Cache Becomes the Agent

If You Only Read One Thing

The useful AI-agent signal today is that interfaces are becoming contracts. Reasonix makes cache stability the organizing principle of a coding agent; Chrome WebMCP makes ordinary web forms callable by browser agents. Start with Reasonix's README: it shows the economic constraint that generic multi-provider agents mostly hide. This is interface design under cost pressure.

Reasonix Caches the Agent

Most coding agents treat prompt caching as an optimization. Reasonix treats it as architecture.

Reasonix is an MIT-licensed terminal coding agent built specifically around DeepSeek's prefix cache: the provider fingerprints prompt bytes from the beginning of the prompt, then discounts repeated cached input. The project has 6.7K GitHub stars, 1,341 commits, an npm path via npx reasonix code, and a deliberately narrow backend choice: DeepSeek V4-Flash by default, V4-Pro on demand. Its README says one real single-day workload used 435M input tokens with a 99.82% cache hit rate, costing about $12 instead of about $61 without cache on V4-Flash.

Why it matters: this is a different answer to coding-agent cost than model routing. The familiar pattern is to swap providers, compact context, or choose a cheaper model after the agent loop has already been designed. Reasonix reverses the order. It keeps the loop append-only, avoids history rewrites, preserves deterministic tool ordering, and exposes session stats because the cacheable prefix is the scarce asset. In plain English: the agent is not just asking DeepSeek to code; it is arranging its entire memory and tool history so DeepSeek can bill the same bytes at the cached rate.

That coupling is both the strength and the tradeoff. The project can support MCP servers, skills, hooks, memory, SEARCH/REPLACE edits, event replay, a desktop prerelease, and local semantic indexing, but the core economic claim depends on staying byte-stable for one provider's cache mechanics. Generic agents want portability. Reasonix wants a cheaper long session. The structural point is not that every team should use this tool; it is that prompt-cache behavior is becoming a product-design constraint rather than a line item in a pricing table.

Room for disagreement: the headline cache numbers are self-reported and tied to one workload. The stronger evidence would be third-party task-level comparisons that include cache hit rate, wall-clock time, edit quality, and user rework across the same repository.

What to watch: whether other coding-agent CLIs begin publishing cache-hit and cost-per-session stats as first-class telemetry. If they do, Reasonix's narrow design will look less strange and more like an early version of a broader accounting shift.

WebMCP Names the Web

Browser agents are bad at websites for the same reason interns are bad at unfamiliar dashboards: they have to infer the work from visible shapes. Chrome's WebMCP proposal gives the page a way to name the work directly.

Google's WebMCP documentation was published May 18 and describes a proposed web standard for exposing structured tools to AI agents through JavaScript and annotated HTML forms. The Declarative API turns an ordinary form into a tool with attributes such as toolname and tooldescription; toolautosubmit can submit when the model invokes the tool; SubmitEvent.agentInvoked lets the site know an agent triggered the action; and respondWith() lets the page return structured results. Chrome says WebMCP is available behind a local flag and planned for a Chrome 149 origin trial.

Why it matters: WebMCP attacks actuation, the brittle pattern where an agent simulates clicks and typing on a UI built for humans. The practical version is simple: instead of a model guessing which "Submit" button matters, the page declares a checkout, filter_results, or run_diagnostics tool with a schema for inputs and outputs. That moves browser agents closer to function calling without requiring every website to run a backend MCP server. The web page itself becomes the tool surface.

The bigger implication is about platform power. If browser-agent interaction becomes a web-standard layer, Chrome is no longer just rendering pages for humans; it is mediating how agents discover and execute user intent inside those pages. That can make consumer agents more reliable, but it also shifts advantage toward websites that expose clean tool contracts and browsers that control the agent runtime. The old SEO question was "can Google understand this page?" The emerging agent question is "can a browser agent safely call this page?"

Room for disagreement: this is still early. Chrome lists real limits: the tab or webview must be open, headless operation is not supported, complex sites may need refactoring, and tool discovery requires visiting the site. That makes WebMCP a serious preview, not a production baseline.

