Proprietary AI Tools

Cognition's Devin Bots manage teams of AI coders and shipped an Android app in 44 days — but only the $200 tier gets them

November 19, 20260 views阅读中文原文
Cognition's Devin Bots manage teams of AI coders and shipped an Android app in 44 days — but only the $200 tier gets them

TL;DR

On November 17, Cognition launched Devin Bots. In plain terms: instead of handing Devin a single task, you hand a Bot an outcome it keeps owning — "keep Android at parity with iOS" — and it splits the work, spins up a swarm of Devin sessions in parallel, keeps them moving, and comes back only when a human decision is required.

The short version: this is not a model upgrade. It changes who is responsible for pushing a project forward. Until now the engineer was the project manager — writing tickets, chasing progress, reviewing results. Cognition wants a persistent agent to take that coordination layer.

Three caveats up front:

  • Devin and Devin Bots are closed-source commercial products. Nothing here is open source.
  • The headline numbers (an Android app in 44 days, 159 pull requests in three weeks) are the vendor's own account of its own projects and a handful of early customers. No third party has reproduced them.
  • It is not in the cheap tiers. On the official pricing page, Bots appear only on Max ($200/month) and Teams ($80/month, up to 100 users). Free and the $20 Pro plan do not include them.

A note on sourcing: the product details and figures come from Cognition's own release — blog, product page, pricing page and docs. The company valuation, customer scale and competitive framing, however, are compiled from multiple media reports, chiefly Fortune's exclusive and MLQ.ai's write-up of it. This article is compiled from multiple media reports.

What it actually is: one Bot plus a fleet of sessions it runs

Three layers are worth separating.

Devin is the coding agent that does the work: give it a task and it edits code, runs tests and opens pull requests on a cloud machine. That product shipped in March 2024.

A Devin Bot is the new layer. It has its own chat, its own memory, its own connections and secrets, its own Slack app. You tell it in that chat what it owns, and it owns it: it breaks the goal into pieces, starts a Devin session for each piece — each with its own cloud machine — follows up on the sessions, and decides what to pursue next.

Needs you is the one place it interrupts you. Approvals, decisions and pull requests awaiting review collect in a single list you can clear in a click. The docs add two more details: a Bot can also run on a schedule or on events in your tools (a morning summary of open pull requests, for example), and a Bot's memory is readable by everyone who can use it — share the Bot and you share what it remembers.

One design detail matters: a normal Devin session can propose creating a Bot when the work clearly needs a long-term owner, but the Bot only exists once you approve it. Bots do not appear on their own.

Three case studies, and the numbers behind them

Cognition's launch post leans on three deployments, all in-house or customer-run, but at least the figures are specific.

One: an Android app in 44 days. Cognition had an iOS app and an iOS team, no Android engineers and no Android plan. On September 28, 2026, an engineer on the Bots team created an "Android Bot" and gave it one instruction: product-manage the Android app, build the whole thing autonomously, but first find out what will block you.

Forty-four days later the app was in open testing on Google Play. The tally: 1,134 pull requests merged, 344,651 lines of Kotlin, 2,841 screenshot tests, 1,217 tickets closed. Over those 44 days the engineer sent 183 messages — roughly one per six merged pull requests — and on 22 of the days he sent none.

Two: a Layout Bot that guards against page jank. Devin's web app loads parts of a page through separate requests; late-arriving content pushes elements around. Cognition created a Bot whose job is "keep the web app from shifting or lagging": every three hours it builds production from the latest main, runs the full stack on its own machine, and simulates first visits, repeat visits and deliberately delayed requests. When something regresses it traces the cause, opens a session, and attaches before-and-after recordings. In three weeks it merged 159 pull requests, and Cognition says lag dropped by 70%.

Three: a game studio run by one human and about 20 Bots. A colleague, Jenny Xu, runs a mobile game studio where each Bot owns one job — development, Unity, releases, UI, iOS, Android, on-device testing — with a "Super Jenny Bot" on top that collects what the others need decided into one Slack thread four times a day, answered with emoji. Weekly pull requests went from roughly 50 to 1,900, with a release every week.

Customer names are checkable too: Bilt's VP of Engineering says its Bots merged about 1,600 pull requests in a week, and early-access customers include Decagon, Fireworks AI, Reducto and OpenRouter.

Why it matters: the pitch moves from "how smart is the model" to "who owns the outcome"

The timing is what makes this interesting.

The awkward truth about coding agents in late 2026 is that one can complete every task you hand it while the project still goes nowhere. Someone still has to notice the next problem, choose an approach, and check whether the change helped. Cognition calls that layer coordination and says Bots exist to absorb it.

That is why the post contrasts two ways of writing an assignment:

  • A task: "Port this feature to Android." "Fix this layout shift."
  • A responsibility: "Keep Android at parity with iOS." "Keep the web app smooth as it changes."

With the first, you must know what to build. With the second, the Bot decides what to build next, including parts nobody was watching.

Who it is for: teams sitting on long-deferred engineering work with no spare hands; small teams or solo developers maintaining several platforms; teams already running enough Devin sessions that managing them has become its own job.

Who it is not for: anyone who just wants a snippet of code now and then. You do not need a resident project manager for a five-minute task.

