Anthropic's 4 Ambitious AI Agent Patterns: Speed, Altitude, Depth, Range

Introduction

Felix Rieseberg, engineering manager at Anthropic (responsible for Claude.ai, Cowork, and Claude Code Desktop), observes that AI often falls short not because models have hit a ceiling, but because humans only hand it small, pre‑defined tasks. He argues that "everyone's courage in using AI is still not bold enough" and breaks down more ambitious usage into four directions: Speed, Altitude, Depth, and Range.

1. Speed — Do the Same Thing Faster

Writing emails, filling interfaces, updating reports — AI simply accelerates existing work. The human has already chosen the path; AI only executes. This is the most familiar layer, but it leaves most path‑selection to the human.

2. Altitude — Delegate Outcomes, Not Tasks

Shifting from "fix this crash" to "keep the application stable" raises the task altitude. Felix illustrates with two concrete examples:

Crash fixing: Early 2025 he asked Claude to fix individual crashes. Later he changed the goal to "keep the app stable." Claude then had to continuously monitor new crash reports, prioritize, choose fix paths, reproduce on Windows/macOS/Linux, verify fixes, and decide when to pause for human judgment. This required workflow changes: reading crash reports, locating the offending Git commits, reproducing across OSes, and verifying no regressions.

Quarterly business review: Instead of feeding data and a template to update slides, he asked Claude to first discover what happened and why, then identify three decisions leadership must make with evidence, counter‑arguments, and risks. Further, he proposed designing an early‑warning system that runs in parallel with the existing review for a quarter. The slide deck becomes a by‑product, not the goal.

Felix's test: if you still need a meeting after the output to decide next steps, include "what must be solved after the meeting" in the agent's brief. Higher goals also demand explicit completion criteria, guardrails, rollback procedures, and human‑intervention points.

Shorter Instructions Require More System Support

"Keep the app stable" spans multiple reports, fixes, and environments. State cannot live only in the model context; execution environments must survive failures. Anthropic's Managed Agents architecture evolved from a single container holding session log, Harness, and Sandbox — where a container crash lost everything — to three decoupled components:

Session log: append‑only event log, persists progress.

Harness: calls Claude, forwards tool requests, recovers from log after crashes.

Sandbox: runs code, modifies files; disposable and replaceable. On init it pulls code with a repo token, wires auth to local Git remote; MCP OAuth tokens stay in an external vault. The agent can pull, push, and call MCP but never sees the tokens.

Verification must go beyond the agent's claim. Anthropic's agent eval guide uses a booking example: the agent saying "ticket booked" is not proof; the verifier must query the database for the reservation record. Similarly, "bug fixed" requires test results, screenshots, performance benchmarks, and production metrics.

3. Depth — Use Expert Materials and Methods, Not Just Expert Tone

Adding "act as a 20‑year veteran" only changes phrasing. Depth means giving the agent the raw materials, tools, and methods experts actually use.

Churn analysis: Instead of a summary table, provide raw logs, transaction records, and user behavior. Ask the agent to first try to disprove the hypothesis "onboarding causes churn." If it only has Markdown tables, connect it to the database and statistical models. After validating known hypotheses, have it search for unknown early signals and test them on unseen data.

Performance optimization: Targeting 5 seconds yields routine tweaks; targeting 200 ms forces re‑examination of data paths, caching, network round‑trips, and architectural assumptions. The ambitious target surfaces problems the original task never touched.

Felix distills his Depth prompt:

I want a deeper task, not a bigger task. First tell me: what extra work do top professionals in this field do that I haven't asked for? What raw materials do they start from? What methods and tools do they use? Besides you and me, what can prove the result is correct? Then rewrite the task based on those answers.

The prompt ends with a critical question: "Who proves the result is correct?" The executing agent can propose, but should not self‑certify. Database end‑state, compiler, test suite, performance benchmarks, and proof checkers are more reliable than the model's self‑evaluation.

In an Anthropic formal verification project, Claude generated ~1 billion lines of Rocq candidate proofs; ~180 million passed an independent checker, covering 239 entry points across 123 open‑source libraries. The 1 billion is generation volume; 180 million is verified volume. Proofs only cover the given specification, environment, and assumptions — gaps in the spec remain uncovered. For daily development, unit tests, integration tests, real command output, screenshots, and traffic replay turn "I'm done" into verifiable evidence.

