agent-friendly-cli/docs/plan.md

Plan — agent failure taxonomy and the new evaluator

Status: agreed, not yet built. All three arms paused. This supersedes the fix plan I issued on 2026-08-21 morning.

---

0. The question

What makes a CLI interface agent-friendly?

That is what we are trying to answer. It is a general question with a general answer — a set of design properties that hold beyond botmap.

Everything else is instrumentation. botmap is the subject we experiment on, not the thing we are shipping. GEPA, the three arms, the question bank and the evaluator all exist to produce evidence for the question above.

Three consequences:

• We do not touch botmap/evals/. Not ours, not the goal. We build our own evaluator; botmap's stays exactly as it is.
• A run that moves no score can still be a success. If it tells us which CLI properties let an agent recover unaided, that is the result we came for.
• The deliverable is a document, not a patch. See section 0.1.

When something is ambiguous, ask "does this teach us what makes a CLI agent-friendly?" — not "does this make the number go up?"

---

0.1 The deliverable

docs/agent-friendly-cli.md — a living list of design properties, each backed by a measurement. This is the output of the whole project. Everything in the rest of this plan exists to add evidenced lines to that file.

Each entry has the same shape. The change and its effect are mandatory — a property observed but never fixed is a hypothesis, not an answer.

PROPERTY    what an agent-friendly CLI does
VIOLATION   the failure class that appears when it is missing
STATUS      hypothesis | confirmed | refuted

BEFORE      the measured trace of an agent defeated by its absence
            - what it typed, what came back, how many commands it burned
            - what it finally concluded (often: a confident wrong answer)

CHANGE      the actual change, and WHICH LEVER it was
            - lever: tool | instructions
            - the diff, or the exact text added
            - why that lever and not the other

AFTER       the measured trace of the same question, same conditions,
            with the change in place
            - did the agent recover unaided?
            - commands before/after, turns before/after
            - did it reach the right answer?

VERDICT     confirmed | refuted, and the delta that supports it

Two tiers of evidence, and why the distinction matters

Not every property can be confirmed cheaply. There are two levels, and we should be explicit about which one an entry has:

Tier 1 — the information existed and was not surfaced. The differential probe proves this. Cheap: CLI calls only, no model spend. Example: --class recreation → 0, subtype=recreation → 86. The tool knew. This makes a property a candidate. It does not confirm it.

Tier 2 — we surfaced it, and the agent did better. Requires a paired run: same question, same conditions, before and after the change. Example: with the near-match hint on count, the agent reaches bus_station in 1 command instead of 7 — or does not, in which case the property is refuted. Only Tier 2 confirms.

Tier 1 is how we find candidates cheaply. Tier 2 is how we spend our budget deliberately, on the candidates most worth proving.

A refuted property is a real result. If we add a hint and the agent ignores it anyway — class F — then "name the fix" was not the missing property, and something else is. That finding is as valuable as a confirmation, and cheaper than shipping a fix nobody benefits from.

Which lever is part of the answer, not an implementation detail

Every entry records whether the fix went in the tool or the instructions, because "what makes a CLI agent-friendly?" has a legitimate answer of the form "nothing in the CLI — tell the agent in the prompt."

If most confirmed properties turn out to be instruction-side, that is a finding about where agent-facing design effort should go. If they are mostly tool-side, that is the opposite finding. We cannot know without recording it every time.

The structural insight this exposes

The failure taxonomy and the answer are the same list, seen from opposite sides. Every failure class is a design property being violated:

Failure class	The property it violates
C c-vocabulary	never return empty without saying why
C c-truncated	never silently truncate output
C c-dropped-input	never silently discard input
C c-wrong-column	if a value exists elsewhere, say where
C c-wrong-entity	confirm what you resolved, not just that you resolved
B (present)	name the fix, not just the problem
D	emit progress on long operations
F	a hint the agent ignores is not a hint that worked

So the classifier is not just a scorer. It is the instrument, and its readings are candidate design properties. That is why the taxonomy has to be right before anything else runs.

The draft answer, from evidence we already have

