The bill for running an AI agent used to be simple to predict: count the tokens, multiply by the price, brace yourself. That math worked fine when a bot answered one question and stopped. It stopped working the moment “agent” started meaning a system that thinks in loops: reads a task, checks a tool, reads the result, checks another tool, and does that ten or twenty times before it hands you an answer.
Every one of those loop turns re-sends the same scaffolding: the system prompt, the list of available tools, the running history of what has happened so far. On a naive setup, you pay full price for all of it, every single turn. A ten-turn agent doesn’t cost ten times one turn’s worth of tokens. It costs something closer to fifty-five times, because turn six is still dragging turns one through five behind it.
That’s the bill Deepseek decided to go after, and the fix it landed on is reshaping how people price agent-heavy workloads across the board.
The trick is remembering what you already said
The technique is called prompt caching, and it isn’t new. What’s new is how aggressively Deepseek’s V4 Flash model prices it. When part of a request matches something the model has already processed, that part gets billed at a steep discount instead of full price. Deepseek’s published numbers put V4 Flash at $0.14 per million input tokens and $0.28 per million output tokens, with cache hits landing at $0.0028 per million tokens, roughly a quarter of a cent for a full million tokens of repeated context.
For a single request, that’s a nice discount. For an agent swarm, it changes the shape of the cost curve entirely.
Picture ten agents working a shared task, each one carrying a two-thousand-token system prompt and a set of tool definitions. On a model with no meaningful caching, that overhead gets re-billed at full price on every turn, for every agent, for the life of the run. On Deepseek’s setup, that same overhead becomes a cache hit after the first pass. The marginal cost of keeping an agent turn going approaches the cache-hit rate, not the sticker price. Deepseek’s own materials describe this as agent swarm optimization, and the framing is accurate: the pricing was built with exactly this workload in mind, not bolted on after the fact.
Why this matters more for swarms than for single calls
A single chatbot answering a single question barely notices caching. There’s one prompt, one response, done. The economics only bend once you’re running the pattern that defines modern agent work: repeated calls, mostly identical context, one small delta per turn (the latest tool result, the next instruction).
That’s the shape of coding agents, research agents, and anything built on a loop of “check something, decide something, check the next thing.” It’s also, not coincidentally, the shape most teams are building toward as agentic tooling matures. A workload that was expensive to run as ten sequential single-shot calls becomes dramatically cheaper once it’s reframed as one long-running conversation with a cacheable prefix.
Deepseek isn’t alone in chasing this. Kimi’s coding-focused tier prices cache hits at $0.19 per million tokens, aimed at the same coding-agent pattern. Moonshot and Deepseek are both explicit that this is the target: not the one-off question, but the long-running loop.
The competitive picture is not as simple as “cheapest wins”
It would be easy to read the pricing table and conclude the argument is over. It isn’t, and treating raw price per token as the whole story would be a mistake.
Anthropic’s Claude models sit at a different point on the map. Claude Opus 5 runs $5 per million input tokens and $25 per million output tokens, no caching discount published as a separate cache-hit rate the way Deepseek structures it, but with its own batch processing option that cuts the bill in half for workloads that can tolerate delayed results: $2.50 per million input tokens and $12.50 per million output on the batch tier. Claude Sonnet 5 lists at $3 per million input and $15 per million output as the standing rate, with an introductory price of $2 and $10 running through the end of August 2026, worth flagging as a limited-time number rather than a permanent one if you’re budgeting past that date.
The gap between those numbers and Deepseek’s $0.14 input rate looks enormous until you factor in what you’re actually paying for. Teams choosing Claude aren’t buying tokens; they’re buying a production track record, a safety and reliability posture that matters for anything customer-facing, and an ecosystem (Claude Code chief among it) that a lot of engineering teams have already built workflows around. That’s a real cost difference with a real reason behind it, not a mispricing waiting to be arbitraged away.
What Deepseek’s approach does is widen the field of workloads where the cost math can plausibly favor a cheaper backend. A high-volume agent swarm doing repetitive, well-scoped work (data extraction, code review passes, structured research) is a different bet than a customer-facing assistant where a bad answer costs you a relationship. The caching economics make the first category dramatically cheaper to run at scale. They don’t erase the reasons the second category still leans toward a more expensive, more battle-tested model.
The practical shift for teams building agents
If you’re architecting an agent swarm today, the caching-aware framing changes two things worth doing differently.
First, design your prompts so the expensive, stable part comes first and the cheap, changing part comes last. Tool definitions and system instructions belong at the front of the request, ordered the same way every time. The part that changes turn to turn (the latest observation, the next instruction) belongs at the end. Get that ordering wrong and you invalidate the cache on every turn without realizing it, paying full price while thinking you’re getting the discount.
Second, treat the marginal cost of an additional agent turn as a real variable to budget, not an afterthought. Under a caching-heavy pricing model, running an agent for twenty turns instead of ten doesn’t cost twice as much if most of those turns are hitting cache. That changes what counts as an efficient design. A system that used to avoid extra turns to save money can afford to let an agent double-check its own work, because the double-check is closer to free than it used to be.
None of this makes the older, more expensive models obsolete. It does mean the calculation for choosing a backend now has to include how the workload actually shapes its context, not just what the per-token sticker says. For anyone running agent swarms at volume, that’s the conversation worth having before the next invoice arrives.
Sources: Deepseek V4 API pricing documentation (benchlm.ai); “DeepSeek V4 Flash in AI Agent Price War” (techbooky.com); Anthropic Claude API pricing documentation; Kimi API pricing calculator (benchlm.ai). Model pricing current as of August 2026 and subject to change; Claude Sonnet 5’s introductory rate is scheduled to expire August 31, 2026.
Chris Meredith writes about AI, technology, and what it actually means for real people. Follow along on Substack: monkeyattack.substack.com