4. Range — Borrow Methods from Other Disciplines

Felix suggests turning nouns into verbs. A quarterly review defined as "a slide deck" becomes writing, charting, formatting. Redefined as "in 30 minutes make busy people understand business changes and causality, and decide with incomplete information," the method changes: analysts query data, journalists verify sources and causality, editors cut unsupported conclusions, short‑sellers hunt hidden risks, forensic accountants trace numerical contradictions. Assigning five agents five roles but feeding them the same summary only yields five tones. A "journalist agent" must return to primary sources, distinguish first‑hand from hearsay, and timestamp claims. A "short‑seller agent" actively seeks counter‑evidence, conflicts of interest, and ignored risks. Borrow the method, not the tone.

Felix discovered Blender for his personal homepage 3D scene after seeing colleague Alex Albert use it for interior design — despite his own game‑dev background. Range means multiple agents using different materials, methods, and responsibilities: some implement, some hunt counter‑examples; some read raw data, some only check final evidence. A coordinator distributes work but must not rubber‑stamp the verifier's approval.

Why We Still Assign Trivial Tasks

Felix cites psychology's "self‑efficacy": belief in one's capability influences willingness to try. In 1939 George Dantzig solved two famous unsolved statistics problems because he thought they were homework. In 1954 Roger Bannister broke the four‑minute mile; 46 days later a second runner did it. These stories don't prove belief guarantees success; they show that once people deem a path impossible, the attempt never happens. Models and tools now read code, run programs, operate software, and query data, yet we still use them like chat boxes. "Be bolder" means re‑examining that capability boundary alongside verification and correction.

Experienced Users Delegate More — and Interrupt More

Anthropic's analysis of real Claude Code usage reveals an apparent paradox:

Users with <50 sessions: ~20% of sessions use full auto‑approval.

Users with ~750 sessions: >40% use full auto‑approval.

Novices (~10 sessions) interrupt ~5% of turns; experienced users ~9%.

As task complexity rises, Claude itself stops more often to ask for clarification.

Experienced users no longer approve every step; they intervene when direction drifts, evidence is thin, or scope expands. This data comes from software engineering where changes are comparable, testable, and reversible via Git. If errors surface only at month‑end, actions are irreversible, and the only check is the model's summary, autonomy must be reduced.

Architecturally: the model finds the path, tools execute, Harness manages state and pacing, verifiers check results, humans retain goals, preferences, and irreversible decisions. "The system can verify X and roll back Y, so the agent may decide Z."

Conclusion: No Magic Prompt, Just Expanded Responsibility

The four patterns are not isolated tricks; they all expand how far the AI carries responsibility for the outcome. Speed accelerates the original task; Altitude lifts the task to the outcome; Depth pushes work down to raw materials and professional methods; Range imports tools and observation styles from other fields. As the task boundary expands, the system must supply data, tools, state, environment, verification, rollback, and human oversight — not rely on the model alone.

Three decisions remain human: What result is worth pursuing, what cost is unacceptable, and when is it good enough. Define the outcome, attach tools and evidence, let the AI go further, and be ready to stop or roll back to the last known‑good state.

References

Felix Rieseberg: How to Be More Ambitious: A Tutorial for Humans with Models (https://felixrieseberg.com/how-to-be-more-ambitious-a-tutorial-for-humans-with-models/)

Felix Rieseberg: X post announcing the tutorial (https://x.com/felixrieseberg/status/2110023283169247623)

Anthropic: Measuring AI Agent Autonomy in Practice (https://www.anthropic.com/research/measuring-agent-autonomy)

Anthropic: Demystifying Evals for AI Agents (https://www.anthropic.com/research/demystifying-evals-for-ai-agents)

Anthropic: Scaling Managed Agents: Decoupling the Brain from the Hands (https://www.anthropic.com/research/managed-agents)

Anthropic: LLMs Are Making Formal Software Verification Feasible at a Much Larger Scale (https://www.anthropic.com/research/formal-verification)

Anthropic: Trustworthy Agents in Practice (https://www.anthropic.com/research/trustworthy-agents)

Addy Osmani: Own the Outer Loop (https://addyosmani.com/blog/own-the-outer-loop/)

Addy Osmani: Agentic Autonomy Levels (https://addyosmani.com/blog/agentic-autonomy-levels/)