DeepSeek cuts V4-Pro prices 75%, but agent bills rise anyway

DeepSeek cut pricing on its V4-Pro model by 75%. That sounds like a straightforward win for enterprise AI vendors and developers. But many teams are running into a messier reality: cheaper inference does not automatically translate into healthier margins once agent systems take over.

Here’s why, in plain terms. A normal chatbot often turns one user question into one model call. An agent turns it into a chain: planning, retrieval, tool use, verification, summarization, and follow-up decisions. The user sees one answer. The vendor pays for the loop. That mismatch is the “100x problem”: the same user-visible request can cost far more to serve when it becomes an agentic workflow instead of a single-turn chatbot or retrieval-augmented generation (RAG) response. And in longer-running workflows, the multiplier gets worse.

For decades, software economics followed a predictable script: infrastructure got cheaper every year, while applications got more capable. Many people assumed AI would behave the same way. As frontier models improved and token prices dropped, inference would become a rounding error. That assumption is starting to crumble, not because models are suddenly “worse,” but because product architecture is changing faster than cost curves are offering relief.

The token amplification effect is the culprit. In a single-turn chatbot, one user message produces roughly one model call, with an input-to-billed ratio of about 1:5. In a multi-step agent deployed across customer support, sales operations, finance, legal review, and engineering, the ratio routinely lands at 1:700 or higher. Each loop iteration carries forward cumulative conversation content, tool outputs, and reasoning traces. Nothing is dropped. A “simple” agent query like “What did our top customer ask about last week?” typically touches seven priced operations before returning an answer: user prompt (~50 tokens); system prompt and tool definitions (~3,000 tokens, repeated on every call); retrieval (~5,000 tokens of context); model call #1 for tool selection (8,000 in / 200 out); tool execution (~4,000 tokens returned); model call #2 for summarization (12,000 in / 400 out); and model call #3 for follow-up decision (12,400 in / 100 out). One sentence in can mean about 35,000 input tokens billed.

At “somewhere between $0.10 and $0.40 per query on a frontier model,” that may not sound existential until you multiply by scale. If you run a million queries a month, which is table-stakes volume for many enterprise B2B features, that line item can reach six figures. And the economics get even stranger for seat-based SaaS. Enterprise AI has often leaned on seat pricing: pay per user per month, deliver agent capability, capture margin. That model only works if cost per user stays bounded. Token amplification breaks the assumption. A power user executing 50 agent invocations per day on a $40/seat plan can cost more in inference than the plan charges. Vendors can end up with negative gross margins on heavy users, exactly the segment they are most incentivized to serve.

The public evidence is still uneven, but the direction is showing up in coverage. Bloomberg documented a widening gap between Salesforce’s Agentforce marketing demos and the capabilities actually shipping to customers, signaling a situation where the promised functionality can be technically possible but uneconomical at the implied seat price. The source also notes that established enterprises retrofitting agents into existing product lines face even larger absolute numbers. The strategic implications are not “AI is expensive.” It is that the dominant business model behind many AI-native plans may not survive contact with agentic workloads, even when the models get cheaper.

There are also incentives already baked into the capital allocation story. OpenAI proposed a program to give every Y Combinator startup $2 million in API credits. The source frames that figure as more than a recruiting perk: it is an admission of what it now costs to run an AI-native company through its first year of product. When that same cohort previously “got by on a few thousand dollars of AWS credits,” it highlighted a key shift. Agentic workflows increase consumption, and consumption increases burn.

So what actually saves margin? The technical responses may sound familiar, but they are critical for survival because they attack the token amplification problem directly. Cost-aware routing uses a small classifier model to decide which tier handles each query, and well-tuned routers can cut inference bills by around 60% without degrading quality. Prompt caching (offered with 75 to 90% discounts on cached prefixes by Anthropic, OpenAI, and Google) reduces repeated work. Context discipline means truncating tool outputs, pruning reasoning traces, and capping tool depth so the agent does not spiral. For self-hosted deployments, speculative decoding can guarantee 2 to 3X effective throughput on the same GPUs. IBM is cited for the claim that “Organizations using orchestration-led governance report stronger productivity gains,” with “six times greater productivity impact than compliance-only approaches.” The pattern is clear: orchestration becomes the new “moat.” The companies building it well look less like generic app builders and more like financial trading systems, because they effectively price every routing decision, every path with its own P&L, and every tenant on a metered budget.

For leaders, the action list is blunt. Make inference cost a first-class metric, tracked per-feature, per-tenant, and per-query class the same way cloud cost was tracked starting in the mid-2010s. Budget like a media buyer by setting cost-per-thousand-queries ceilings per feature, cap them, and alert on overruns. Treat the router as core infrastructure, not a later optimization, because it is the new load balancer. Audit prompts quarterly because a 4,000-token system prompt that grew organically over six months can become a six-figure bill in slow motion. Negotiate volume commits early since frontier-model vendors now offer reserved-instance-style prepaid commits at subs-style arrangements (the source truncates here, but the direction is to lock in cost). The “100x problem” is not theoretical anymore. It is what decides whether agent adoption expands margins or quietly destroys them as usage grows.