Cognition raised $1B because Devin now writes 89% of its own code

On May 27, 2026, Cognition announced a Series D of more than $1 billion at a $26 billion valuation. Revenue run rate hit $492 million, up from $37 million a year earlier. Those numbers are loud.

The detail I keep coming back to is quieter and more useful: 89% of code committed by Cognition engineers is now committed by Devin, up from 13% in December 2025. They are not selling a demo. They are running the company on the product.

What changed in five months

When Devin launched in March 2024, autonomous coding agents felt like a benchmark stunt. SWE-bench scores made headlines. Production usage was thin.

The trajectory inside Cognition tells a different story now:

That is not "we tried an agent once." That is a team restructuring how software gets written.

Agent-first vs IDE-first: two different bets

The funding round lands in the middle of a market split:

1. IDE copilots (Cursor, Windsurf inline, GitHub Copilot) keep the human at the keyboard. The model suggests the next edit.
2. Autonomous agents (Devin) take a task description, plan work, use tools, test, and open a PR. The human reviews outcomes.

Cognition's bet is that the agent layer, not the model layer, is where durable value accrues. Devin routes across Anthropic, OpenAI, Google, and Cognition's own SWE-1.6 instead of locking you into one foundation model.

I have shipped with both patterns. Copilots win on tight feedback loops inside a file you already understand. Agents win when the task spans files, commands, browser docs, and a test run. The Mercedes-Benz story Cognition cites (eight-month legacy modernization compressed to eight days) is the second shape of work.

How Devin actually runs (brain + devbox)

Under the hood, Devin separates reasoning from execution:

• Brain: cloud-side planner that breaks tasks into steps, recalls context, and recovers from errors.
• Devbox: sandboxed Linux environment with shell, editor, and browser. Same toolchain a human engineer would use.

That split matters for security and scale. Reasoning can stay stateless while execution environments spin up per task. You review progress, accept feedback, and intervene when the plan drifts.

Recent architecture writing also points to Devin Fusion, a hybrid routing layer that sends routine checks to smaller helper agents and reserves heavier models for planning. If you are designing your own agent stack, that pattern is worth stealing: not every step needs your most expensive model.

What I would (and would not) delegate today

Good fits for autonomous agents right now:

• Ticket-shaped work with clear acceptance criteria (migrations, test coverage gaps, dependency bumps)
• Internal tools where failure is contained
• Greenfield modules behind feature flags
• Documentation and boilerplate that humans hate writing

Still human-first:

• Auth, billing, and permission changes
• Cross-team API contracts
• Anything where "almost right" is worse than slow

The 89% figure is Cognition eating its own cooking on product engineering. Your team will not flip that switch overnight. But the direction is clear: engineers spend more time framing problems; agents spend more time executing.

Numbers worth keeping in your head

Useful references:

• Cognition Series D announcement
• Introducing Devin
• Cursor (IDE copilot lane for comparison)

The takeaway for applied AI builders

Autonomous coding crossed from "interesting benchmark" to "how this company builds software." The market is pricing that shift at $26 billion.

If you run engineering or client delivery, the practical question is not whether agents work. It is which tasks you will route to them first, what review gates you need, and how you measure cost per merged PR versus human throughput.

I am wiring more agent-first workflows into client projects this year, always with scoped sandboxes and human review on production paths. If you want a second pair of eyes on where agents fit in your stack (and where they do not), book a free discovery call.