What Is Devin? Cognition's AI Engineer

How Devin Works

Devin is not a plugin that lives inside an editor you already use. It is a cloud agent: you hand it a task in natural language, or via a message in Slack, Linear, or Jira, and it provisions its own sandboxed Linux environment on Cognition's infrastructure. Inside that sandbox it has a shell, a headless browser it can navigate and read, a code-editor view you can watch in real time, and a full filesystem with git, package managers, and language runtimes already installed.

From there, Devin runs a loop that looks a lot like how a competent engineer actually works, not how a chat model answers a single question. It reads the task, forms a plan, and breaks that plan into a sequence of concrete actions — clone the repo, locate the failing test, reproduce the bug, edit the file, rerun the test suite, check the diff. Crucially, it inspects the output of each action before deciding the next one. If a command fails, if a test still fails after an edit, or if a dependency conflicts with another package, Devin reads the actual error text and revises its plan rather than declaring victory. That read-act-observe-revise cycle, sometimes called an "agent loop," is the mechanical difference between an agent and a chatbot: a chatbot predicts the next best-sounding paragraph, while an agent executes a step, checks whether the real world agreed with its prediction, and corrects course if it didn't.

Think of the difference like the gap between a recipe and a chef. A large language model answering a coding question in a chat window is like a recipe: it hands you instructions and stops, and if the oven runs hot or an ingredient is missing, the recipe has no idea and does nothing about it. Devin is closer to a chef working from that recipe in an actual kitchen — tasting as it goes, adjusting the heat, swapping an ingredient when something's off, and only plating the dish once it has actually verified it's right.

You are not locked out while any of this happens. Devin surfaces its plan and each step it takes in a live session view, and you can interrupt, leave a comment on a specific step, correct its direction, or take the keyboard yourself at any point — closer to reviewing a junior engineer's work-in-progress branch than to submitting a batch job and walking away entirely.

This is architecturally distinct from the two other dominant categories of AI coding tool. Claude Code, Anthropic's terminal-first agentic tool, runs locally on your own machine against your own filesystem, which means your code never has to leave your laptop and there's no cloud sandbox to provision, but it also means Claude Code doesn't have Devin's built-in browser or persistent async execution. Cursor, a fork of VS Code with an AI pair programmer layered in, is built around fast, inline, synchronous editing — you're watching every keystroke rather than delegating a multi-hour ticket and walking away. Devin's whole design bet is that a meaningful share of engineering work — a dependency upgrade across forty repos, a flaky-test investigation, a well-scoped bug fix from a ticket — doesn't need a human staring at the screen the entire time.

What is the "ACI" that Devin's engineers talk about?

Cognition has described building what it calls an "agent-computer interface," the tooling layer that lets Devin interact reliably with a shell, editor, and browser without hallucinating command syntax. Rather than treating the sandbox as a black box the model narrates about, the ACI exposes structured, verifiable feedback — exit codes, diffs, test results — back to the model after every action, which is what makes the self-correction loop trustworthy enough to run unsupervised.

Devin 2.0 and the Price Collapse

Cognition relaunched the product as Devin 2.0 in April 2025, and the release note doubles as an admission that the original $500-a-month, enterprise-only version had priced out the audience most likely to make Devin better through daily use. Devin 2.0 introduced a self-serve entry point, a redesigned interactive planning view, and — most consequentially — usage-based pricing built around a new unit called the Agent Compute Unit (ACU).

An ACU is Cognition's normalized measure of the resources a Devin session actually consumes while it's working: sandbox compute time, the underlying model inference calls, and network bandwidth, all rolled into one number so a customer doesn't have to reason about GPU-seconds or token counts directly. Cognition's own rule of thumb is that one ACU is roughly equivalent to fifteen minutes of continuous, autonomous Devin work (Cognition pricing documentation, 2026; reporting via UsagePricing, 2026).