What to watch: whether non-Google browsers or agent runtimes implement the same tool-discovery model. A Chrome-only WebMCP is a feature; a cross-browser WebMCP is infrastructure.

The Contrarian Take

Everyone says: agents need better models and longer context windows.

Here's why that's incomplete: today's best signals are about surfaces, not size. Reasonix shows that a long session is valuable only if its repeated context stays economically stable. WebMCP shows that a browser agent is useful only if the page stops making it guess how to act. Inspect's intervention work, below, points the same way: operators need live control and faithful logs, not just bigger transcripts. More context helps; named, billable, interruptible interfaces matter more.

Under the Radar

• Inspect is turning intervention into an eval primitive. Inspect's new Agent Intervention docs let an operator observe a running agent, interrupt a generation or tool call, send follow-up messages, and record the intervention in the transcript. That turns "human in the loop" from a postmortem phrase into logged state inside an eval run.
• Augment Code is operationalizing cloud-agent ownership. Augment's Cosmos 26-05-18 release adds service-account attribution for automated workflows, scoped webhook subscriptions, and hosted artifacts created by cloud agents via CLI and API. The missed angle is not feature count. It is that enterprise agents need identity, event scope, and output custody before they need another chat pane.
• Parallel compaction is attacking agent stalls. A May 22 arXiv paper proposes parallel context compaction for long-horizon agent serving, reporting lower end-to-end wall time and better compaction throughput at matched decode volume. It stays Under the Radar because I did not find released code, but the framing is right: context compression is becoming serving latency, not just memory hygiene.

Quick Takes

• Constraint decay gives backend-agent failures a name. The Constraint Decay paper evaluates 80 greenfield and 20 feature-implementation backend tasks across eight web frameworks, finding capable configurations lose about 30 assertion-pass points as structural requirements accumulate. The useful insight is that agents often satisfy behavior while violating architecture, ORM, and data-layer constraints. (Source)
• SWE-bench Pro is still a ceiling, not a solved benchmark. The public SWE-bench Pro page lists 1,865 problems across 41 repositories and says commercial-set tasks are long-horizon, human-verified, and often take human engineers hours or days. Initial public results still sit below 44% resolved, even with uncapped cost and a 250-turn limit. (Source)
• HBM is eating the chip bill. Epoch AI estimates memory rose from 52% to 63% of AI chip component spending between Q1 2024 and Q4 2025, with HBM spend across Nvidia, AMD, Google, and Amazon designs rising from roughly $12B in 2024 to $32B in 2025. That is the hardware-side reason cache reuse keeps mattering. (Source)

The Thread

The connective tissue today is contractualization. Reasonix contracts with a model provider's cache mechanics. WebMCP contracts the relationship between a website and an agent. Inspect contracts operator intervention into the eval log. Augment contracts agent work to service accounts and scoped webhooks. The pattern is that agent reliability is moving out of the prompt and into the surrounding interfaces. That is less glamorous than a new benchmark win, but it is how agent systems become cheap enough, legible enough, and interruptible enough to run for longer than a demo.

Prediction Ledger

Weekly Scorecard

• By 2026-08-31, at least two coding-agent platforms among Codex, Claude Code, Cursor, Cline, and Copilot will expose resumable background-session state through both an interactive UI and a programmatic SDK/API. — Made 2026-05-19, medium confidence. Pending: no check-date evidence is due yet.
• By 2026-08-31, at least two production LLM serving stacks beyond vLLM will document external KV-cache service backends that survive worker restarts or share cache across replicas. — Made 2026-05-20, medium confidence. Pending: PegaFlow is one proof point, but the two-stack threshold is not met.

New prediction

• I predict: By 2026-08-31, at least three coding-agent CLIs will publish prompt-cache, context-retention, or cost-per-session metrics in their session stats rather than only reporting raw token totals. (Confidence: medium; Check by: 2026-08-31)

Generated: 2026-05-25 03:40 EDT