These come from the 20 measured defects. Every one is currently STATUS: hypothesis — we have the BEFORE trace for each and no AFTER for any. They become the work queue: each needs a change and a paired run before it can be claimed as an answer.

1. Never return an empty result without saying why. A zero that could mean "none exist" or "you asked wrong" is the most damaging output a CLI can produce. (bus_stop → 0; landuse --class beach → 0 while 67 exist under land)
2. Name the fix, not just the problem. (the near-match hint fires on places but not on count, where the docs tell agents to start — the agent ran seven commands hunting a name the tool already knew)
3. Never silently discard input. (--class trunk --class primary keeps only the last; no warning)
4. Never silently truncate output. (--top 200 omits bus_station; --top 5000 returns all 963 — the agent concluded the category did not exist)
5. Make discovery a first-class operation. (no categories --search, so finding a slug means guessing --top N and grepping)
6. Advertise only values that work. (--class help lists subtype values that return zero)
7. Confirm what you resolved. (where "Malta, MT" → Malta, Montana, silently)
8. Emit progress on long operations. (19m42s of total silence reads as a hang; the agent abandons a correct command)
9. Recovery advice must actually work. (no_match recommends a command that takes ten minutes and prints nothing)
10. One obvious spelling should work. (--json only functions before the subcommand, and breaks the first example an agent reads)

Note what these have in common: almost none are about the CLI's functionality. The commands work. What is missing is the CLI telling the agent what happened — which suggests the answer to our question is mostly about observability and self-description, not features. That is a hypothesis the runs should test.

---

1. Decisions taken

#	Question	Decision
1	Three axes or a richer label list?	Three axes. Changing record.json is fine — write a new record format, keep the old one untouched.
2	Build the differential probe?	Yes. It is how we learn whether an agent could have recovered, and what would have let it.
3	Agent-side failure in scope?	Record it. We want to know whether hints actually help the agent self-correct. Decide what to do with it next iteration.
4	Which exam first?	Neither — build a new shared evaluator module used by all three arms.
5	Sabotage validation?	Yes.
6	Existing runs?	Leave them alone. No re-scoring, no rewriting history. New runs write new records.

We accept that new numbers will not be comparable to old ones. That is a deliberate cost, taken once.

---

2. Architecture — one shared evaluator

Today the scoring logic exists twice, with incompatible contracts (botmap's classify_error returns None for clean; autoresearch's classify returns "clean" and never None). That drift is how we ended up with the same bug in two places.

New module: autoresearch/agenteval/. One implementation, imported by all three arms.

autoresearch/agenteval/
  contract.py    the record schema — written FIRST, everything else builds to it
  taxonomy.py    three-axis classifier
  probe.py       differential probe (the class-C detector)
  score.py       class-weighted scoring
  explain.py     turns classified failures into fix instructions for the proposer
  sabotage.py    fixtures that prove the classifier actually fires

botmap/evals/ is untouched and stays on its own path. If we later want to compare, we run our evaluator over botmap's recorded attempts — we do not edit theirs.

---

3. The data contract — build this first

Everything else depends on this shape, so it lands before anyone writes a classifier or a scorer. Nobody starts their component until contract.py is merged.

New file per attempt: record-v2.json. The old record.json is still written, unchanged, so nothing existing breaks.

{
  "schema": "agenteval/2",
  "question_id": "bus-stops-cambridge",
  "repeat": 1,
  "calls": [
    {
      "argv": ["count", "-t", "place", "--in", "Cambridge, MA",
               "--where", "categories.primary=bus_stop"],
      "exit_code": 0,
      "stdout_head": "0",
      "stderr_head": "[botmap] Ambiguous --in ...",
      "duration_s": 12.4,

      // the three axes
      "outcome":  "empty",        // ok | empty | error | degenerate
      "blame":    "tool",         // tool | agent | environment
      "recovery": "unguided",     // guided | unguided | n/a

      "class": "C",               // A-F, derived from the three axes
      "subtype": "c-vocabulary",  // only for class C
      "evidence": "bus_stop absent from place taxonomy at all levels; nearest bus_station",
      "probes": [
        {"kind": "vocabulary", "ran": "categories -t place --top 5000 | grep bus_stop",
         "result": "absent", "conclusive": true}
      ]
    }
  ],
  "agent_side": [
    {"kind": "ignored_hint", "at_call": 3,
     "detail": "hint offered bus_station; next 4 calls did not use it"}
  ],
  "tools_used": {"Bash": 5, "Skill": 1, "WebSearch": 2},
  "botmap_calls": 0,
  "answer": {"text": "There are no bus stops in Cambridge.", "verified": null}
}

