Executive Summary
Raw model intelligence is now cheap and gets cheaper every few weeks. Cost, reliability and lock-in have moved into the harness: retries, caching, compaction, stop conditions and verification. OpenAI's DevDay and Anthropic's Opus 5.5 release push in the same direction. Both labs are moving up the stack into the operational layer around the model. That layer is also where enterprise money gets lost and where vendors most want to own the customer. The weakest part of that stack is verification. Labs ship generation capability on 18 day cycles, but even Anthropic's first-party eval tooling grades its own output with opaque logic. Enterprises that measure cost-per-task on their own workloads, and keep evaluation independent of the vendor, will capture the deflation. Those that buy on rate cards and vendor auto-QA will pay for it in rework.
What Changed
- Computer use is now economically viable. GPT-6.1 Sol runs computer-use tasks at about 1/7 the cost and 7x the speed of Astra. Most of the gain comes from architecture: the model reads the accessibility tree and DOM and emits multi-step JavaScript instead of running screenshot-and-click loops. "No API" is no longer a hard blocker for automating a workflow.
- The price ladder split in two. Near-frontier intelligence costs $2/$10 per million tokens (Sol) and $4/$20 (Opus 5.5, 60% below Fable 5.1). Premium latency runs the other way: Cerebras-backed Ultrafast costs 6x more, and one user reportedly burned $1,000 in 90 minutes. The $500 Pro tier gives worse marginal value than the $200 tier.
- OpenAI is building agent plumbing as cloud primitives. These include a 12 hour prompt cache, cache pre-warming, async tool calls, mid-turn steering and built-in context compaction. That is OpenAI's EC2/S3 play for long-running agents.
- Labs copy community patterns within weeks. The Decisions API shipped four weeks after an open-source pattern spread to about 100 clones. Anthropic reports 80%+ Claude-authored code internally and an 18 day flagship release cadence.
- First-party eval tooling arrived immature. The Claude Code
build_eval/hill-climbplugin finds failure modes well. However, it asks users to pick an eval target before they look at the data. Its graders bundle four distinct failure conditions into one opaque score.
Cross-Expert Synthesis
Jones and Berman reach the same conclusion from opposite directions: the rate card is the wrong unit. Jones gets there through efficiency. A model that needs fewer retries and file reads at a lower price cuts real workload cost about 40%, so measure cost-per-task. Berman gets there through pricing structure. Intelligence and latency now sit on divergent cost curves, so budget them separately. Taken together, procurement models built on per-seat or per-token assumptions are already obsolete.
The sharpest tension is between Latent Space and Husain. OpenAI presents agents using computer use to QA their own code as a way to compress the SDLC. Husain's live test shows what happens when the creator of a model automates evaluation end to end: speed beats rigor, labels get validated through chat, and graders become uninspectable. Self-verifying loops are where the industry is heading. The evidence from this week says the verification half of the loop is not ready to run without human anchoring.
Jones's warning about overnight agents (18 hour runs need explicit stop conditions or token burn is unbounded) and OpenAI's long-duration cache and compaction primitives describe the same problem. Long-running agents are a cost-control problem before they are a capability problem. OpenAI is offering to solve it inside its own cloud.
Enterprise Implications
The platform battle has moved from model quality to agent infrastructure. That changes where lock-in risk sits. Switching models is cheap, because 18 day cadences make every choice temporary. Switching harnesses is not. Agents built on OpenAI's cache guarantees, steering, compaction, cloud-native Codex and bring-your-own-tokens distribution will be very hard to move. Dots adds a billing coupling: Dots conversations are free, but standard meters start the moment Dots drives a ChatGPT or Codex thread.
Computer use reopens the integration backlog. Legacy and API-restricted SaaS can now be automated through the UI. This changes the build-vs-integrate decision for workflows previously written off. It also creates a new governance surface: agents with standing credentials operating human interfaces.
The Decisions API reuses existing weights, and OpenAI's own product lead calls confidence calibration unresolved. Treat it as a fast classifier, not as an automated decision authority.
What To Do About It
- Build a standing cost-per-task benchmark from 10 to 20 real recurring workloads. Re-run it on every release and log failures and retries, not just completions. At an 18 day cadence it pays for itself within a quarter.
- Split AI budget lines into commodity intelligence and premium latency. Require workload-specific justification before buying Ultrafast or top-tier plans.
- Separate evaluation from the generation vendor. Use vendor auto-eval for discovering failure modes only. Keep error analysis human-led, keep one failure condition per grader, and read the grader code.
- Pilot computer use on two or three high-volume, UI-only workflows behind scoped credentials and session logging. Prioritize vendors that restrict API access on purpose.
- Require stop conditions and a defined "done" state for any agent that runs unattended.
Customer question worth asking: "If you swapped model vendors tomorrow, what in your agent stack would break: the prompts, or the caching, compaction and steering plumbing underneath them?" Most teams discover that the second answer is the real lock-in.
Risks and Blind Spots
Most of these numbers come from vendors: 7x, 40%, 80% Claude-authored code. The third-party corroboration (GitHub, Lovable, Spotify) is from early partners, not independent audits. Coverage of model naming is inconsistent (Sol vs. Soul, Astra as both baseline and Ultrafast base), so pricing comparisons should be checked against official rate cards before they go into client material.
Labs absorb community patterns within four weeks, which shortens the moat for any startup an enterprise builds on top of. Vendor diligence needs a "will the lab ship this next month" test.
The largest blind spot is security. Computer-use agents with standing access to email, calendars and legacy admin UIs widen the prompt injection and credential exposure surface considerably. None of these sources addressed that.