What_$25B_Is_Actually_Pricing

The Cognition thesis is specific: autonomous AI agents capable of taking a coding task and shipping it without human intervention in the loop represent a fundamental shift in how software gets built. That vision is real. A world where well-specified tasks route to agents with execution autonomy is a world where certain kinds of labour move up the value chain or off the chain entirely. The market pricing a $25B upside on that vision is rational.

What a valuation prices, though, is the vision. What it does not price is the operational reality of running that architecture at scale over time. These are not the same thing. The gap between them is the most useful signal in agentic AI right now.

What_My_System_Actually_Is

I run twelve specialised agents across eight production repositories, each with distinct autonomy tiers and decision authority. The architecture is governed by three structural choices:

Trust tiers calibrated on track record × reversibility × blast radius. An agent's historical accuracy on similar tasks, the reversibility of mistakes, and what breaks if the mistake lands determine the tier. An agent with fifty clean deployments still moves to a tighter review gate after a single high-blast-radius failure.

Model tiering matched to task load. Sonnet handles code, research, and strategy (Nix, Sable, Quinn, Tom, Oren, Reid). Haiku handles copy, social, and operations (Vera, Lena, Cleo, Maya, Jo). The override ceiling for subagent specialists is Sonnet - Haiku upgrades to Sonnet when context complexity warrants it, and no specialist runs on Opus. The orchestration layer itself - the session that dispatches specialists - runs on Opus, because the orchestrator holds the cross-stream context across every active project and that is where reasoning depth matters most.

Specification-before-code. Any change touching more than two files requires a written brief. The brief forces specification into writing before inference, preventing confident execution against incomplete context.

Supporting systems include the PR Comprehension Gate (seven questions on production repos, scaling down to three on smaller surfaces), nightly audits surfacing specification drift (EXP_004), a decisions log, and agent role definitions with scope contracts.

The_Specification_Problem:_What_the_Valuation_Does_Not_Price

The execution layer is not the bottleneck in a production agentic system. Execution is the tool. The bottleneck is specification.

An autonomous agent that can execute anything you ask it to is genuinely valuable - if and only if you have specified the task in a way that actually describes what you want. In a production system where twelve agents are continuously executing against an evolving context, it is almost never true that the task description is obvious.

The brief is not a description of what you want built. It is a specification of what the boundaries are. What modules are in scope, what modules are out of scope. What the acceptance criteria actually are. What happens if the agent executes correctly within the brief but has an unanticipated downstream effect in a system the brief did not explicitly mention. What the agent explicitly should not do, even if it could.

A short brief written by someone who knows the terrain is fast. An incomplete brief - one that sounds complete but is missing the edge case that matters - is invisible until the agent executes against it. Then it cascades. Devin's valuation does not price the labour that makes Devin safe to run. It prices the labour that Devin eliminates. These are different numbers.

The_Failure_Modes_Nobody_Demos:_What_Accumulates_Over_Time

A demo is a moment. A system is a story. Failure modes that matter in agentic AI do not appear in a demo because they require time to accumulate.

Silent failure from stale context. An agent is given a context snapshot correct at the time of request. Between snapshot and execution, another agent has updated a shared data structure. The first agent's output is coherent against stale context, incoherent against current state. The code runs. The output is wrong, silently. (For the full account of how stale context accumulates in production, see the anchor piece in this series at /module/the-ceiling-isnt-the-model.)

The blast radius problem. An agent is asked to change a feature flag in the admin module. The agent executes correctly within scope. But the flag governs downstream behaviour in the payment module, which the brief did not mention. The agent cannot know what it does not know. The blast radius question is a specification question, not an execution question.

Trust calibration over time. An agent executes well across forty deployments and earns autonomy. On the forty-first, it introduces a failure on a high-blast-radius surface. The agent's track record does not protect it. The tier tightens immediately. This is not a model problem. It is an operational pattern.

These are not model deficiencies. They are structural properties of any autonomous system in a multi-dependency environment.

The_Human_Is_Not_Removed:_They_Are_Repositioned

The Devin narrative implies labour elimination. The reality is labour transformation. The humans who remain do not write code. They design the system that writes code.

The specification layer - briefs, decisions, acceptance criteria. The work of knowing what not to build, what the constraints are, what measures success. This is not lower-skill than code-writing - it requires more context, more system-level thinking.

The architecture decisions - what agents can autonomously execute. What requires human review. Who is trusted with what tier of blast radius. These are systems design, more consequential than most individual code contributions.

The failure mode design - what the signal is that agents are operating against stale context. How you detect silent failures before they propagate. How you update trust tiers when evidence arrives. This is reliability architecture.

What this means for the $25B question: the valuation prices commoditised execution. Commoditising execution creates a new kind of labour upstream - specification and architecture labour that requires more judgment, not less.

What_the_Valuation_Gets_Right

Cognition is correct about the direction. Execution is a commodity. The ability to take a well-specified task and ship it reliably, without hand-holding - that is genuinely valuable, and it will commoditise execution labour. The market is pricing something real.

What it does not price is the specification layer, the operational architecture, and the repositioning of human judgment that make execution safe to run at scale. Those layers are not visible in a demo. They are mandatory the moment you run more than one agent continuously.