Anthropic reveals 3 smart patterns for building leaner Claude agents

Anthropic co-founder Chris Olah has a saying about frontier AI: systems like Claude are grown more than they are built. Researchers set the initial conditions, but new capabilities emerge unpredictably. That creates a massive headache for builders: most agent frameworks are loaded with rigid assumptions about what models cannot do, and those assumptions turn stale the moment a new model drops.

Anthropic published a practical guide outlining three harness design patterns to balance intelligence, latency, and cost. The core thesis is simple: stop over-engineering the scaffolding. Instead, strip down your harness and let Claude handle its own orchestration, memory, and context.

Let Claude write its own glue code

The most pervasive anti-pattern in agent development is the round-trip token tax. Usually, every tool call dumps its full payload back into the model's context window. If you ask an agent to inspect a single column in a 10,000-row spreadsheet, you pay tokens for 9,999 rows the model never asked to see.

Anthropic's fix is straightforward: hand Claude a code execution tool, like bash or a language REPL. Claude can write code to pipe, filter, and orchestrate tools on the fly, sending only the final distilled output back into context. The results are stark. On BrowseComp, a benchmark for agentic web browsing, letting Opus 4.6 filter its own tool outputs bumped task accuracy from 45.3% to 61.6%.

This also doubles down on what Claude already understands best. Late in 2024, Claude 3.5 Sonnet hit a state-of-the-art 49% on SWE-bench Verified using just bash and a text editor. Today, features like Agent Skills and programmatic tool calling are built on that exact foundation.

Playing Pokémon like a real player

Context management is undergoing the same shift. Instead of bloating system prompts with every possible workflow instruction, Anthropic recommends progressive disclosure. System prompts should only hold brief YAML descriptions of skills; Claude reads full instructions only when needed. It can also prune stale thinking blocks and fork work into subagents, which gave Opus 4.6 an additional 2.8% boost on BrowseComp.

Long-term memory follows the same pattern: let Claude maintain its own scratchpad files rather than bolting on fragile vector databases. Anthropic tested this by letting models play Pokémon. Sonnet 3.5 acted like an obsessive transcriber. After 14,000 steps, it generated 31 files detailing NPC chatter—including duplicate notes on Caterpie and Weedle—while remaining stuck in the second town.

Opus 4.6, at the exact same step count, had three gym badges and just 10 structured files. Instead of transcription, it kept tactical post-mortems: noting Bellsprout attack combos, item management limits, and maze geometry. In search benchmarks, a simple memory folder pushed Sonnet 4.5 from 60.4% to 67.2% on BrowseComp-Plus.

Finally, Anthropic warned against thrashing prompt caches, which slash input costs by 90%. Keep static tools and instructions at the top, avoid switching models within a session, and reserve rigid, declarative tools strictly for safety barriers, user confirmations, and audit logging.

Why it matters

This post is a reality check for the AI engineering ecosystem. Over the past two years, an entire industry of bloated agent frameworks cropped up, trying to micromanage every step with brittle prompt graphs. Anthropic is basically telling developers: delete half your orchestration code and let the frontier model run.

For builders, the immediate win is lower latency and fewer wasted tokens. Shifting multi-step data processing into bash or Python scripts running inside sandboxes is far cheaper than paying frontier token pricing on intermediate noise.

We think Anthropic's philosophy is spot-on, but it pushes real complexity onto infrastructure. Letting an agent execute code dynamically requires rock-solid sandbox isolation and bulletproof security guardrails. You can simplify your prompt logic, but you better be prepared to harden your execution runtime.