Three things to note:

• class is derived, never stored independently. It is a function of the three axes. If they disagree with the class, the axes win.
• probes records what the scorer did to reach its verdict, so a classification can always be audited. No unexplained labels.
• answer.verified is null for now. Ground truth is a later step; the field exists so adding it does not change the schema again.

---

4. The taxonomy classifier

4.1 The three axes

OUTCOME    ok         the call did what the agent needed
           empty      succeeded, returned nothing — MEANING UNKNOWN
           error      refused
           degenerate succeeded, but by an unusable route

BLAME      tool       botmap could have done better
           agent      botmap behaved correctly; the agent misused it
           environment not the tool's fault (network, quota, stale data)

RECOVERY   guided     the tool named a next action
           unguided   the agent was left to guess
           n/a        nothing to recover from

4.2 The six classes

Class	Axes	Meaning	Score
A Hard failure	error + unguided	Refused, agent stuck. Raw traceback.	heavy penalty
B Soft failure	error + guided	Refused, and said how to fix it.	near-free
C Silent wrong	empty + unguided	Succeeded, answer wrong, said nothing.	heaviest
D Degenerate	degenerate	Right answer, unusable route.	proportional to waste
E Environment	blame=environment	Network, quota, stale release.	excluded from scoring
F Agent-side	blame=agent	Tool was fine; agent misused it.	recorded, not charged to the tool

Web search: record it, do not judge it yet

hotel-density-two-countries ran zero botmap commands — two web searches, a citation of official hotel statistics — and scored 1.00.

We are not building a class or a scoring rule for this yet. We record the plain fact and decide what it means once we can see how often it happens:

"tools_used":   {"Bash": 5, "Skill": 1, "WebSearch": 2},
"botmap_calls": 0

That is all. No grounded judgement, no invalidation, no penalty. Both numbers fall straight out of the transcript we already parse, so it costs nothing.

Why hold off: deciding why an agent web-searched needs judgement we do not have data for. The two plausible reasons point in opposite directions — searching for vocabulary ("what is this category called") suggests the CLI's own discovery failed, which is a design finding; searching for the answer suggests the attempt is not measuring the CLI at all. We will be able to tell those apart once we have counts. Guessing now would bake in a rule we cannot support.

Web search stays allowed regardless. A real agent has it, and removing it would make the test less like reality.

Class B is the headline change. Today a hint is punished twice — counted as an error, and disqualified from being the recovery that redeems an earlier error. Under this taxonomy a hint is close to free and satisfies the recovery test. A tool that explains itself is doing its job.

Class C is the other headline. Today it is invisible — worse than mislabelled. A crash is honest; a confident wrong answer is not. C carries the heaviest penalty of any class.

4.3 Class C sub-types

Each has a different fix, so each gets its own name:

Sub-type	What went wrong
c-vocabulary	the value does not exist anywhere
c-wrong-column	the value exists, in a different field
c-wrong-type	the data lives under a different verb
c-dropped-input	a flag was silently discarded
c-truncated	the answer was cut off by a limit
c-wrong-entity	resolved to the wrong place
c-unknown	empty, and no probe explained why

c-unknown is deliberate. An honest "we could not determine why this was empty" is worth more than a guess, and its frequency tells us how good our probes are.

---

5. The differential probe

The idea: we cannot ask "is this zero correct?" But we can ask "does this zero survive a change that should not matter?" If changing something irrelevant makes the answer appear, the original was wrong.

Probes run after the agent finishes, from the scorer, against the same tool build. They are never in the agent's transcript — the measurement must stay out of the thing being measured.

