Wink Pings

Most Agents Don’t Need an Agent: Anthropic’s Six Patterns, and the Harness Layer That Should Be Fixed First

Anthropic breaks agent building into six patterns, and most tasks should stop at the first one. Trackmind’s long piece on the harness supplies the other half: beyond the model, the task contract, map file, evidence gate, permissions, retry cap, and state file are what determine whether an agent can actually deliver.

First, look at this diagram.

Agent pattern diagram

Many teams take a very predictable path when building agents: start with complex orchestration, then change the prompt after it fails, then switch models, then stuff in documents. When Trackmind summarized Anthropic’s material, it offered a more deflating answer: most tasks don’t need a “real agent” at all, just the simplest pattern that works.

Six Patterns, and the First Should Stop Most Requests

Anthropic breaks building into six patterns:

  1. Augmented LLM: a model, plus tools, plus memory. Most so-called agents should stop here.
  2. Prompt chaining: split the task into steps, check between steps, then move to the next step.
  3. Routing: classify the input first, then route it to the appropriate prompt, or to a cheaper model.
  4. Parallelization: split and run in parallel, then merge; or run the same task three times and vote.
  5. Orchestrator-workers: one model plans, dispatches workers, and finally merges the results.
  6. Evaluator-optimizer: generate, critique, revise, and loop until it passes.

Only when none of these fit should you consider a real agent: a loop with tools, a stop condition, and human checkpoints.

The power of this set of patterns lies in the order. Don’t start by asking “How do we make the agent more autonomous?” Start by asking “Does this task deserve a loop at all?” A comment from Sogav online was harsh and close to reality: half of all agents are just a for loop plus a very confident system prompt, and those are exactly the ones that work. Russell put it more directly: most agents should just be a good prompt.

Beyond the Model, There Is Another Layer

Trackmind’s long piece pushes the question down one layer. The original proposes a formula: Agent = Model + Harness. The model handles reasoning and proposing the next step; the harness handles everything else: what the model can see, which tools it can touch, what is remembered between sessions, what counts as done, what is forbidden, and what happens after an error.

The original cites two public data points. LangChain raised a coding agent from 52.8% to 66.5% on Terminal Bench 2.0 without changing the model; what changed was the prompt, tools, and middleware. OpenAI described an experiment in which three engineers flooded a repository with about 1,500 PRs, with every line of code written by Codex. Early progress was slow, and their diagnosis was that the environment description was not clear enough. The engineers’ work shifted from writing code to designing the environment, expressing intent, and building feedback loops.

Trackmind also records a smaller experiment. Twenty real tasks, the same model, the same base prompt, the same machine, run twice. Run A was given only the bare prompt. Run B added a harness built over a weekend: a short contract for each task with a “done when” line; a map file of no more than 40 lines; a mandatory test gate before completion; a retry cap of three; and a rules file stating what can and cannot be touched.

Results: tasks that passed without human intervention went from 8/20 in Run A to 16/20 in Run B; runaway retry loops went from 5 to 0; average cost per accepted task went from about $4.10 to $1.60; daily babysitting time dropped from about two hours to 25 minutes. The model was not changed, and the prompt wording was not changed either.

That is the value of the harness. It doesn’t make the model smarter; it reduces how much of the model’s intelligence is wasted on the wrong world.

Seven Failures, Seven Fixes Outside the Model

The original lists seven high-frequency failures, and the fixes all sit outside the model.

Going off task. Write the task contract first, including the goal, constraints, deliverables, “done when,” items requiring approval, and what to do when blocked. Without “done when,” the agent will casually solve a simpler problem and then calmly report success.

Getting lost in the codebase. Give a map, not a manual. Put an AGENTS.md or CLAUDE.md of no more than 40 lines in the root directory, pointing to architecture, tests, product rules, and security docs. Context is an attention budget, not storage space. The more you dump in, the less it understands.

Saying it’s done when it isn’t. Turn evidence into a completion gate. In the original bare run, the agent reported all 20 tasks as complete, but only 8 survived actually running the tests. Only when a check.sh prints GATE: PASS does it count as complete. Separate the checker role from the builder role; the verifier’s question is not “Does this look good?” but “What reason is there to reject it?”

Doing things without approval. Put permissions outside the model. Allow reversible operations and leave an audit trail; require approval for externally visible operations; block hard-to-reverse operations entirely. The model suggests, the harness decides, and the tools execute.

Retrying the same error over and over. Classify failures first, then set caps. Timeouts, bad parameters, missing information, test failures, and permission denials each map to different actions. Stop when the same error appears twice; by default, escalate to a human after three. The original author mentions an overnight run that retried a failing API 41 times; after adding a three-retry cap, the agent stopped and left an attempt log, which turned out to be a useful debugging report.

Forgetting what was decided earlier. Keep state outside the conversation. A STATE.md records the current step, decisions made and why, artifacts, risks, and next steps. A new session reads the state, not a lossy recollection.

Repeating the same kind of mistake. Turn lessons into infrastructure. First explain, then make a checklist, then automate checks, and finally enforce. “UI code must not import the data layer directly” written in a prompt is a wish; written into a lint rule, it is a wall.

Don’t Build a Platform to Start

The original gives a gradual path. Level 0 is prompt plus model, suitable for low-risk, fast tasks. Level 1 adds a contract, a short map, and a small number of clearly defined tools. Level 2 adds state, real checks, and bounded loops. Level 3 adds permissions, tracing, recovery paths, and human approval. Before adding each layer, you should have seen with your own eyes the failure it is meant to prevent.

One practical test: every agent guideline should be traceable to a real incident. If you can’t point to an incident, that rule is probably noise.

Models change every few months. Contracts, tests, maps, state, and permissions stay. What most agent projects lack is not a smarter model, but this peripheral system willing to do the dirty work.

Trackmind original post: https://x.com/0xTrackmind/status/2121647160387092518

Long-form article link: https://x.com/i/article/2113375170392203264

发布时间: 2026-11-15 17:31