Automating work with Claude

How to automate real work with Claude in 2026 - Managed Agents, computer and browser use, MCP tools, batch processing, and patterns that control cost.

Automating work with Claude in 2026 means one of four things: calling the Claude API from your own code, running an agent loop yourself with the Claude Agent SDK, handing the whole loop to Managed Agents (public beta, billed at standard token rates plus $0.08 per session-hour), or submitting bulk work to the Batch API at a flat 50% discount. Which one you pick is mostly a question of how long the task runs and whether anyone is waiting for it.

This page covers the current automation surfaces, five workflow patterns with a recommended model for each, the levers that actually reduce cost, and the failure modes that make long-running agents expensive.

#What can Claude actually automate in 2026?

The honest framing is that Claude automates judgement steps, not whole processes. It reads a messy input, decides something, and emits a structured result or calls a tool. The plumbing around it - queues, retries, scheduling, storage - is ordinary software, and treating the model as if it should also be the scheduler is how automation projects go wrong.

What changed over the last year is the size of the judgement step. A model that reliably calls tools, holds a million tokens of context and runs for hours can own a task that previously needed a human checkpoint every few minutes. That is the premise behind Fable 5, positioned for long-running agents rather than for better single answers.

#Managed Agents: letting Anthropic run the loop

Managed Agents is a hosted agent harness - Anthropic runs the agent loop, the sandbox and the session state, and you talk to it over a REST API. It entered public beta on 8 April 2026 and every endpoint requires the beta header managed-agents-2026-04-01, which the official SDKs set for you.

Four concepts: an Agent (model, system prompt, tools, MCP servers, skills), an Environment (an Anthropic cloud sandbox, or your own self-hosted one), a Session (a running instance), and Events streamed over SSE. Built-in tools cover bash, file read/write/edit/glob/grep, and web search and fetch with domain allowlists. Sessions survive disconnection, can be scheduled on a cron, can be triggered by webhooks, and can orchestrate other agents.

Billing has two dimensions. Tokens are charged at standard model rates, with prompt-caching multipliers applying identically. Session runtime is metered to the millisecond at $0.08 per session-hour, and only while the session status is running - time spent idle, rescheduling or terminated does not count. Anthropic's worked example: a one-hour Opus 5 coding session consuming 50,000 input and 15,000 output tokens costs $0.25 + $0.375 + $0.08 = $0.705. Session runtime replaces code-execution container-hour billing, so you are not charged twice.

The alternative is the Claude Agent SDK - the same tools, agent loop and context management that power Claude Code, running in your own process. It is available for Python and TypeScript only; from other languages you run the CLI as a subprocess with -p and --output-format json. You keep control of data handling and you avoid the session-hour charge, at the cost of operating the infrastructure yourself.

#Computer use and browser use went GA in August 2026

On 19 August 2026 computer use reached general availability as computer_toolset_20260801 - no beta header, with batch actions and zoom enabled by default. A separate browser use tool (browser_toolset_20260801) shipped the same day. Both are available for Fable 5, Opus 5, Sonnet 5 and Opus 4.8 on the Claude API.

These are last-resort tools. The toolset overhead alone is roughly 4,500 input tokens for computer use and 6,600 for browser use, charged on every request that includes them, before the model has seen a single screenshot. If the target system has an API or an MCP server, use that. Reserve pixel-level control for systems with no other door - legacy internal applications, vendor portals, desktop software.

#Five automation patterns that work

The patterns below are distinguished by latency tolerance and by how much state the task carries. Match the model to the pattern rather than defaulting to the most capable one.

The extraction pipeline has the clearest return, because it is where the batch discount, prompt caching and the cheapest model all stack, and where a schema-shaped tool definition gets you deterministic output. The long-horizon agent is the one to approach last: Fable 5 costs $10/$50 per million tokens and has materially tighter rate limits than Opus 5 at every tier, so a runaway loop is expensive in two ways at once.

#Batch processing for anything nobody is waiting for

The Batch API charges 50% of standard rates on input, output and special tokens. Limits are 100,000 requests or 256 MB per batch, whichever comes first; most batches finish inside an hour, results are available when all messages complete or after 24 hours, and anything unfinished at 24 hours expires without being billed. Results stay retrievable for 29 days.

Three details worth knowing before you build on it. Streaming and fast mode are not supported in batch requests. Anthropic recommends the 1-hour cache TTL rather than the 5-minute one, because batches routinely run longer than five minutes. And the output-300k-2026-03-24 beta header raises the batch max_tokens ceiling to 300,000 tokens on Opus 5, Opus 4.8/4.7/4.6 and Sonnet 5 - useful for bulk long-form generation, though a single 300k-token completion can take over an hour.

#How do you keep automation costs under control?

Five levers, in rough order of how much they save.

#1. Route cheap work to Haiku 4.5

Most automation is classification, routing and extraction dressed up as something harder. Haiku 4.5 costs $1/$5 per million tokens against Opus 5's $5/$25 - a fifth of the price - and it is the model Anthropic points at high-volume intelligent processing and sub-agent tasks. Use a cheap model for the fan-out and an expensive one only for the step that genuinely needs it. The model comparison works this through per task rather than per benchmark.

#2. Cache the system prompt

Cache reads cost 0.1× base input. A 5-minute cache write costs 1.25×, so it pays for itself after a single read; a 1-hour write costs 2× and pays off after two. Minimum cacheable prompt length is 512 tokens on Opus 5 and Fable 5, and 1,024 on Sonnet 5 and Haiku 4.5. In an automation loop where the same instructions and tool definitions go out thousands of times a day, this is usually the single largest saving available. Cache reads also do not count toward your input-tokens-per-minute rate limit on current models.

#3. Batch anything not interactive

A flat 50% discount, stacking with caching multipliers. If a human is not sitting there watching a spinner, there is rarely a reason not to.

#4. Cap iterations, explicitly

Set max_tokens deliberately, cap the number of agent turns, and use session budgets in Managed Agents - a session that hits its budget stops with a budget_reached stop reason rather than continuing. Set a monthly spend cap in the console as a backstop; Start tier caps at $500 and Build at $1,000 by default.

#5. Turn the thinking effort down

Thinking is on by default on Opus 5, Sonnet 5 and Fable 5, and thinking tokens are billed as output tokens. The effort ladder runs low → medium → high (default) → xhigh → max. For triage and extraction, low or medium is usually indistinguishable in quality and materially cheaper. See how Claude's thinking modes work for the mechanics.

#What goes wrong with long-running agents?

Long-horizon automation fails in recognisable ways. Each has a bound you can set in advance.

The refusal case is the subtlest and the one most likely to be missed in an unattended pipeline: it is not an exception, it is a successful response with a different stop_reason, and you are not billed if nothing was generated. A retry on another model via the fallbacks parameter earns a “fallback credit” refunding the prompt-cache cost of switching.

The broader principle: bound everything that can run away - turns, tokens, wall-clock time, spend - and log the stop_reason for every call. Agents fail quietly far more often than they fail loudly.

#Where to start

If your automation must touch existing systems, the connection layer is MCP. To build the workflow visually rather than in code, Claude agents in n8n covers the node-based route. Claude for developers maps the surfaces, the prompt engineering guide covers the structured-output techniques that make an unattended step reliable, and plan-level costs are on the pricing page.

#Frequently asked questions