Era	Pricing	Notes
Launch (March 2024)	$500/month flat	Enterprise-only, waitlisted
Devin 2.0 (April 2025)	$20/month + ACU credits	Opened to individual developers
2026	Free / Pro $20 / Max $200 / Teams $80 + $40 per seat / Enterprise custom	ACU billed at $2.25 (Core) or $2.00 (Teams) per unit

Table: Devin pricing evolution, 2024–2026, sourced from Cognition's public pricing changes and third-party pricing trackers (VentureBeat; UsagePricing, 2026).

The competitive pressure behind that 25x cut is not subtle. Claude Code shipped with pay-as-you-go and Pro-plan pricing that undercut $500 a month by a wide margin, Cursor's agent mode delivered comparable multi-step autonomy inside a familiar editor for $20 a month, and free, open-source options like Aider closed the gap further for developers willing to bring their own API key. Cognition had to compete on price because it no longer had a monopoly on the idea of an autonomous coding agent — it had roughly a year's head start, and the rest of the industry used that year well.

The Windsurf Saga: A Three-Way Fight Cognition Won by Losing First

The most tangled part of Devin's story doesn't involve Devin directly at all — it involves the IDE Cognition ended up owning. In mid-2025, OpenAI had negotiated a reported $3 billion deal to acquire Windsurf (the AI-native code editor formerly known as Codeium), but the deal's exclusivity window expired on July 11, 2025 after OpenAI and Microsoft failed to agree on how Microsoft, as an OpenAI partner and investor, would get access to Windsurf's underlying intellectual property (BankInfoSecurity, "Unpacking the $5 Billion Power Struggle for a Tiny AI Firm," 2025).

Within roughly 72 hours of that deal collapsing, Google DeepMind moved in — not to buy the company, but to hire its way around an acquisition. Google signed a reported $2.4 billion non-exclusive licensing-and-hiring deal that brought Windsurf CEO Varun Mohan, co-founder Douglas Chen, and a group of the company's key researchers over to DeepMind, while taking no equity stake in Windsurf itself (CNBC, "Cognition to buy AI startup Windsurf days after Google poached CEO," July 14, 2025).

That left roughly 210 Windsurf employees, its product, its trademark, and its enterprise business — reported at about $82 million in annual recurring revenue and 350-plus enterprise customers — without the leadership that had just left for Google. Cognition stepped in on July 14, 2025 and acquired what remained: Windsurf's IP, product, brand, and staff, at a price reported around $250 million by outlets covering the deal, though Cognition itself has not disclosed exact terms (Cognition, "Cognition's acquisition of Windsurf," 2025; InfoWorld, "Cognition agrees to buy what's left of Windsurf," 2025). Founder Scott Wu structured the deal to be unusually generous to the employees Google hadn't taken: 100% financial participation in the transaction, waived vesting cliffs, and fully accelerated vesting for work already done. Two months later, investors valued Cognition at $10.2 billion, and the company said its combined annual recurring revenue had more than doubled since the acquisition closed (CNBC, "Cognition valued at $10.2 billion two months after Windsurf purchase," September 2025).

The IDE didn't stay "Windsurf" for long. On June 2, 2026, Cognition shipped an over-the-air update that rebranded Windsurf entirely as Devin Desktop — no reinstall or migration wizard required, existing users simply received the new build on their next restart. The rebrand was more than cosmetic. The old code-first editor canvas became an "Agent Command Center," a Kanban-style board that shows every agent session — local or cloud — organized by status: in progress, blocked, or ready for review. Cascade, the local agent that had powered Windsurf since its Codeium days, was retired, with an end-of-life date of July 1, 2026, and replaced by Devin Local, described as a full Rust rewrite of the local-agent engine. A new feature called "Spaces" gives teams shared workspaces where multiple agent sessions, their pull requests, and their context all live together instead of being scattered across separate chats.

