On May 27, 2026, Cognition announced a $1B+ funding round at a $26B post-money valuation. That headline number will dominate the coverage. But the stat that matters for builders is buried in the middle: 89% of the code committed at Cognition is now written by Devin.
That figure grew from 13% in December 2025. Five months. 13% to 89%.
If you’re building AI-assisted software workflows and you read nothing else from this round, read that trajectory. Because it tells you something about where the architectural leverage actually lives — and it’s not where most teams are currently investing.
The Numbers in Context
Cognition’s revenue trajectory is unusual even for a well-funded AI company:
- May 2025: ~$37M ARR
- May 2026: $492M ARR
- Growth: 13x in 12 months
- Enterprise usage: up 10x since January 2026 (~50% month-over-month for six consecutive months)
- Target: $1B ARR before end of 2026
- Total funding to date: more than $2.5B
The previous round was $400M at a $10.2B post-money valuation in September 2025. The new $26B valuation is more than 2.5x that — in under nine months.
Investors in this round include Lux Capital, General Catalyst, 8VC, Founders Fund, Ribbit Capital, Atreides Management, and Elad Gil.
These are not buyers speculating on AI hype. General Catalyst and Founders Fund have decades of enterprise-software pattern recognition between them. When they lead a $1B round at a $26B valuation based on demonstrable ARR, they’re expressing a view about which architectural bet is winning.
What Enterprise Customers Are Actually Running
The enterprise case studies published alongside the announcement clarify what Devin is being used for in production. These are the examples builders should study, because they reveal what “agent-first” means in practice rather than in demo.
Mercedes-Benz: A legacy modernization project that engineering estimated at eight months was completed in eight days with Devin. The task was code migration — systematically transforming patterns across a large, unfamiliar codebase. This is exactly the kind of work where agent-first architecture excels: well-defined goal, high repetition, large surface area, low per-decision stakes.
Itau (Brazilian banking): Itau deployed Devin for security vulnerability remediation. Devin now automatically resolves approximately 70% of security vulnerabilities without human intervention. The remaining 30% get flagged for human review. This is a triage + execution workflow — the agent handles the routine cases, humans handle the edge cases.
Goldman Sachs, Citi, Santander, Dell, Palantir, NASA, U.S. Army and Navy: All listed as enterprise customers. The breadth of this list — from investment banking to defense to aerospace — signals that the blocking objections (security, compliance, auditability) have been answered well enough to close contracts, even if not perfectly solved.
The pattern across these case studies: large-surface-area, high-repetition tasks with clear success criteria and bounded scope. Not “figure out the architecture.” Not “decide what to build.” Execute against a specification across a lot of code.
The Architectural Fork: Agent-First vs. IDE Copilot
The mainstream adoption curve for AI coding assistance has two distinct architectures, and Cognition’s trajectory is the clearest evidence yet that they diverge meaningfully in outcomes.
IDE copilot architecture treats the AI as an intelligent autocomplete. The human is the agent; the AI is an input-accelerator. You write code, the AI suggests completions. You describe a function, the AI drafts it. The human reviews everything, directs every step, and maintains full situational awareness of the codebase. Tools like GitHub Copilot, Cursor, and Codeium live here. This architecture is deeply familiar to developers and slots neatly into existing workflows.
Agent-first architecture inverts the relationship. The AI is the agent; the human is the goal-setter and reviewer. You specify an outcome — migrate this module, fix these 47 vulnerabilities, implement this feature to these acceptance criteria — and the agent executes autonomously, committing changes, running tests, and handling errors without waiting for your input at each step. Devin, Claude Code, and Antigravity 2.0 live here. This architecture requires a different mental model and different tooling, but it’s the architecture that produces the Mercedes-Benz 8-month-to-8-day compression.
The stat that reveals the divergence: Cognition grew its own Devin-written code share from 13% to 89% in five months. A team using IDE copilot architecture doesn’t see numbers like that, because the human bottleneck remains in the loop. A team using agent-first architecture, where the agent runs autonomously against a well-specified goal, can reach the kind of leverage those numbers represent.
This is not an argument that agent-first is right for all tasks. It is an argument that the tasks where agent-first architecture applies are larger and more valuable than most teams currently recognize — and that teams who map those tasks correctly will compound their velocity advantage over time.
What the 89% Stat Actually Measures
The 89% figure deserves a closer read, because what it measures tells you something about how to structure your own agent-first workflows.
It does not mean Devin writes 89% of the logic or makes 89% of the architectural decisions. It means Devin accounts for 89% of committed code. The humans at Cognition are still specifying goals, reviewing outputs, handling ambiguous edge cases, and making architectural calls. What Devin has displaced is the mechanical execution layer: the transformation, the boilerplate, the test scaffolding, the migration, the systematic application of patterns across a large surface area.
This distinction matters for builders, because it points to where the agent-first yield is highest:
- High yield: Tasks with clear success criteria, measurable outputs, large surface area, repetitive structure (migration, vulnerability patching, test generation, refactoring to a new pattern)
- Lower yield: Tasks requiring deep contextual judgment, novel architectural decisions, stakeholder negotiation, or understanding of business priorities the agent doesn’t have
If you’re building internal agent workflows and wondering where to start, the Cognition case studies tell you: start with the tasks where you currently have a large backlog of well-understood-but-tedious work. The ROI is clearest there, and the mistakes are least expensive.
The Self-Validation Loop
There’s a recursion in Cognition’s story worth naming: they are shipping an agent that builds software faster, using that agent to build their own software faster, which accelerates their ability to improve the agent, which improves their ability to build software faster. This is what a compounding agent-first advantage looks like when it’s working.
89% of committed code being agent-written means their engineering team is spending most of its cognitive budget on goals, specifications, reviews, and architectural decisions — not execution. If their per-engineer throughput is 10x what it was in December (a rough implication of 13% → 89% Devin-written share), and they’re hiring engineers at a normal pace, the compounding is significant.
This is not magic. It requires well-specified goals, solid evaluation criteria, and a team that has learned how to operate an agent-first development pipeline. Those are learnable skills. The barrier is lower than most teams assume.
Builder Checklist: Agent-First Transition Points
Based on the Cognition case studies and the architecture distinction above, here’s a practical framing for builders evaluating where agent-first fits their work:
1. Identify your high-surface, low-ambiguity backlog. What work accumulates because it’s tedious, not because it’s hard? Migration tasks, technical debt remediation, test coverage gaps, documentation generation, systematic refactoring — these are your entry points.
2. Specify goals, not steps. Agent-first workflows succeed when you give the agent an outcome to achieve and success criteria to evaluate against. They fail when you try to prescribe every step. Write acceptance tests before you write the agent prompt.
3. Instrument for review, not intervention. In an IDE copilot workflow, you review in real time. In an agent-first workflow, you review the output. Design your review checkpoints accordingly: define what “done” looks like, have the agent generate a diff or summary, then evaluate against your criteria.
4. Build the feedback loop. Cognition’s trajectory from 13% to 89% didn’t happen in one sprint. It happened because they shipped, reviewed, identified where Devin failed, improved the specifications or the tooling, and repeated. The compounding is in the iteration, not the initial deployment.
5. Start with bounded scope. Mercedes-Benz ran Devin on a legacy migration — a bounded task with clear start and end states. Itau ran it on vulnerability remediation — a well-defined evaluation criterion (is the vulnerability resolved?). Neither case was “improve the overall engineering quality of the codebase.” Bounded scope produces measurable results and reveals where the architecture needs tuning.
What This Round Signals for the Market
A $26B post-money valuation on $492M ARR is a ~53x revenue multiple. That’s a venture-growth multiple, not a mature SaaS multiple. The implicit bet: Devin’s market is much larger than $492M ARR, and the current growth rate (13x in 12 months) will sustain long enough to justify it.
For builders, the market signal is simpler: the enterprise buyers who are hardest to close — Goldman, Citi, Mercedes-Benz, NASA — are running Devin in production. The objections that would have blocked deployment 18 months ago have been addressed. Agent-first coding tools are no longer in “interesting pilot” territory. They’re in production at scale.
The question for your team is not whether agent-first architecture will matter. It’s whether you’re building the operational skills to use it effectively before the builders who are will compound past you.
Cognition’s $1B round was announced May 27, 2026. The $26B figure is post-money; TechCrunch reports $25B pre-money. The 89% codebase share is the company-stated figure; some secondary sources round to 90%. Customers named above appeared in multiple outlets at announcement.