Probe	Trigger	Action	Concludes
vocabulary	any empty with a value filter	is the value in the published taxonomy at all?	c-vocabulary
column swap	empty with --class/--where col=	retry against subtype / subclass	c-wrong-column
type sweep	empty with -t X	retry the same filter across other types	c-wrong-type
limit raise	any result whose length == the limit	re-run with a much larger limit	c-truncated
argv echo	repeated flags present	did the tool act on all of them?	c-dropped-input
entity check	any --in / place qualifier	does the resolved entity match the qualifier's region?	c-wrong-entity

Rules:

• Probes are cheap CLI calls, no model tokens. Budget them per question and log the count.
• A probe that finds nothing is recorded as inconclusive, not as "fine".
• If no probe fires, the class is c-unknown — never silently ok.

Why this is the most valuable part

It answers the real question. When a probe fires, we learn exactly what the tool would have needed to say for the agent to recover unaided:

--class recreation returned 0. The same value as subtype returns 86. The tool had everything it needed to say "recreation is a subtype, not a class — try --where subtype=recreation" and said nothing.

That sentence is a CLI design requirement, discovered empirically. Collecting those across 30 questions is the actual output of this experiment.

Follow-on we expect: once we see which probes fire most, the fix may be a skill.md instruction ("if a filter returns zero, try it as a subtype before concluding none exist") rather than a tool change. Both are valid answers to our question, and the probe data is what tells us which.

---

6. Scoring changes

Replace the single error count with class-weighted terms.

score = w_correct  * outcome_quality
      + w_recovery * recovery_quality
      + w_effort   * effort

• Class E attempts are dropped, not scored. Environment failures must never reach the optimiser as tool defects.
• Class F is recorded and reported, not charged. A tool cannot be optimised into fixing agent stubbornness. Counting it would send the proposer hunting a fix that does not exist.
• Class B barely costs anything, and satisfies the recovery test for a prior failure.
• Class C dominates. One silent wrong answer should outweigh several honest refusals.

Weights are not fixed here. Set them once we can see the real class distribution from a first run — picking them now would repeat the mistake of weighting a term that cannot move.

A likely side effect worth watching

The exam is currently saturated: 21 of 30 questions score a perfect 1.00. Many of those are perfect only because class C is invisible. Once C is detected, those questions should start failing — which restores headroom without writing a single new question.

If that happens, the saturation problem was a symptom of the taxonomy, not of the question bank. We find out on the first run. Do not rewrite questions until we have looked.

---

7. Feedback changes (explain.py)

The README's premise is that the proposer improves by reading why something failed. Today it reads:

PROBLEM: 1 failed command(s): bad_category_value.

Under the new taxonomy, with probe evidence attached:

CLASS C (silent wrong) - c-vocabulary
  The agent ran: count -t place --in "Cambridge, MA" --where categories.primary=bus_stop
  Result: 0 rows, exit 0, nothing on stderr.
  Probe: `bus_stop` does not appear in the place taxonomy at any level.
         Nearest real value: `bus_station` (L3, travel).
  The tool had the information needed to say this and did not.

That is a fix instruction, not an error code. It names the mechanism, the evidence, and the missing behaviour.

---

8. Sabotage validation

We are building a detector for failures that are invisible by definition. We therefore cannot trust it until we watch it fire.

sabotage.py holds fixtures with known answers — at minimum one per class and one per class-C sub-type — and asserts the classifier produces the expected verdict. A silent-wrong fixture that classifies as clean is a build failure.

This is not optional polish. The one thing we know about silent failures is that test suites do not catch them: in the production study, ~0% were caught by 4,286 unit tests during the silent phase, while ~70% were caught by a human reading output. Sabotage fixtures are how we avoid being in that 0%.

---

9. What each arm does

Nobody starts until contract.py is merged. It is the interface all three build against.

Arm B — the contract and the probe

1. contract.py — record-v2 schema, writer, validator. Blocking. Do this first and tell me the moment it lands.
2. probe.py — all six probes, with a per-question call budget and inconclusive handling.
3. Wire record-v2 alongside the existing record. Old path keeps working.