The strategic bet embedded in Devin Desktop is arguably more interesting than the rebrand itself. Rather than trying to lock users into Devin's own models, Devin Desktop ships supporting the open Agent Client Protocol (Apache 2.0 licensed), which means Codex, Claude Agent, Gemini CLI, OpenCode, and JetBrains' Junie can all run as first-class agents inside the same editor, side by side with Devin (Digital Applied, "Windsurf Is Now Devin Desktop," 2026). In effect, Cognition decided the editor doesn't need to be a walled garden for its own model — it needs to be the best place to coordinate whichever agents a team already uses, competitors included. That's a notably different posture than Cursor's, which is far more tightly built around its own agent stack.

Devin in 2026: What the Product Actually Does Now

Cognition has kept shipping features around the core agent loop rather than reinventing it. As of mid-2026, the meaningful additions are:

• Devin Search — a semantic index of your entire codebase that Devin consults before making a change, so its plan is grounded in how your project actually works rather than in generic patterns from its training data.
• Parallel Devins — the ability to run multiple independent Devin sessions on different tickets simultaneously, which is the feature that most directly supports the "fire and forget" workflow Cognition markets the product around.
• Playbooks — saved task templates ("upgrade dependency X across every repo in this org," "triage new bug reports tagged p2 every morning") that Devin can execute on a recurring schedule without a human re-typing the instructions each time.
• Knowledge — a persistent memory layer that retains your team's coding conventions, architectural decisions, and past corrections across sessions, so Devin doesn't relearn the same lessons on every new ticket.
• Integrations — first-party connectors for Slack, Linear, Jira, GitHub, and GitLab, so a Devin-authored pull request shows up exactly where a human teammate's would.
• SWE-1.7 — Cognition's own proprietary coding model, launched July 8, 2026, which the company positions as a near-frontier model at a fraction of the inference cost of the largest general-purpose models. Third-party trackers estimate SWE-1.7 completes tasks on the FrontierCode Main benchmark at roughly $1.97 per task, though Cognition has not published an official per-task price (Tech Insider Ireland, "Cognition's SWE-1.7 Undercuts Rivals at $1.97 a Task," 2026; Mervin Praison, "Cognition SWE-1.7," July 2026).
• Devin Desktop / ACP support — the multi-agent IDE described above, positioning Devin as a coordination layer that can host competitors' agents rather than a closed ecosystem.

On the benchmark that made Devin famous, the honest answer is "it depends heavily on how you measure it." In Cognition's own SWE-bench technical report, Devin 2.0 scores 45.8% on SWE-bench Verified under a strict, no-human-in-the-loop, no-best-of-N constraint — a deliberately conservative setting meant to reflect real unsupervised use. Under looser evaluation conditions that allow multiple attempts, third-party trackers have recorded scores as high as 72% for Devin 2.0 (Cognition, "SWE-bench technical report"; AIToolRanked, "Devin AI Review 2026"). For context, that's a large jump from the 13.86% launch figure, but it also sits behind the frontier general-purpose models now topping the public SWE-bench Verified leaderboard, some of which have been reported above 90% under best-of-N conditions in 2026 (Steel.dev, SWE-bench Verified Leaderboard, 2026). Devin's pitch has never really been "the single smartest model" — it's "the most complete autonomous environment," and those are different competitions.

What Devin Actually Looks Like on a Real Ticket

It's worth walking through a concrete example rather than staying abstract. Say a team files a ticket: "Users report that CSV exports silently drop rows containing commas inside a quoted field." Handed to Devin via a Linear integration, the agent's session typically unfolds in a predictable shape. First, it clones the repository into its sandbox and runs the existing test suite to establish a working baseline — if tests are already red before it touches anything, it needs to know that going in. Next, it uses Devin Search to locate the CSV export logic, rather than grepping blindly, because a semantic index surfaces the relevant function even if the ticket's wording doesn't match the code's naming.

