Claude 4 API: Tool Use Streaming & Prompt Caching vs Cursor Background Agents

“The primitive here is clean: incremental tool-call deltas over SSE, and a cache-control header you attach to prompt segments to pin them server-side. The DX bet is that complexity lives in the HTTP layer, not in a new SDK abstraction — you opt in per-request, no new mental model required. The moment of truth is calling `stream=true` on a tool-use request and watching partial JSON arguments arrive before the model finishes thinking, which actually matters for agent loops where you want to dispatch work early. This is not a weekend-script replacement — implementing correct incremental JSON parsing for partial tool arguments plus a reliable distributed cache with 2M token capacity is a real engineering problem Anthropic has solved for you. The specific decision that earns the ship: cache invalidation is explicit and cache hits are reflected in the usage object, so you can actually measure what you're saving instead of guessing.”

“The primitive here is clean: spin up an isolated sandbox, run an agent against a task spec, return a diff. That's not a wrapper — that's infrastructure. The DX bet is that developers trust diffs more than they trust inline chat suggestions, which is empirically correct. The moment of truth is submitting your first task and walking away — if the diff comes back coherent and scoped to what you asked, this earns a permanent place in the workflow. The specific decision that earns the ship is sandboxed isolation per task: no state bleed between runs, which is the failure mode that makes other agent frameworks useless in practice.”

“Direct competitors are OpenAI's cached completions and Google's context caching in Gemini 1.5 — both shipping for months — so Anthropic is catching up, not leading. The specific scenario where this breaks: cache hit rates depend entirely on prompt structure, and developers who dynamically compose system prompts (inserting user-specific context at the top) will see near-zero cache utilization and pay full price while assuming they're saving money. The prediction: this feature doesn't get killed — it becomes table stakes infrastructure and Anthropic wins by having the largest cache window (2M vs. competitors' current limits). What would have to be true for me to be wrong: OpenAI ships a 10M token cache window before Anthropic's ecosystem matures, commoditizing the advantage. Still a ship because the streaming tool-use delta is genuinely differentiated — no competitor has clean partial-argument streaming for tool calls yet, and that changes agent loop architecture in ways that matter.”

“Direct competitor is GitHub Copilot Workspace, which has been promising the same async agent workflow for over a year and is still in preview. Cursor shipping this in a usable state is a real differentiator — for now. The scenario where this breaks is multi-file refactors that touch shared state or require understanding of runtime behavior the sandbox can't replicate; the diff comes back syntactically valid and semantically wrong, and the developer ships it because the review surface is 400 lines. What kills this in 12 months: GitHub ships native async agents with deeper repo context via the Actions integration, and the distribution advantage Cursor has today evaporates. What would have to be true for me to be wrong: Cursor builds enough workflow lock-in through saved task templates and team-level agent configs that switching cost exceeds GitHub's platform gravity.”

“The thesis this bets on: by 2027, the dominant AI application architecture is a persistent agent with a large, stable context (tools, memory, instructions) that gets reused across thousands of user interactions — making context I/O cost the primary unit economics lever, not generation cost. The dependency that has to hold: agents don't collapse back to stateless chatbots, and context windows keep growing faster than per-token prices fall. The second-order effect nobody's talking about: prompt caching at 2M tokens makes it economically viable to give every enterprise user a fully-loaded, role-specific agent context at request time — which shifts competitive differentiation from 'who has the best model' to 'who has the best cached context corpus,' effectively making knowledge curation the new moat. This tool is riding the trend of context-window expansion-as-infrastructure, and it's on-time, not early — but the streaming tool-use primitive is ahead of the curve on agent loop efficiency. The future state where this is infrastructure: every production agentic system has a cache manifest the same way it has a CDN config.”

“The thesis Cursor is betting on: within two years, the bottleneck in software development shifts from writing code to reviewing code generated continuously in the background — the IDE becomes a diff-review interface, not an editor. That's a falsifiable claim, and background agents are the first concrete step toward it. The dependency that has to hold is that LLMs get good enough at scoped tasks that the diff-to-merge rate stays above 60%; below that, the cognitive overhead of reviewing bad diffs exceeds the time saved. The second-order effect nobody is talking about: if background agents normalize async code generation, it radically changes what a 'senior engineer' does — task specification and diff judgment become the core skill, and typing speed stops mattering entirely. Cursor is riding the trend of agent reliability improving faster than trust in agents, and they're early enough that this shapes user behavior rather than just optimizing it.”

“The buyer is the engineering team at any company running Claude in production with long system prompts or multi-step agents — this comes out of the AI infrastructure budget, not a new budget line, which means no procurement friction. The pricing architecture is sound: cache reads at ~90% discount means the savings are real and measurable in the first billing cycle, which creates immediate retention — developers who restructure prompts to maximize cache hits are now architecturally coupled to Anthropic's caching implementation. The moat question is the honest one: this is infrastructure that OpenAI and Google will match, so the defensible position isn't the feature itself but the ecosystem of developers who've restructured their codebases around it. What survives a 10x model price drop: the streaming tool-use architecture, because that's about latency, not cost. The specific business decision that makes this viable is pricing cache reads as a separate SKU — it lets Anthropic capture value from high-volume production workloads without losing price-sensitive experimenters.”

“The job-to-be-done is precise: let a developer delegate a well-scoped task and context-switch without losing the work in flight. That's one job, no 'and.' Onboarding is where this gets interesting — the user has to learn to write a good task spec before they see value, and bad task specs produce bad diffs, which produces distrust, which produces churn. Cursor needs an opinionated task template or a spec-quality feedback loop in the first session, or early adopters will bounce after two failed runs. The specific product decision that earns the ship is the diff-as-output contract: it forces the agent to produce something reviewable rather than something runnable, which is the right trust calibration for where developer confidence in AI agents actually sits right now.”