LangChain Deep Agents v0.7: Cutting Agent Input Tokens by 65%

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Deep-agent loops are where enterprise AI budgets quietly go to die. Every step resends the full conversation, every retry resends the same tool schema, and every stale observation stays in context long after it stopped mattering. The v0.7 release of LangChain Deep Agents, shipped in August 2026, attacks exactly that line item: the harness itself, not the model, now cuts input-token usage by 65% on standard multi-step benchmarks. For teams running long-horizon agents against live tools, that is not a rounding error. At a flagship-model price of about $3 per million input tokens, a loop that makes 40 calls per task and burns 60,000 input tokens per call goes from $7.20 per task down to roughly $2.50 per task before any output or cache-write costs. Scale that across thousands of tasks and a 65% cut on inputs is the difference between an agent product that loses money per run and one with a real gross margin.

What actually changed in Deep Agents v0.7

Deep Agents v0.7 is a harness release. It does not swap models, lower sampling temperature, or trim reasoning effort. It changes what gets sent to the model, how often, and in what order. The release notes call it "harness optimization," and the 65% figure comes from controlled runs across the GAIA and SWE-bench-verified harnesses where input tokens are metered at the provider API level. Four techniques carry almost all of the win: prompt and tool-call compression, harness-level deduplication, salience-based context pruning, and cached static prefixes.

Each one targets a different leak. Compression shrinks the repetitive schema and instruction text that dominates every request. Dedup stops the same tool arguments, error dumps, and file diffs from being sent two or three times across retries and sub-steps. Pruning drops observations the agent no longer needs. Caching turns the never-changing head of the prompt into a cheap cache-read instead of a full-priced input stream. Combined, they compound: a compressed prompt makes caching cheaper, dedup shrinks what pruning has to evaluate, and pruning keeps context windows small enough that caching hits stay high.

Technique 1: prompt and tool-call compression

The single largest token sink in a deep agent is the repeated, verbose tool surface. A modern tool registry ships names, descriptions, JSON schemas, and argument examples - often 2,000 to 6,000 tokens of pure schema per request. v0.7 compresses this in two passes. First, it strips the schema down to a typed signature: parameter names, types, required flags, and a one-line description, with long description fields moved to a fetchable reference the model only requests when confused. Second, it uses a small, cheap compressor model to rewrite the assembled system prompt and tool header once per session, then caches that compressed result. Because the compressed head is produced once and reused, the compression cost amortizes across every subsequent call. In practice the tool surface drops 55-75% in size while tool-use success rates on GAIA hold within one point of baseline.

Technique 2: harness-level deduplication

Deep agents are retry machines. A tool call that fails, a sub-agent that loops, a parser that stumbles - each attempt re-issues the call with nearly identical arguments. v0.7 adds a dedup layer at the harness level that fingerprints tool-call payloads and suppresses identical arguments across consecutive steps, replacing them with a short pointer like "reuse prior tool_args[12]". The same layer collapses repeated error blocks and file diffs that appear verbatim in two consecutive observations. On SWE-bench-verified runs, where patches and diffs routinely duplicate across attempts, this alone accounts for roughly a third of the measured savings.

Technique 3: context pruning with salience scoring

Long-horizon agents accumulate observations faster than models can usefully consume them. v0.7 prunes by salience: every observation gets a score from a lightweight relevance pass (a cached classifier, not a full model call), and observations below threshold with no future reference are evicted. Conversation history is compressed into rolling summaries at fixed boundaries, and only the most recent raw turns survive intact. The result is a context window that stays near a bounded working set - typically 15,000 to 25,000 tokens instead of drifting toward 100,000+ - which both cuts input cost and measurably improves latency on every subsequent call.

Technique 4: cached and reusable prefixes

The most elegant of the four techniques exploits how provider caching actually bills. Anthropic prompt caching and OpenAI prefix caching charge a fraction of the input-token price for reads from cache - roughly 10% for cache reads versus 100% for fresh input tokens. v0.7 is cache-aware: it pins the compressed system prompt, tool header, and few-shot examples into a stable prefix that never changes mid-task, so every call after the first is largely a cache read. The plugin layer lets teams add their own cached prefixes - a compliance preamble, a retrieval context header, a company style guide - provided they hold those blocks byte-identical across calls.

The benchmark picture

The table is worth reading as a compounding story, not four independent wins. Compression makes dedup cheaper to evaluate, dedup shrinks what pruning scores, and pruning keeps the working set small enough that the cache hit rate stays above 90% on steady-state calls.

The cost math for large agent deployments

Here is where the 65% becomes a P&L line. A team runs 10,000 deep-agent tasks per day. Each task averages 30 API calls and, before v0.7, 2.2M input tokens and 180K output tokens per task.

• Input tokens per day: 22 billion at $3/M = $66,000/day.
• Output tokens per day: 1.8 billion at $15/M = $27,000/day.
• Daily model cost at v0.6: roughly $93,000.

With v0.7 cutting inputs 65% (inputs drop to 7.7B/day) and holding outputs flat, the input bill falls to about $23,100/day, for a total of roughly $50,100/day. That is a $42,900/day saving - about $1.29M a month, or $15.4M annualized at 30 days per month - before you factor in lower provider latency on cache reads and reduced egress. Even after adding the compressor-model inference cost (a small model at maybe 2% of the savings) and engineering time, the payback on adopting v0.7 for a fleet that size is measured in days. Smaller teams get the same curve in miniature: a 1,000-task-per-day workload still saves about $1.3M a year.

from langchain_deep import DeepAgent, CompressionConfig, PruningConfig, CacheConfig

config = DeepAgent.Config(
    compression=CompressionConfig(
        tool_surface="signature_only",      # strip verbose schemas to typed signatures
        compress_system_prompt=True,        # one-time compressor pass, then cached
    ),
    dedup=CompressionConfig(dedup_reuse_pointers=True),
    pruning=PruningConfig(
        salience_evict=True,
        rollup_boundary=8,                  # summarize history every 8 turns
        max_working_set=24_000,             # keep context near a bounded window
    ),
    caching=CacheConfig(
        cache_static_prefixes=True,         # system + tools + few-shot, byte-identical
        min_cacheable_blocks=1_024,
    ),
)
agent = DeepAgent(config=config).bind(model="claude-sonnet-4")
tokens = agent.invoke("resolve this GitHub issue and open a PR")
print(f"input tokens: {tokens.usage.input_tokens}")   # ~65% below v0.6 baseline

The configuration above is the whole point of the release: these are harness-level switches, not model changes. For teams that want to go further, the pruning and dedup layers expose hooks that interoperate cleanly with MCP-backed tool servers, so tools stay registered once in the MCP directory and never re-send their schemas on every call.

For teams already on v0.6, the migration is low-risk: the harness is backward-compatible with existing tool bindings and model choices, and every new technique activates through config flags rather than code rewrites. The one discipline that matters is keeping static prefix blocks byte-identical across calls, which is exactly what the cache layer is designed to enforce. Measure token usage for a week on a shadow copy of your busiest workflow, compare it against the v0.6 baseline, and you will have a live cost figure to put in front of finance before you roll the change out fleet-wide.

Bottom line

Deep Agents v0.7 proves that the cheapest tokens in an agent system are the ones you never send. A 65% input-token cut at fixed quality, delivered by a harness upgrade, changes the economics of every deep-agent deployment from prototype to production. Teams running agents at meaningful volume should measure their own baseline today, because every week at the old token burn is spending money the harness no longer requires. For the latest on agent frameworks, watch the daily AI news feed, and for reusable orchestration patterns, the workflows library has agent-loop blueprints that adopt these techniques out of the box.