Devin: The Autonomous Cloud Software Engineer

Look at the agents you have met so far (Topics 269–272):

• Cursor and Windsurf work while you sit in the IDE, reviewing diffs.
• Claude Code can run unattended, but on your machine or CI runner.

Both share one hidden assumption: a human is present, or the compute is yours.

So the question becomes

That is Devin, launched by the company Cognition in early 2024 and marketed as the "AI software engineer." Not an assistant inside your editor — a worker on the cloud, with its own environment, that takes tickets like a coworker does.

This is a design point, not just a feature list: every choice below (pricing, wiki, reporting, risks) follows from one sentence —

A Devin session works like this:

1. You send a task — from the web app, Slack, Linear/Jira, or the API.
2. A fresh Devin provisions its own cloud VM — its own rented workshop containing three things every engineer has:
   • a shell (terminal: install packages, run builds, start servers),
   • an editor (to write and change code),
   • a browser (to read documentation and even reproduce web bugs itself).
3. It plans and breaks down the work, edits code, executes commands, and iterates on failures — the same read-the-error-try-again loop as every agent (Topic 269).
4. It finishes with a pull request plus a natural-language report: what it did, and how it verified it.
5. You can chat with it mid-session — send screenshots, redirect it — but nobody has to.

Key surfaces beyond single sessions:

• Sessions / NDEVS ("multiDevin"): parallel Devin instances tackling subtasks at once; a coordinating Devin can delegate to them — a manager splitting a feature across workers.
• Devin's Wiki: when you connect a repo, Devin auto-indexes its architecture, conventions, and dependencies into a browsable internal knowledge base. This is its answer to "does it really understand our codebase?" — you can literally open the wiki pages it wrote and check.
• DeepWiki / Stack: Cognition's public, free version of the wiki idea at deepwiki.com (auto-generated wikis for open-source repos), plus Stack, an internal Q&A over your org's knowledge.
• Devin CLI & API: start and steer sessions programmatically — including from CI.

Devin's economics are all about how well-specified the ticket is. One ACU ≈ about 15 minutes of Devin working (the details in section 6). Watch the same budget behave two ways:

Ticket A (good): "Remove deprecated getUserV2 calls. Failing test attached. Acceptance: suite green, no references remain."

code
Copy
  plan 3 steps → wiki: "getUserV2 lives in api/users.py"
  → grep finds 12 call sites → edits + test run
  → 1 failure → re-reads migration note in docs (browser)
  → fixes → PR + report          ≈ under 1 ACU

Ticket B (bad): "Improve the performance of the dashboard area."

code
Copy
  plan? → measure what? → tries 6 theories → rebuilds env twice
  → chats itself in circles → PR touches 40 files, unverifiable
                                                    ≈ many ACUs, rework

The lesson practitioners repeat: batch, delegable, verifiable work is Devin's currency. A crisp spec with a test that proves "done" converts ACUs into merged PRs; vagueness converts them into an expensive mystery novel.

Each session is an island: its own VM, its own branch, nothing escapes except the PR.

code
Copy
        YOUR WORLD                    DEVIN'S VM (throwaway)
   ┌─────────────────┐          ┌───────────────────────────┐
   │ repo @ main     │── clone →│ shell │ editor │ browser   │
   │ CI, secrets     │          │  plan→edit→test→fix loop  │
   │ your review     │←─ PR ────│ + written report          │
   └─────────────────┘          └───────────────────────────┘
     gate: only the PR crosses     destroy VM when done

That isolation is why teams tolerate real autonomy here: the agent can run arbitrary shell — but inside a rented room, on a copy, and the only permanent artifact is a pull request a human must approve.

Now stack Devin against its siblings by who watches, and where the code runs:

code
Copy
                 human watching?      where it runs
   Cursor Tab        always              your laptop
   Cascade/agent     per-diff            your laptop
   Copilot cod.agt   at PR review        GitHub's sandboxes
   Claude Code -p    optionally          your CI
   Devin             at PR review        its OWN cloud VMs

Carry one analogy through: hiring a freelance contractor who works off-site, by the hour.

• The ticket is the work order you fax them. Crisp orders get crisp deliveries.
• The cloud VM is their rented workshop — they bring their own tools (shell, editor, browser), so your laptop is never involved.
• The ACU is the taximeter: running while they work, and you watch the meter. Vague jobs keep the meter spinning.
• The PR + report is the delivery with an itemized receipt: what they did, how they checked it.
• Devin's Wiki is the guided tour of your factory on day one — before touching anything, they are shown where every machine is and how the lines connect.
• NDEVS/multiDevin is hiring a crew: one lead splits the job into subtasks for parallel workers.
• And the golden rule of freelancers, now literal policy: you always inspect the work before it enters your house. Treat every ACU-funded session as an untrusted contributor — access granted in principle, proven in review.

What the analogy also predicts: freelancers are brilliant on well-scoped repairs and terrible at "design me a kitchen." Same failure profile as Devin.

Devin's pricing tells you how Cognition wants it used.

• Then: launched with a ~$500/month floor — priced like a full-time hire, which gated it to enthusiasts and enterprises.
• Now: pay-as-you-go, billed in Agent Compute Units (ACUs) — roughly one ACU per ~15 minutes of Devin working — with an entry Teams plan starting around $20/mo including an ACU allowance.

In plain words:

Three big implications:

1. Cost tracks task clarity. Simple, well-scoped tickets cost a fraction of an ACU budget; vague multi-hour tasks can burn dozens (section 3's two tickets).
2. The economic case is batch work. Dependency bumps, test coverage, migrations, small bug fixes with a reproduction — the mechanical backlog. Not ambiguous greenfield design.
3. Your job changes shape. Fully autonomous + remote means the human role shifts to specifying and reviewing — which is exactly where teams with weak test suites struggle: no tests means no proof of done, and the meter kept running anyway.

One corporate footnote that matters for vendor thinking (Topic 270 had the other half): after 2025, Cognition also owns Windsurf. So one company now sells both ends of the autonomy dial — Devin (cloud, autonomous) and Windsurf (IDE, interactive) — sharing repo understanding across the pair.

Devin is the async, hands-off option. You do not pair with it; you queue work for it — like a junior engineer who never sleeps but needs crisp specs and code review.

Quick map of the field (each covered in its own topic):

• Cursor / Windsurf — interactive; a human reviews diffs live in an IDE (Topics 269–270).
• Copilot coding agent — GitHub-native: issue → draft PR inside Actions (Topic 271).
• Claude Code — terminal-first, scriptable, lives in your CI (Topic 272).
• Replit Agent — builds and deploys whole new apps (Topic 274).
• Devin — a dedicated remote worker with planning, a browser, and written reporting; best for backlog chunks you can describe in a ticket and validate with tests.

A sane adoption recipe:

1. Pick 10 mechanical tickets with reproductions or failing tests.
2. Give branch protections + least-privilege tokens; keep secrets out of the VM.
3. Budget ACUs per ticket; measure the burn.
4. Review every PR like a junior's; write the spec-down the road.
5. If the pilot's win rate is high on scoped work, build a Devin queue. If not, your tests or tickets — not the agent — are the bottleneck.