DeepSeek Ends the Subsidy

If You Only Read One Thing

Agent cost is no longer the model's price. It is the vendor's ability to reprice accumulated state after workflows depend on it. DeepSeek Prices the Dependency shows that power at the API layer; Enterprise Agents Stop at Half shows why customers cannot buy their way out. Providers monetize attempts. Enterprises need finished state, and the gap is becoming the product.

DeepSeek Prices the Dependency

DeepSeek has stopped subsidizing repeated context, the input agent loops reuse most. On August 16, V4 Pro's cheapest cache-hit rate jumped 6.1 times off-peak and 12.1 times at peak.

Gartner calls the broader pattern the inference paradox: lower unit prices invite software to consume more units until task costs rise. Its August 17 forecast says provider cost per agentic workflow will rise more than fivefold through 2028, even as individual unit prices fall.

A chatbot reads one prompt and returns one answer. An agent reads a repository, calls tools, inspects the results and sends its growing history back to the model on every turn. Gartner says that workflow already costs providers at least five times as much as a basic chat interaction.

DeepSeek turned that forecast into a rate card. Its live V4 pricing now charges $0.022 per million cached V4 Pro input tokens off-peak and $0.044 at peak. Before August 16, the same cached input cost $0.003625.

The increase lands where agent workloads are most concentrated. One practitioner replayed 650 API calls across 16 sessions and 155.9 million input tokens. With a 98.09% cache-hit rate, the same workload cost 2.7 times more under the new off-peak table. The estimate reconciled within 2% of the user's DeepSeek console bill.

This does not make caching pointless. On that workload, cached input remained roughly 15 times cheaper than paying the miss price. DeepSeek also remains inexpensive beside many frontier APIs. That counterargument is right.

What changed is the subsidy, not the technique. DeepSeek used nearly free repeated context to attract long conversations and coding loops. Once those loops became normal, the provider raised the price of the input they reuse most.

Last Thursday's first look established the V4 Pro endpoint; yesterday's trajectory analysis showed why every extra turn compounds context. Today's rate table connects the two: once a provider becomes the default for a cache-heavy loop, it can charge against the state that makes switching expensive.

The economic unit is now a completed task, not a token. A model with a cheap output rate can still be expensive when it takes more turns, carries more history or retries after failure. That pushes value toward routing systems that can reserve costly reasoning for the steps where it changes the answer.

The clean watch signal is DeepSeek's off-peak V4 Pro cache rate. A cut below $0.01 per million tokens by September 30 would mark the new table as temporary load management. Holding at $0.022 would confirm that the introductory cache subsidy is gone.

Enterprise Agents Stop at Half

Enterprise agents can find the right button, but still fail half the time when every action must produce the right final state. The bottleneck has moved from tool access to reliable planning across tools.

Artificial Analysis has published an independent EnterpriseOps-Gym run across email, calendar, file storage, HR, customer service, IT service management, Teams and hybrid workflows. Claude Fable 5 with an Opus 4.8 fallback leads at 51.1% strict task completion. Gemini 3.5 Flash follows at 50.1%, while Claude Opus 5 reaches 47.5%.

Final-state scoring checks what changed in the underlying databases, not whether the transcript sounded competent. An employee-transfer task passes only if every required record, notification and permission ends in the correct state. There is no partial credit for a polished explanation beside a broken workflow.

The test is substantial. ServiceNow's open benchmark contains 1,150 tasks, 512 tools and an average of 9.15 steps per task. The agent must satisfy 5.3 verification conditions on average. That resembles ordinary operational work more closely than a one-shot question does.

The result is harsher because Artificial Analysis uses oracle tool mode. The agent receives the relevant tools instead of searching an enormous catalog. Even with that discovery problem removed and three attempts per task, the best system clears only about half the work.

The original study points to planning as the constraint. Giving agents a human-written plan improved success by 14 to 35 percentage points. Models can call a tool; they lose the thread when later actions depend on earlier state and several conditions must hold.

Strict scoring can understate useful assistance. A model that completes four of five steps may save time before a human finishes the fifth. Synthetic ServiceNow sandboxes also cannot reproduce every permission edge, stale record or office exception.

But partial success has a different meaning when software changes payroll, access or customer records. An unfinished draft is visible. A half-correct state transition can look complete until another system relies on it. The practical boundary is therefore exception handling: the agent's value depends on whether failure becomes an explicit queue or a silent database state.

The answer-moving threshold is 70% strict success on hybrid tasks without oracle tool selection, repeated across three runs. Until a frontier system clears that bar, enterprise agents are best understood as fast operators attached to a large exception queue, not autonomous process owners.

The Contrarian Take

Everyone says: Falling model prices will make autonomous agents an inevitable replacement for ordinary software workflows.

Here's why that's wrong (or at least incomplete): The denominator is moving faster than the price. DeepSeek's cache-heavy practitioner workload became 2.7 times more expensive after repricing, while the best EnterpriseOps agent finished only 51.1% of strict tasks. Failed loops consume tokens too, and retries buy the same context again. Cheap intelligence matters only when the system converts it into a correct final state.

Under the Radar

Cursor wants custody of the repository. Origin code hosting is rolling out in early beta with repositories, pull requests, code browsing and GitHub sync. Its promised agent-native features are still future tense, but moving the code store inside the agent product is the prerequisite for controlling execution, review and history.
llama.cpp adds a receipt to its binaries. The project now attests signed release artifacts, giving downloaded inference binaries a verifiable build origin. Model supply-chain checks usually stop at weights; the runtime executing those weights is just as privileged.

Quick Takes

Codex makes sessions branchable. Version 0.148 can fork, archive, restore and export complete sessions, while eligible workspaces can see estimated thread credits. Forking separates an experiment from its parent record. Agent work is becoming a durable, inspectable artifact instead of a terminal process that disappears when the window closes. (Source)
Pydantic puts a wall clock around blocking tools. Pydantic AI 2.32 moves synchronous hooks into a thread pool and enforces configured timeouts for blocking tools and hooks. A declared timeout now constrains the code that was most likely to ignore the event loop. Failure becomes a bounded run error instead of a hanging process. (Source)
Claude extends capacity, not burst size. Anthropic is keeping Claude Code's 50% weekly-limit increase through August 31 for Pro, Max, Team and seat-based Enterprise users. The five-hour limit is unchanged, so the promotion expands total work without removing the short-window throttle. Capacity remains a scheduling problem, not a simple monthly allowance. (Source)

The Thread

DeepSeek gets paid when the loop runs; an enterprise gets value only when every required state change sticks. That mismatch creates the next AI margin pool. Codex's session branches and Pydantic's timeouts are early controls on the expensive middle: they preserve recoverable work and stop unbounded attempts. Model vendors can change token prices, but runtime owners that turn failures into explicit, resumable exceptions decide how much inference becomes billable waste. The control point is moving from generation to exception management.

Predictions

New predictions:

I predict: By September 30, at least one major agent SDK or coding-agent dashboard will expose a first-party task-level spend cap or per-workflow cost estimate. A token-only usage alert does not count. (Confidence: medium; Check by: 2026-09-30)

Issue date: 2026-08-19 · Generated: 2026-08-19 03:57 AM EDT