From there it writes a minimal reproduction — often a small script or a new test case that captures the exact failure described in the ticket — and runs it to confirm the bug is real and matches the report before writing a single line of fix. Only then does it edit the parsing logic, rerun the reproduction case, rerun the full suite to check for regressions elsewhere, and open a pull request with a description that references the original ticket. A human reviewer sees a normal-looking PR, not a black box: the commit history shows the reproduction step before the fix step, which is itself a signal of whether the agent actually understood the bug or just guessed at a plausible-looking patch.

This is also where Devin's limits show up fastest. If the ticket is ambiguous — "exports feel slow, can you look into it" — Devin has to guess at scope, and it's meaningfully more likely to either over-fix (refactoring far more than the ticket asked for) or under-fix (patching the first slow-looking function it finds rather than profiling to find the real bottleneck) than a senior engineer who'd ask a clarifying question first. Cognition's own materials and independent reviewers converge on the same conclusion: Devin is strongest on well-scoped, verifiable work and weakest on ambiguous, judgment-heavy work — which is close to true of most junior engineers, human or not.

Comparison: AI Software Engineers in 2026

Tool	Form Factor	Individual Pricing	Best For	Weakness
Devin	Cloud agent (+ Devin Desktop IDE)	$20/mo (Pro) + ACU credits; $200/mo (Max)	Async tickets, parallel work, Slack/Jira-native workflows	No fully local/offline mode; cost scales with ACU usage
Claude Code	Terminal CLI	$20/mo (Pro plan) or usage-based API	Power users, local repos, deep refactors, code review	No built-in browser or cloud sandbox by default
Cursor	IDE (VS Code fork)	$20/mo	Real-time pair programming, fast inline edits	Less built for hours-long unsupervised sessions
OpenAI Codex CLI	Terminal CLI	Pay-per-use API	Teams already standardized on OpenAI models	Smaller third-party ecosystem than Claude Code/Cursor
GitHub Copilot Workspace	Web (GitHub.com)	Bundled with Copilot subscription	GitHub-native issue-to-PR workflows	Slower feature cadence than the rest of the field
Aider	Terminal CLI	Free, open source (bring your own API key)	Developers who want full control and no vendor lock-in	Manual task scoping; no built-in sandbox or browser

Table: How the major AI coding agents compare on form factor, price, and fit, as of mid-2026.

The short version: Devin owns the "fire and forget" lane, where a task gets handed off and checked on later, often outside any editor at all. Claude Code and Cursor own the "AI working next to you in real time" lane, where the human stays in the loop step by step. Everything else in the table is a variation on one of those two postures, distinguished mostly by which model or platform it's tied to.

Where Devin Wins and Where It Loses

Devin's genuine strength is scope that maps cleanly to a "junior engineer left to work overnight" mental model: dependency upgrades that touch dozens of files in predictable ways, flaky-test investigations that require patient, repeated re-runs, well-described bug tickets with a clear reproduction path, and repetitive migrations across many repositories at once. Parallel Devins make this compound — a team lead can queue up five well-scoped tickets on Monday morning and review five draft PRs by lunch, which is a genuinely different workflow shape than anything a synchronous pair-programming tool offers.

Its honest weaknesses cluster around three things. First, latency and cost: spinning up a cloud sandbox and running a multi-step agent loop is slower and pricier per task than a quick inline suggestion in Cursor, so Devin is a poor fit for the rapid, thirty-second edits that make up a large share of a typical coding session. Second, ambiguity tolerance: as the CSV export example above shows, Devin does best when a ticket already has a clear definition of "done," and degrades when the task requires the kind of clarifying conversation a human teammate would normally have before starting work. Third, data locality: because Devin's sandbox runs on Cognition's infrastructure by default, teams with strict data-residency or air-gapped requirements need the enterprise tier specifically to keep code from leaving their own environment — that's not a limitation for most startups, but it rules Devin out for a meaningful slice of regulated industries without a custom contract.

