Agent interfaces · Usability for models
Reflexive Agent Design: The AI Was Not Simulating a User — It Was the User
When the production user of a system is an AI — a wiki behind an MCP, an agent-facing API — usability research inverts. Real usage can be generated on demand, every walk is an inspectable behavioural trace in the same medium as the repair, and competing designs can be replayed against identical traffic. Architecture evolves through AI-generated walks instead of waiting for humans.
In brief
- The founding joke is the finding: mid-experiment the coding agent asked for “more users” — it was already the main user.
- Reflexive Agent Design: AI uses the system, paths are recorded, AI inspects them, generates more traffic when thin, and designs are replayed against the same usage.
- Three-mode ladder: cheap trace inspection first, Git-pinned counterfactual replay second, active evidence generation only when the corpus fails to exercise the new behaviour.
- Grade paths, not only answers — the dangerous cell is a bad path with a right answer.
- Vary models and prompt styles, or you optimise for one model’s habits rather than affordances legible to the agent class.
Mid-afternoon, mid-experiment, the coding agent said something ordinary and ridiculous: we needed more users to generate walk data, to see whether the new pattern held. It had not noticed that it was the main user of the walks. So I opened ChatGPT, asked a handful of real questions, and made it walk the wiki through the MCP. Then I switched to the coding window and asked it to review those walks — what ChatGPT used and ignored, which code paths it followed, which patterns it preferred. We reorganised the application around those patterns the same afternoon.
That loop is the whole book in miniature. The funny part is also the profound part:
The AI was not simulating a user. It was the user.
You do not need to recruit humans to generate more WikiWalks when the intended consumer of the system is principally an AI navigator. ChatGPT using the MCP was legitimate production-like traffic. That is not a metaphor and it is not a usability cosplay. It is the user class the product was built for.
What “reflexive” means
A system is under Reflexive Agent Design when six conditions hold:
- AI is a real user of the system.
- Its interaction path is recorded in an inspectable form.
- AI can analyse those paths as behavioural evidence.
- It can generate more representative usage when evidence is thin.
- Competing designs can be replayed against the same usage.
- Findings update the system the AI will subsequently use.
That is stronger than ordinary dogfooding. The user, the analyst and the design assistant can all be AI instances — while you remain the architect and the judge.
We already had language for half of this. File Back the Walk treats the answer and the path as two different artefacts: the answer records what the walk concluded; the path records what the walker actually did, including abandoned branches and untouched regions. Querying improves the map because missing edges and cold pages become janitor work rather than discarded exhaust.
Reflexive Agent Design extends that idea from use traffic to improve the wiki to something sharper:
Use AI-generated traffic to evolve the architecture through repeated observation and replay.
Page-level janitor work is still useful. This book is about falsifying designs.
Three evaluation modes — a progressive ladder
You do not need to replay everything continuously. Escalate cost only when evidence fails.
1. Trace inspection
No replay required. Give an AI a collection of recorded walks and ask the questions a good usability researcher asks while watching people struggle with an interface:
- Why did walkers repeatedly perform broad searches?
- Where did they backtrack?
- Which tool or edge was consistently ignored?
- Which paths were unexpectedly long?
- Where did they reach the right answer for the wrong reasons?
- What behaviour does the system appear to be eliciting?
The walk is particularly useful because each step is a legible decision in the same medium as the repair. A reviewer can name the exact wrong turn and change the map or the tool contract at that point. In the WikiArmy session, inspection alone was enough to hear the diagnosis in plain language: the users are doing dumb things because we wrote the application dumb — or because we need to allow for the behaviour the design is currently punishing.
Concrete defect from inspection alone (WikiArmy)
ChatGPT, as a real MCP user, repeatedly reached for broad search and secondary pages while under-using edges that should have been the shortest path to canonical material. Reviewing the walks in the coding window made the defect obvious without a full counterfactual harness: tool descriptions and graph affordances were training the wrong habit. The same-afternoon change was not “more documentation for humans” — it was reorganisation of navigation structure and tool contracts around the observed agent patterns. That is the minimum proof that inspection is not hand-waving: one recorded defect, one structural change, one tighter next walk.
2. Counterfactual replay
Restore a known world state and replay the same queries under alternative designs:
Then compare path length, search calls, redundant reads, canonical-source reach, abandoned branches, time and token cost, answer quality, and — critically — unsupported lucky answers. This is counterfactual design replay over AI cognition, not only over software outputs.
Worked comparison shape (tool contract A vs B)
Pin a wiki commit and agent configuration. Hold twelve representative questions fixed. Under design A, the agent must discover canonical pages via free-text search; under design B, a structured “open_canonical(entity)” tool is advertised first in the boot profile. Score each walk on path length, search-call count, and whether the canonical source was opened before the answer was synthesised. The interesting outcome is not only “B is shorter.” It is whether A’s green answers were lucky priors that never opened the canonical page — the bad-path/right-answer cell that output-only evals miss.
3. Active evidence generation
When analysis says “we need more user walks,” dispatch actual AI users:
That is not merely synthetic testing. It is automated usability research for an AI-native interface. The shared walker makes it especially powerful: query, ingestion and janitor roles can be exercised through one path harness when they share the same navigation machinery.
Progressive rule
Review existing walks → infer defects → change design. Only when evidence is insufficient: restore snapshot → replay. Only when the corpus does not exercise the new behaviour: generate new real AI usage.
Path quality beats answer quality alone
A system can return the right answer through a poor path: never open the canonical page, search too broadly, lean on model priors, ignore the graph, stumble onto a secondary mention. That looks successful until the lucky prior stops holding.
Path Testing makes the distinction explicit:
| Path | Answer | Meaning |
|---|---|---|
| Good | Right | Real success |
| Good | Wrong | Synthesis / reasoning defect |
| Bad | Right | Unsupported lucky answer |
| Bad | Wrong | Navigation defect |
The third cell is invisible when you only test outputs. Industry tooling is starting to catch up: agent evaluation platforms now capture full trajectories — tool selection, arguments, loops, retrieval paths — not only final strings.12 That movement is necessary. It is still incomplete if trajectories are used only to validate a known change rather than to discover what the design should become.
For a news-queue system, the equivalent is not merely “did the interesting signal eventually enter the queue?” It is also: did it enter for the correct reasons, through the right case, with appropriate canonicality, at the right time?
Two streams: WikiWalk vs queue evolution
On the radar work that sits beside this essay — the signal-case queue and its cascade ledger — we retained two related but distinct replay streams.
WikiWalk stream — is the graph legible?
Queue evolution stream — does the serial attention mechanism behave?
Later events might promote a canonical anchor or merge cases. The first stream tests semantic navigation. The second tests whether attention is allocated sanely over time. Product siblings own the queue design; this practice owns the instrumentation that lets those designs be falsified under AI use.
Git makes the world restorable
A replay begins from a precise tuple:
Restore the wiki commit, restore the queue checkpoint, branch the replay, feed events from offset N, record decisions and walks, compare with baseline. You do not re-ingest ninety days for every experiment. Periodic checkpoints, append-only event logs, Git-versioned wiki state, and versioned prompts/tools/model identifiers are enough to cover the last two hours, two days, or seven days from an exact historical position.
Reflective optimisers in the research literature — notably GEPA’s loop of execute, capture full traces, diagnose in language, mutate a component, retain a Pareto frontier — show how much can be learned when execution traces stay readable rather than collapsed into a scalar reward.3 The harder case in design work is that the evaluation function itself is being discovered: while studying walks, you realise that canonical-source reach or queue stability should have been measured in the first place. The harness co-evolves with the design.
The main risk: one AI teaching the system its own habits
Because AI is the intended user, optimising for AI behaviour is correct. Optimising for one model, prompt style, or initial tool preference is not. Use variation across frontier and utility models; fresh contexts; terse and conversational questions; direct and indirect formulations; users who know the wiki vocabulary and users who do not; tool descriptions and boot profiles; deliberately delayed or missing information.
The aim is not to make one ChatGPT session walk beautifully. It is to make the system’s affordances legible across the class of agents intended to use it.
Why the synthetic-user critique does not bite here
Teams increasingly use LLMs as synthetic users to generate test conversations and broaden evaluation coverage. Research warns that LLM-simulated users can systematically differ from humans — less diverse behaviour, weak correlation with human preference, shallow personalisation, and misleading design preferences.45
That warning is real for human products. It applies much less strongly when ChatGPT is not pretending to be your human customer. The real production user of the wiki is an LLM operating through the MCP. Its tool choices, searches, backtracking and page reads are genuine usage behaviour from the intended user class. Nothing is simulated. The validity critique dissolves by ontology, not by hand-waving.
What this is not
This essay supplies the instrumentation and the evaluation ladder. It does not absorb the full design-evolution loop — candidate breeding, future-leakage-safe harness racing, and the build boundary — which lives in Replay-Driven Design Evolution. It does not re-derive File Back the Walk’s write-back economics. It does not treat “blast ten sub-agents at the architecture” as the centre: multi-agent systems can consume an order of magnitude more tokens than chat, and they help mainly when work truly parallelises.6 Sub-agents make good experimental instruments. They make poor miniature architects.
The deeper loop, once you see it, is almost musical:
The writer rehearses the read, the reader leaves a trace, the trace tests the design, and the redesigned system changes the next read.
When AI is the principal user, it can cheaply generate the usage, inspect its own behavioural evidence, and run counterfactual versions of its future working environment before the design is committed. That is not a testing trick. It is a design practice for a world where the user is already a model.
Start this week
Pick one agent-facing surface. Record twelve walks from at least two models. Spend one session on inspection only — no replay — and force yourself to name one design defect visible in the path. Fix the affordance. Walk again. Escalate to Git-pinned replay only when inspection cannot discriminate. Generate new traffic only when the corpus does not exercise the behaviour you care about.
That is the ladder. Climb it in order.
References
- LangChain. "LangSmith: AI Agent & LLM Model Evaluation Platform." — "Agent evaluation in LangSmith captures the full trajectory of steps, tool calls, and reasoning your agent took." https://www.langchain.com/langsmith/evaluation
- LangChain. "LangSmith Evaluation" documentation. — Datasets from production traces; observe → add failing traces → change → replay → deploy. https://docs.langchain.com/langsmith/evaluation
- Agrawal et al. "GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning." arXiv:2507.19457, 2025. — Reflective mutation from full execution traces; Pareto frontier of candidates. https://arxiv.org/abs/2507.19457
- Yoon et al. "Evaluating Large Language Models as Generative User Simulators for Conversational Recommendation." arXiv:2403.09738, 2024. — "Discrepancies include low item diversity, low correlation with human preference, lack of request personalization, and incoherent feedback." https://arxiv.org/abs/2403.09738
- "Synthetic Heuristic Evaluation: A Comparison between AI…" arXiv:2507.02306, 2025. — Growing use of AI-simulated users; need rigorous comparison to human evaluation. https://arxiv.org/html/2507.02306v1
- Anthropic. "How we built our multi-agent research system." June 2025. — Agents ~4× tokens vs chat; multi-agent systems ~15× tokens vs chats. https://www.anthropic.com/engineering/multi-agent-research-system