Arm C — the classifier and the scorer

1. taxonomy.py — three-axis classifier, class derivation, C sub-types. Its existing network_failure work moves here as class E; quota_exhausted gets built (it was designed and never committed).
2. score.py — class-weighted scoring, E dropped, F recorded-not-charged. Leave weights as named constants with a TODO. Do not tune them yet.
3. Prove the class-B fix with arm A's count-zero-hint candidate: under the new scorer it must score better than baseline, not worse.

Arm A — evidence, explanation and sabotage

1. sabotage.py — fixtures per class and per C sub-type, from real recorded traces. It has the deepest trace knowledge and failure_dataset.yaml already maps 26 questions to the defects they hit.
2. explain.py — the feedback text above.
3. Agent-side (class F) detection: hint offered at call N, not used by N+1.

Me

Sequencing, cross-arm contract questions, and keeping the arms from messaging each other. No decisions taken unilaterally.

All arms — the standing instruction

Every time a probe fires or a class is assigned, ask: what property would the CLI have needed for this not to happen? Write it into docs/agent-friendly-cli.md in the four-field shape from section 0.1.

That file is the deliverable. Your component is how we generate evidence for it, not the point in itself. A run that produces one well-evidenced design property is worth more than a run that moves a score.

---

10. Sequence

1.  contract.py                        Arm B     <- everything blocks on this
2.  taxonomy + probe + sabotage        B, C, A   in parallel, same contract
3.  sabotage passes                    all       gate: no run until fixtures fire
4.  one instrumented run, no optimiser all       just to see the class distribution
5.  read the distribution together     us        decide weights, and whether the
                                                 exam still needs new questions
6.  paired before/after experiments   all       one per candidate property:
                                                 change it, re-run, compare traces

Step 4 is a measurement run, not an optimisation run. Its output is two things:

1. a histogram of failure classes — the first genuinely new information this project will have produced; and
2. the BEFORE traces for every candidate property.

Step 6 is where the answer actually gets made. Each candidate property gets one paired experiment: apply the change, re-run the same questions under the same conditions, and compare traces. Commands burned, turns taken, whether the agent recovered unaided, whether it reached the right answer.

Arm A's three existing candidates are already Tier-2 experiments waiting to run. count-zero-hint is precisely "add the near-match hint" — its paired run confirms or refutes property 2. skill-bus-station is an instruction-lever fix for property 1. They were built to move a score; they are more valuable as controlled before/after experiments, and that is how we should run them.

---

11. Deliberately not doing

• Not editing botmap/evals/. Not ours, not the point.
• Not re-scoring old runs. They stay as history.
• Not tuning weights yet. Not until we can see a real class distribution.
• Not writing new exam questions yet. Detecting class C may restore the headroom on its own. Look first.
• Not resuming any optimiser run until steps 1-5 are done.

---

12. Implementation steps

Ordered. Each step names its deliverable and how we know it is done. Nothing starts until the step above it is finished, except where marked parallel.

Phase 0 — skill isolation (blocking, one flag)

Scope decision (2026-08-21): --setting-sources project only. The other two candidates are deliberately NOT in phase 0 — see below.

0a. Isolate skills. Add --setting-sources project to the claude -p invocation in runner.py.

Why: measured 2026-08-21 — without it the agent under test sees 30+ of the operator's personal skills (herdr, context-lens, lavish, mattpocock-skills:*, find-skills). That is an artifact of one machine: nobody else could reproduce our numbers, and neither could we after changing our own setup. With the flag: 13 skills, botmap plus Claude Code built-ins.

Done when: a probe run lists botmap and built-ins only, and a normal question still completes.

Owner: Arm B. Two cheap probe calls, no other spend.

---

Deliberately not in phase 0

Tool restriction — NOT changed. --allowedTools Bash does not actually restrict; a recorded attempt invoked Skill, Bash×5, ToolSearch and WebSearch. We are leaving this alone because a real agent has those tools too. Removing them would make the harness less like real use, not more.