Common Misconceptions About Devin

A few claims about Devin circulate persistently and are worth correcting directly. The first is that Devin "replaced" OpenAI's Windsurf deal — it didn't. OpenAI's own attempt to buy Windsurf fell apart in July 2025 over IP-access terms with Microsoft; Google then hired away Windsurf's leadership and top researchers in a licensing deal that took no equity; Cognition subsequently bought what was left of the company — its product, brand, IP, and remaining staff. Three different companies were involved in three different transactions within the same week, and conflating any two of them misstates what happened.

The second misconception is that Devin's 13.86% launch score and its 2026 SWE-bench Verified scores are directly comparable. They're not: they were measured on different benchmark variants (SWE-bench versus SWE-bench Verified, a curated subset with human-validated test cases) under different evaluation conditions, so treating the jump from 13.86% to 45–72% as a clean apples-to-apples improvement overstates the comparison, even though the underlying product genuinely has improved substantially.

The third misconception is that Devin is a drop-in replacement for an engineer. Cognition itself doesn't claim that in its 2026 marketing, and the benchmark data doesn't support it either — Devin resolves a meaningful share of well-scoped, verifiable tickets unsupervised, but architectural decisions, ambiguous product requirements, and judgment calls about what shouldn't be built at all remain firmly human work in every credible account of how teams actually use the tool.

Should You Use Devin?

Devin is worth trying if you want to delegate well-scoped tickets the way you'd delegate to a junior engineer and check back later, if your team already lives in Slack, Linear, or Jira and wants AI-authored work to surface there as a normal pull request, and if you're comfortable with a cloud-hosted execution environment rather than requiring everything to run on your own machine.

Skip Devin, or at least don't lead with it, if you want tight, second-by-second feedback loops while you code — Cursor or Claude Code fit that better. Skip it too if you work on proprietary code that legally or contractually cannot leave your own infrastructure without an enterprise agreement, or if you'd rather pay per token for exactly what you use than pay for seats and ACU credits.

Devin is also a weak starting point if you're new to programming and trying to learn, because it abstracts away the exact decisions a beginner needs practice making. For that audience, working directly with an editor-embedded assistant is a better fit — see our explainer on vibe coding for how AI-first, in-the-loop programming actually works day to day, and our broader look at how AI agents plan and self-correct for the mechanics behind tools like Devin, Claude Code, and Cursor's agent modes.

The takeaway

Devin's story is less about one breakthrough model and more about an evolving bet on what autonomy in software engineering should look like: a full sandboxed environment, a self-correcting agent loop, and now a multi-agent IDE that's willing to host competitors rather than lock users in. The price collapse from $500 to $20 a month and the SWE-bench jump from 13.86% to the mid-40s (or higher, depending on how you measure) both reflect the same underlying pressure — an entire industry chasing the same idea within months of Cognition proving it was possible. Devin in 2026 is neither the overhyped demo of March 2024 nor the engineer-replacement some marketing implied; it's a genuinely useful tool for well-scoped, asynchronous work that still needs a human deciding what's worth building in the first place.

FAQ

Q: Is Devin actually autonomous, or does it need hand-holding? A: It's largely autonomous on well-scoped tasks like bug fixes, dependency upgrades, and clearly described features, and needs more hand-holding on ambiguous or research-style work. The 2024 launch demos overstated how autonomous the product was; the 2026 version behaves closer to a junior engineer who can work unsupervised on clearly defined tickets.

Q: Is Devin better than Claude Code? A: They're built for different workflows rather than being strictly better or worse. Claude Code runs locally and suits fast, interactive work on your own machine; Devin runs in the cloud and suits handing off a ticket and coming back later to a finished pull request. Many engineering teams use both depending on the task.

Q: What model powers Devin? A: Cognition built its own proprietary coding model, SWE-1.7, launched July 8, 2026, and has historically also blended in frontier models from other labs alongside its own agent-computer-interface and planning layer. The differentiator Cognition emphasizes is the agent harness and sandbox tooling, not any single underlying model.