How it works in practice: three steps and one change in wording

The documented path is short:

  1. In the sidebar's Bots section, click Create new Bot, pick a template or start from scratch, and name it. Templates include a QA Engineer (tests each pull request in a real browser and posts the video), an Android Engineer, a Latency Optimizer, a Product Engineer, a Software Factory, and a Chief of Staff that hands work to other Bots.
  2. Tell it in chat what it owns. The recommended phrasing gives an outcome, not a task: "You own the Android app now. Keep it at feature parity with iOS."
  3. From then on your messages are mostly check-ins ("anything waiting on me?") and answers to its questions. You can reach it in the web app, in Slack (it gets its own Slack app) or over iMessage.

A few things stay your call: which mode the Bot itself runs in, the default mode for the child sessions it starts, which repositories and tools it can reach, which changes require human review, and which low-risk edits may be approved and merged automatically.

Pricing: no separate Bot price, just a higher tier

The pricing page is blunt about it:

  • Free ($0): no Bots.
  • Pro ($20/month): no Bots.
  • Max ($200/month): Bots included.
  • Teams ($80/month, up to 100 users): Bots included, plus SSO, three usage-control tiers and centralized billing.
  • Enterprise: talk to sales.

There is no published per-Bot price. The docs say a Bot's work counts toward your plan's usage like any session, so the real cost depends on how much work it does and which models it picks — a Bot selects models per stage, using faster, cheaper ones for routine code.

The blog gives no general-availability date, only "available today", and the product and pricing pages were updated the same day, so November 17 is the launch date.

Limitations and who should wait

The numbers are self-reported. The 44 days, the 1,134 pull requests and the 70% lag reduction were all measured and published by Cognition, on its own projects and a few early customers. They show the thing can be done; they do not show it will work on your codebase.

Supervision does not disappear. The most important number in the post is that the Android Bot received 183 human messages in 44 days. That sounds cheap in human time — but many of those messages were security reviews and architecture choices, decisions with high judgement density. The Bot absorbs the typing, not the accountability.

Automatic merging is a real risk knob. Teams can configure low-risk changes, such as a button colour, to be approved and merged without review. Where that line sits is the biggest risk in the whole setup, and Cognition offers no general rule for drawing it. Its own framing is that safety rests on rules companies set and monitor, "rather than relying on models themselves being smart enough to recognize a risky or malicious prompt."

Cognition is competing with its own suppliers. As Fortune notes, OpenAI's Dots (paired with Codex) and Anthropic's Duet (paired with Claude Code) are chasing the same ground, and both companies also supply models to Cognition. Cognition's answer is not to tie a Bot to one lab, and to keep training its own cheaper engineering and code-review models.

Cost and time: a rough budget

  • Money: budget $200/month for Max, or $80 per seat per month for Teams, with Bot usage drawn from the plan allowance and extra usage purchasable. Since no marginal Bot cost is published, start with one Bot on one well-scoped goal and watch the meter for a week.
  • Setup time: creating the Bot, writing down what it owns, and configuring access and review rules takes roughly half a day to a day. The genuinely hard part is defining what success looks like — Cognition admits that remains engineering work.
  • Time to results: in the published cases the Layout Bot produced 159 pull requests over three weeks and the Android Bot shipped in 44 days. This is not a same-day tool; give it two to three weeks.

Next step

First, resist creating a Bot immediately. Look through your backlog for something repeatedly raised, repeatedly deferred and obviously valuable when done — fixing load order on a weak connection, or adding screenshot tests to an old module.

Second, rewrite that item as a responsibility rather than a list of tasks, and read it aloud. Does it state a success criterion? Is there observable evidence — tests, recordings, metrics? If not, do not hand it over yet.

Third, start with the tightest permissions: one repository, pull-request-only access, human review on everything. Run it for two weeks, count how many of its submissions you send back, and only then consider loosening automatic merging.

Fourth, do the arithmetic. Put the subscription, your review hours and the pull requests it actually landed on one page. If a Bot costs you five hours of review a week for two mergeable pull requests, it is not ready for you.

Sources

  • Devin blog: Introducing Devin Bots: from tasks to outcomes (November 17, 2026) https://devin.ai/blog/introducing-devin-bots
  • Devin product page: Devin Bots https://devin.ai/bots
  • Devin pricing (Bots on Max and Teams only) https://devin.ai/pricing
  • Devin docs: Devin Bots — memory, access, modes, usage https://docs.devin.ai/work-with-devin/bots
  • Windsurf changelog (v3.14.30819 / v3.13.4, November 17, 2026, listing "Devin Bots are now available") https://windsurf.com/changelog
  • Fortune exclusive: Cognition bets on 'Devin Bots' coding agents (November 17, 2026, 12:01 PM ET) https://fortune.com/2026/11/17/exclusive-cognition-bets-on-devin-bots-coding-agents-in-challenge-to-anthropics-duet-and-openais-dots/
  • MLQ.ai: Cognition launches Devin Bots (November 17, 2026, citing Fortune and the product page) https://mlq.ai/news/cognition-launches-devin-bots-coding-agents-that-manage-teams-of-devins-on-projects-for-days-or-weeks/

Sources

Comments

0 published
Log inorsign up to leave a comment.

Loading comments...