But it has a consequence we must not lose: when an agent answers partly by web search, "it succeeded" no longer cleanly means "the CLI was drivable". So the open suggestion is to record the bypass rather than block it — a per-attempt flag for "the agent reached outside botmap, and at which call". That is an observation, not a restriction, and it is arguably its own signal about CLI usability: a CLI an agent routes around is telling us something.

Not decided. Raise at phase 5 with real numbers.

Invocation recording — not in phase 0. Logging the flags, model, setting sources and resolved tool list into the run summary. Cheap and non-behavioural, but out of scope for phase 0 by the same decision. Worth folding into contract.py in phase 1 if it lands naturally there.

Phase 1 — the contract (blocking)

1a. agenteval/contract.py.

@dataclass(frozen=True)
class Probe:        kind: str; ran: str; result: str; conclusive: bool
@dataclass(frozen=True)
class CallVerdict:  outcome: str; blame: str; recovery: str
                    cls: str; subtype: str | None
                    evidence: str; probes: tuple[Probe, ...]
@dataclass(frozen=True)
class Record2:      schema: str; question_id: str; repeat: int
                    calls: tuple[...]; agent_side: tuple[...]; answer: dict

def derive_class(outcome, blame, recovery) -> str   # the ONLY place class is computed
def write(path, record) -> None
def load(path) -> Record2
def validate(raw: dict) -> list[str]                # returns problems, never raises

Done when: round-trips a hand-written record, validate rejects a record whose stored class disagrees with its axes, and Arms A and C can both import it.

Owner: Arm B. Announce the moment it lands — two arms are blocked on it.

Phase 2 — three components, parallel, same contract

2a. agenteval/taxonomy.py — Arm C

• classify(call, probes) -> CallVerdict
• the three axes; class derived only via contract.derive_class
• class E absorbs its existing network_failure; build quota_exhausted (designed, never committed)
• Acceptance: a did you mean: call classifies B, scores better than baseline, and satisfies the recovery test. Arm A's count-zero-hint is the fixture.

2b. agenteval/probe.py — Arm B

• probe_empty(call, tree) -> list[Probe] — the six probes from section 5
• per-question call budget, logged; inconclusive recorded as inconclusive
• probes run from the scorer, after the agent finishes, never in its transcript
• Acceptance: on the recorded --class recreation case it returns c-wrong-column with the 0-vs-86 evidence attached.

2c. agenteval/sabotage.py + explain.py — Arm A

• fixtures: one per class, one per class-C subtype, drawn from real recorded traces (failure_dataset.yaml already maps 26 questions to their defects)
• explain(record) -> str — the fix-instruction feedback from section 7
• agent-side (class F) detection: hint offered at call N, unused by N+1
• Acceptance: every fixture produces its expected verdict; a silent-wrong fixture classifying as clean is a build failure.

Phase 3 — the gate

3a. Sabotage suite passes. No run of any kind until it does. We are building a detector for failures that are invisible by definition; the one thing known about them is that test suites miss them.

3b. Run the classifier over the 60 already-retained attempts from baseline-noise-run1-3009509. Costs nothing — no model calls — and gives the first real class distribution before we spend anything.

Phase 4 — one instrumented measurement run

4a. 30 questions × 2 repeats, new evaluator, no optimiser. Output: the class histogram, and a BEFORE trace for every candidate property. Explicitly not: a score to compare against anything.

4b. Check the saturation prediction: do questions that scored 1.00 under the old scorer now fail? If yes, the exam was never the problem — the taxonomy was.

Phase 5 — read it together

Weights get set here, from the observed distribution, not before. Also decided here: whether the question bank needs new questions after all.

Phase 6 — paired before/after experiments

One per candidate property: apply the change, re-run the same questions under the same conditions, compare traces. Arm A's three candidates are the first three, already built.

Each produces a docs/agent-friendly-cli.md entry with BEFORE, CHANGE, AFTER and VERDICT — confirmed or refuted.

What is NOT in these steps

• No optimiser run. GEPA stays off until phase 6 at the earliest.
• No weight tuning before phase 5.
• No new exam questions before 4b says we need them.
• No edits to botmap/evals/.