Q: How much does Devin cost in 2026? A: Plans range from a free tier up to Pro at $20/month, Max at $200/month, and Teams at $80/month plus $40 per additional seat, with enterprise pricing custom. Actual usage is metered in Agent Compute Units at $2.25 per unit on the Core plan and $2.00 per unit on Teams — down from a flat $500/month at 2024 launch.

Q: Did OpenAI buy Windsurf or did Cognition? A: Neither deal happened the way either company originally planned. OpenAI's attempted $3 billion acquisition of Windsurf collapsed in July 2025 over IP-access disagreements with Microsoft. Google DeepMind then hired Windsurf's CEO and top researchers in a non-exclusive licensing deal without buying the company. Cognition, Devin's maker, then acquired Windsurf's remaining product, IP, brand, and staff on July 14, 2025.

Q: What happened to Windsurf? A: Cognition rebranded Windsurf as Devin Desktop on June 2, 2026, shifting the interface from a code-first editor to a multi-agent "Agent Command Center." Its old local agent, Cascade, was retired and replaced with Devin Local, and the editor now supports the open Agent Client Protocol, letting agents from other companies run inside the same IDE.

Q: What is an Agent Compute Unit (ACU)? A: An ACU is Cognition's normalized billing unit covering the sandbox compute, model inference, and network resources a Devin session consumes while actively working. Cognition's rule of thumb is that one ACU is roughly equivalent to 15 minutes of continuous, autonomous Devin activity.

Q: What is Devin's actual SWE-bench score in 2026? A: In Cognition's own technical report, Devin 2.0 scores 45.8% on SWE-bench Verified under a strict, no-human-assistance, single-attempt evaluation, with third-party trackers recording scores up to 72% under looser, multiple-attempt conditions. That's well above the 13.86% launch figure, though the two numbers were measured on different benchmark variants and aren't a clean apples-to-apples comparison.

Q: Can Devin replace software engineers? A: Not as of 2026. It handles a real share of the well-scoped, verifiable work that used to fall to junior or mid-level engineers, but architectural decisions, ambiguous product requirements, and judgment calls about what's worth building still require human engineers. Cognition's own product positioning and independent reviews both describe it as a delegation tool rather than a replacement.

Q: Can I run Devin on code that can't leave my own servers? A: Only through Cognition's enterprise plan, which supports deployment with additional security controls. On the standard Free, Pro, Max, and Teams tiers, Devin's sandbox runs on Cognition's own cloud infrastructure by default.

Sources

• Cognition, "Introducing Devin, the first AI software engineer" (March 12, 2024)
• VentureBeat, "Devin 2.0 is here: Cognition slashes price ... to $20 per month from $500" (April 2025)
• Cognition, "SWE-bench technical report"
• Cognition, "Cognition's acquisition of Windsurf" (July 2025)
• BankInfoSecurity, "Unpacking the $5 Billion Power Struggle for a Tiny AI Firm" (2025)
• CNBC, "Cognition to buy AI startup Windsurf days after Google poached CEO" (July 14, 2025)
• CNBC, "Cognition valued at $10.2 billion two months after Windsurf purchase" (September 8, 2025)
• InfoWorld, "Cognition agrees to buy what's left of Windsurf" (2025)
• Digital Applied, "Windsurf Is Now Devin Desktop: What Users Should Do" (2026)
• Tech Insider Ireland, "Cognition's SWE-1.7 Undercuts Rivals at $1.97 a Task" (2026)
• UsagePricing, "Cognition (Devin) Pricing" (2026)
• Steel.dev, SWE-bench Verified Leaderboard (2026)
• Carl Brown, "Internet of Bugs" Devin demo analysis (YouTube, 2024)

See also: Claude Code explained · AI agents explained · Vibe coding explained