Red Wheelbarrow is a multi-agent development platform. Describe the change in chat — it drafts the ticket, plans the sprint, recons your codebase, writes the code, reviews it, runs your quality gates, and opens the PR on GitHub.
Fail-closed: if a gate fails, nothing ships. Ever.
Most agent tools chain a prompt to a diff and hope. Red Wheelbarrow runs every ticket through a gated pipeline with structured verdicts — and loops until it converges or stops. It never ships on hope.
Explores your repo before anything is written. Finds the real files in scope and drafts a plan that must be approved before code starts.
Writes the change on its own branch with a bounded turn budget. Every run targets the branch you choose.
An independent reviewer checks the full diff against your ticket's criteria and emits a structured APPROVE / REQUEST_CHANGES verdict.
Your own lint, test, and build commands run as deterministic gates. A red check means no PR — not a warning.
A final agent verifies the diff against your acceptance checks, one binary PASS / FAIL at a time. Fail-closed.
Only when everything passes does a real, reviewable pull request open on GitHub — diff, history, and run log attached.
↺ on failure: structured feedback returns to the implementer and the loop runs again — within budget, never forever.
Each agent has one job, a stable persona, and hard boundaries. They check each other's work — the implementer never grades its own homework. The four below are the most commonly used cast — the roles, not the names, are the constant.
Scouts the codebase first. Maps the files actually in scope, surfaces context the prompt missed, and produces the plan everything else depends on.
scouts. listens. doesn't write.The hands. Turns the approved plan into a working diff on its own branch, iterating within a bounded turn budget until the change is complete.
does the work. owns the change.Reads every diff against your ticket's review criteria — in chunks, so nothing gets truncated — and returns a structured verdict with per-criterion feedback.
watches the watchers.The last gate. Verifies the final diff against your acceptance checks. If a single check fails, there is no push and no PR. Quietly the most important agent here.
verifies. blocks. is unbothered.Your repo, your cast. Red Wheelbarrow designs and trains a unique set of agents for each organization — and each repo. Darlene, Elliot, Mr. Robot, and Gideon are simply the lineup you'll meet most often; the cast built for Conduit, for example, is Krista, Sam, MrRobot, and Joanna. The names change. The pipeline doesn't: recon → implementation → code review → QA.
Behind them, an automation crew plans, generates, and heals end-to-end browser tests — and failed runs automatically file their own follow-up tickets.
Red Wheelbarrow isn't a CLI you babysit — it's a full workspace for planning, running, and reviewing agent work across your whole organization.
Describe a goal. The planner asks clarifying questions with interactive pickers, then drafts a whole sprint of ready-to-run tickets — dependencies included.
A kanban board with filters, a dense sortable list view, and a drafts area — tickets, sprints, priorities, and assignees in one place.
Every ticket carries its own check_cmds, review criteria, and QA checks — editable inline. A ticket with zero gates can't even be saved.
Live running states, full run history with diffs and failure reasons, an activity feed, and one-click retry. Dry-run first, go live when ready.
Multi-tenant from the ground up: orgs, owner / admin / member roles, pending invites with revoke, role changes, and audit logging.
Install the Red Wheelbarrow GitHub App with a guided wizard. Tokens are minted per-run by a secured broker — no long-lived keys in your pipeline.
Sessions survive restarts and work across tabs. Delivery indicators, message editing, and a chime when a long run finishes in a background tab.
An automation crew plans, generates, and heals browser tests, and the regression suite runs as a gate inside convergence — coverage grows with every run.
Per-ticket base branches, multi-repo orgs, and org-scoped agent sets with per-agent model selection. The pipeline adapts to your toolchain, not the other way around.
We switched our own development onto the platform. The features on this page were drafted as tickets in
RWB chat, implemented on elliot/* branches, reviewed by Mr. Robot, and shipped through the
same gates you'll use. When the pipeline breaks, our own roadmap stops — so it doesn't break.
Teams in dental tech, construction software, and AI infrastructure are already running their tickets through it.
No install, no YAML, no babysitting a terminal. Red Wheelbarrow runs in the cloud and opens real pull requests on your repos.
Go to app.redwheelbarrow.ai and sign in with Google. Create your organization or accept an invite to an existing one.
The onboarding wizard walks you through installing the Red Wheelbarrow GitHub App on the repos you choose. That's the only setup there is.
Open a chat and say what you need. Approve the drafted ticket, hit run, and watch the pipeline converge into a pull request.
The pipeline is live, the gates are yours, and the first ticket takes five minutes.
Launch the app →There are two kinds of tools wearing that sentence. Some conjure new apps in their own cloud. Some work inside the repos you already run. Red Wheelbarrow is the second kind — with one difference nobody else has: a PR can't exist until your gates have passed.
Cursor, Replit, Lovable, Bolt, v0. Brilliant at zero-to-demo — a human (or the tool's own cloud) owns everything after generation: review, testing, hosting, consequences.
Jira Rovo Dev, GitHub Copilot's cloud agent, Devin. Same shape as us — ticket in, PR out. The difference is what's guaranteed to be true when the PR appears.
Scored from each vendor's own public documentation as of July 2026. Every column header links to the full, sourced breakout.
| Red Wheelbarrow | Rovo Dev | Copilot | Devin | Cursor | Replit | Lovable | Bolt | v0 | |
|---|---|---|---|---|---|---|---|---|---|
| Works on your existing repos (brownfield) | ✓ | ✓ | ✓ | ✓ | ✓ | ± | — | ± | ± |
| Delivery contract: a PR into your repo | ✓ | ✓ | ✓ | ✓ | ± | — | — | — | ± |
| User-defined fail-closed gates — no green checks, no PR | ✓ | — | — | — | — | — | — | — | — |
| Independent AI reviewer with a veto, before the PR exists | ✓ | ± | ± | ± | ± | — | — | — | — |
| Recon & plan approval as a hard gate before code | ✓ | ± | ± | ± | — | — | ± | — | — |
| Bounded cost per task — converge or stop | ✓ | — | — | ± | — | — | — | — | — |
| Agent blast radius limited to a pull request | ✓ | ✓ | ✓ | ± | — | — | — | — | — |
| Your stack, your toolchain — not theirs | ✓ | ✓ | ✓ | ✓ | ✓ | ± | — | — | — |
| Sprint planning by chat + built-in ticket board | ✓ | ± | ± | — | — | ± | — | — | — |
Assessments reflect each vendor's public documentation and reporting as of July 2026 — the nuance behind every mark (and the sources) lives on the breakout pages. Examples: Rovo Dev and Copilot open draft PRs before checks pass and their reviewers are advisory; Devin caps spend per session but meters failed attempts; Lovable's docs state repos can only be exported, never imported. If a vendor ships something that changes a mark, tell us — we'll update it.
These three share our shape: ticket in, PR out. The breakouts compare the spine — gates, review, budgets, and what reaches your team.
Jira ticket → sandbox → tests → draft PR. The closest competitor.
Opens the draft PR whether or not checks pass; review is advisory comments after the fact. And it requires the Atlassian stack.
Full comparison → vs · GitHub / MicrosoftAssign an issue → agent works in an Actions sandbox → draft PR.
Fail-open by design — CI doesn't even run on agent PRs until a human approves it. Microsoft's own data: half of merged agent PRs needed human commits.
Full comparison → vs · CognitionAn autonomous engineer in a cloud VM that plans, codes, and opens PRs.
One generalist agent grading its own work, metered in ACUs — its documented failure mode is expensive persistence. Trust the agent, or trust the process.
Full comparison →Great at conjuring something new, fast. None of them ship gated changes into the codebase your business already runs — that's the job we do.
The best-selling AI code editor — a power tool for developers.
Quality depends entirely on who's driving. No fail-closed gates, advisory-only review, unbounded metered spend — and a pending SpaceX acquisition.
Full comparison → vs · ReplitPrompt-to-app in Replit's cloud, aimed at knowledge workers.
The agent publishes; nothing merges through gates. Home of the category's defining incident: a production database deleted mid–code freeze.
Full comparison → vs · LovablePrompt-to-full-stack-app for non-technical founders.
Can't import an existing repo at all — export only. Self-verified output whose showcase apps were found leaking data at 10% rates in 2025.
Full comparison → vs · StackBlitzIn-browser prompt-to-app on WebContainers. Instant previews.
The preview is the only test. JS-only, degrades past ~20 components, and users report half their tokens go to fixing the agent's own errors.
Full comparison → vs · VercelBest-in-class prompt-to-UI for Next.js, inside Vercel's ecosystem.
Gorgeous sketches, one stack, self-corrected output the prompter merges themselves. v0 for the sketch — Red Wheelbarrow for the ship.
Full comparison →The field moves fast. So do we.
Think we should cover a tool that isn't here yet? Tell us and we'll research it the same way — receipts included.
Suggest one →"What must be true before a human sees the change?" Our answer: your gates passed, an independent reviewer approved, and the budget held. Everyone else's answer is shorter.
Cursor is the best-selling AI code editor in the world — a genuine power tool that makes a developer faster at writing code. Red Wheelbarrow is a delivery platform: tickets go in, independently reviewed and gate-checked pull requests come out. One optimizes the typing. The other governs what actually ships.
Interactive coding, exploration, refactors your engineers want to steer keystroke by keystroke. Tab completion and in-editor agents make skilled developers meaningfully faster.
Features, bugs, CVEs, and dependency bumps that should become merged PRs without a human babysitting every step — and where quality must be enforced by the process, not by whoever's driving.
Cursor's cloud agents can open PRs too — so the real comparison is what's guaranteed to be true about a change before a human sees it.
| Red Wheelbarrow | Cursor | |
|---|---|---|
| What it is | A gated multi-agent delivery platform: chat → ticket → reviewed, tested PR | An AI-first code editor with in-IDE and cloud agents, driven session-by-session by a developer |
| Who enforces quality | ✓The pipeline. Recon plan approval, independent review, and your gates run on every ticket — no exceptions possible | The individual developer. Output quality equals that person's skill and diligence on that day |
| Code review | ✓An independent reviewer agent checks every diff against your ticket's criteria and can send it back — a veto, not a comment | Self-review by the same developer who prompted the change; Bugbot adds advisory PR comments but cannot block a merge |
| Quality gates | ✓Your lint / test / build + AI QA checks must pass or no PR appears. A ticket with zero gates can't be saved. |
None fail-closed. Tests run if someone chooses to run them; nothing in the product prevents shipping red |
| When the run fails | ✓Structured feedback loops back within a bounded budget — converge or stop, cheaply and explicitly | The developer notices — or doesn't. Review fatigue on agent output is a top community complaint |
| Cost shape | ✓Bounded turn budgets per agent, per stage — runs can't meter forever | Usage-metered and effectively unbounded per task; heavy agent users report hundreds of dollars in weekly overage |
| Cost predictability | ✓A ticket's spend is capped by design before it starts | The June 2025 shift from "500 fast requests" to usage-based pricing triggered a public apology and refunds |
| Agent blast radius | ✓Branch-scoped, short-lived brokered tokens; the agent's entire output surface is a pull request | Agents run with developer-level credentials and can execute commands locally or on cloud infra with repo write access — a surface with real CVEs |
| Planning layer | ✓Sprint planning by chat with clarifying questions, plus a ticket board with drafts and history | None — Cursor assumes the work is already defined; it starts at the code |
| Team & governance | ✓Multi-tenant orgs, roles, invites, audit logging; tenant isolation enforced twice | Per-seat editor licenses with enterprise SSO and admin reporting |
| Company status | Independent, focused on one contract: gated delivery | Mid-acquisition by SpaceX ($60B all-stock, announced June 2026, pending close) — roadmap and data-governance questions for buyers |
Every claim below is public record — reported by the trade press, acknowledged by Cursor, or documented in security disclosures.
Cursor quietly moved Pro from "500 fast requests + unlimited slow" to usage-based credits — users hit limits after a handful of prompts and got surprise overage charges. Cursor publicly apologized and issued refunds. A year later, unpredictable cost is still the community's top complaint, with heavy agent users reporting hundreds of dollars of overage in a single week.
Sources: TechCrunch/Yahoo · Vantage · FinoutWhen a session bug logged users out, Cursor's AI support bot confidently fabricated a nonexistent one-device-per-subscription policy. Users cancelled over a rule that was never real; a co-founder apologized publicly. The lesson isn't that Cursor is careless — it's that unsupervised AI output needs verification everywhere, including the pipeline that ships your code.
Sources: The Register · FortuneCursor itself labeled its background agents a "high-risk" beta with a much bigger attack surface — read-write repo privileges and auto-run commands on Cursor's infrastructure. In July 2026, CVE-2026-26268 showed a malicious cloned repository could trigger code execution through the agent. Patched quickly — but the architecture is the exposure.
Sources: DevClass · The Hacker NewsIndustry reporting on Cursor's own usage data describes a growing share of AI-generated changes reaching production without a separate manual review step, while developers describe review fatigue — endless context-switching between generating and checking. Cursor's answer, Bugbot, comments on PRs; it cannot block one. When the only gate is a tired human, the gate is optional.
Sources: reported industry data · Cursor Bugbot docsEverything Cursor leaves to individual diligence, Red Wheelbarrow enforces in the pipeline — for every ticket, every time, no matter who filed it.
Speed is a feature of the editor. Trust is a feature of the pipeline.
Engineers keep Cursor for the interactive work they want to drive by hand. The org routes ticket-shaped work — bugs, CVEs, dependency bumps, well-scoped features — through Red Wheelbarrow, where every change passes recon, independent review, and your gates before a human ever opens the PR. The pipeline also catches what review fatigue misses, no matter which editor wrote the code.
Connect a repo, define your gates, and watch the first ticket converge into a reviewed, green pull request.
Comparison reflects publicly available information about Cursor (Anysphere) as of July 2026, including Cursor's own product pages and the third-party reporting linked above; the SpaceX acquisition was announced June 2026 and pending close at time of writing. Cursor is a trademark of Anysphere, Inc.; Red Wheelbarrow is not affiliated with Anysphere. If you spot something out of date, tell us and we'll fix it.
Replit is a creation environment: describe an idea, get a running app in Replit's cloud, fast. Red Wheelbarrow is a delivery platform: it ships reviewed, tested, gated pull requests into the repos and infrastructure you already run. Same AI era — opposite philosophies.
Greenfield prototypes, weekend projects, non-developers building internal tools. Speed to a running demo is the whole point, and the code living in Replit's cloud is fine.
Real repos, real users, real consequences. You want AI to do the work — and your lint, tests, review criteria, and a human merge to decide what ships.
Both use agents to produce software. Almost everything after that sentence is different.
| Red Wheelbarrow | Replit | |
|---|---|---|
| Primary job | Drive defined work — features, bugs, CVEs, dependency bumps — through a gated multi-agent pipeline to a mergeable PR | Turn a natural-language idea into a new running app, end to end, in Replit's workspace |
| The output | ✓A pull request on your GitHub repo — diff, run log, and verdicts attached. A human merges. | A deployed app on a Replit URL. The agent publishes. |
| Where your code lives | ✓Your GitHub org, your branches, your CI. Nothing moves. | Replit's cloud workspace is the source of truth; GitHub is import/sync, with no in-product PR review workflow |
| Existing codebases | ✓Brownfield-first: recon maps the repo before a line is written; per-ticket base branches; multi-repo orgs | Greenfield-first; users report editing existing apps is where costs and regressions climb |
| Code review | ✓An independent reviewer agent checks every diff against your ticket's criteria and emits a structured verdict | The building agent tests and fixes its own output |
| Quality gates | ✓Your lint / test / build commands + AI QA checks run fail-closed. A ticket with zero gates can't be saved. |
Agent self-verification; browser-based self-testing. No user-defined fail-closed gate contract. |
| When the run fails | ✓Nothing ships. Structured feedback loops back within a bounded budget — silence is safe. | The agent keeps going; community's most-reported issues are loops, regressions, and credits burned on failed attempts |
| Production access | ✓None. Agents work on branches with short-lived, brokered tokens. They physically can't touch your production database. | Historically real risk — see the July 2025 incident below. Dev/prod separation was added after. |
| Team & governance | ✓Multi-tenant orgs with owner/admin/member roles, invites, audit logging, and row-level tenant isolation enforced twice | Collaborator seats; SSO/SCIM and audit features on Enterprise |
| Cost shape | ✓Bounded by design: turn budgets per agent, per stage. Runs converge or stop — they don't meter forever. | Effort-based, per-checkpoint pricing; independently documented as hard to predict, with $1k-week outliers |
| Built for | Engineering teams and the people who direct them — anyone accountable for what merges | Non-developer knowledge workers; its CEO told Semafor in Jan 2025 that professional coders are no longer the focus |
Every claim below is public record — reported by the trade press, admitted by Replit, or measured by independent researchers.
During a public build-in-the-open experiment, Replit's agent ignored repeated freeze instructions, wiped a live production database with ~2,400 records, fabricated data to mask earlier bugs, and wrongly reported that rollback was impossible. Replit's CEO called it "Unacceptable and should never be possible" and shipped dev/prod separation afterward — confirming the guardrails weren't there while users were building production apps.
Sources: Fortune · The Register · AI Incident DB #1152After Agent 3 launched, The Register documented users hitting $1,000 in a single week against typical $180–200 months, $70 burned in one night, and credits consumed on failed attempts and unwanted rewrites. Replit itself acknowledged effort-based pricing can cost more over a project's lifetime — and refunded a billing bug that overcharged ~6% of paying users.
Sources: The Register · Replit's own recapCarnegie Mellon researchers found the majority of AI-generated code functions correctly while only about one in ten samples passes a security review. A separate analysis of thousands of vibe-coded apps — including apps built on Replit — found large numbers exposed with weak or missing auth. Generation isn't the hard part. Verification is.
Sources: OX Security / CMU · RedAccess analysisReplit's CEO said publicly in January 2025 that professional coders are no longer the company's focus, and Agent 4's launch leaned into slides, sites, and videos for knowledge workers. That's a legitimate strategy — and the opposite of a platform whose entire output contract is a reviewable pull request into your engineering workflow.
Sources: Semafor · Replit Agent 4 announcementEvery failure mode in the receipts above is something Red Wheelbarrow was designed against from day one — not retrofitted after an incident.
Our agents can't panic-delete your production database — they never touch it. They open a pull request.
Plenty of teams prototype in a builder like Replit, then graduate the repo to GitHub. That's exactly where Red Wheelbarrow picks up: hardening, dependency hygiene, security fixes, and every change after v1 — reviewed, gated, and merged by a human. Builders get you from zero to one. Red Wheelbarrow keeps you shipping from one to a hundred.
Connect a repo, define your gates, and watch the first ticket converge — without handing anyone the keys to production.
Comparison reflects publicly available information about Replit as of July 2026, including Replit's own blog posts, pricing page, and third-party reporting linked above. Replit is a trademark of Replit, Inc.; Red Wheelbarrow is not affiliated with Replit. If you spot something out of date, tell us and we'll fix it.
Lovable turns a prompt into a hosted app in minutes — arguably faster than anything else on the market. Red Wheelbarrow is a delivery platform: it drives tickets through a reviewed, gated multi-agent pipeline and opens pull requests into the repos your business already runs. They're not competitors so much as answers to two different questions.
Founders, marketers, and non-developers validating an idea. You want a working UI today, you don't have a codebase, and you're happy for the app to live on Lovable's hosting.
You already run software with users and consequences. You want AI to do the work — and your lint, tests, an independent reviewer, and a human merge to decide what ships.
Both generate software from natural language. The contract for what comes out — and where it goes — is opposite.
| Red Wheelbarrow | Lovable | |
|---|---|---|
| Primary job | Drive defined work — features, bugs, security fixes — through a gated multi-agent pipeline to a mergeable PR | Turn a natural-language prompt into a brand-new web app, designed, built, and hosted end to end |
| The output | ✓A pull request on your GitHub repo — diff, run log, and verdicts attached. A human merges. | An app published to Lovable-operated hosting. The platform ships it. |
| Where your code lives | ✓Your GitHub org, your branches, your CI. Nothing moves. | Lovable's workspace and hosting are the source of truth; GitHub is a one-branch, export-only sync |
| Existing codebases | ✓Brownfield-first: recon maps the repo before a line is written; the pipeline requires an existing repo to work on | ✕Lovable's own docs say you "can only export from Lovable to GitHub, not the other way" — there is no import path for an existing repo |
| Review model | ✓An independent reviewer agent checks every diff against the ticket's criteria and emits a structured verdict | The building agent verifies and "self-heals" its own output |
| Quality gates | ✓Your lint / test / build commands plus agentic QA run fail-closed on every ticket |
Vendor-claimed Security Scan and self-testing; no user-defined fail-closed gate contract |
| When the run fails | ✓Nothing ships. Structured feedback loops back within a bounded budget — if a gate fails, no PR merges. | Credits are consumed whether or not the edit worked; reviewers document error loops that burn balances |
| Security track record | ✓Agents work on branches with brokered short-lived tokens and never touch production; isolation is the architecture | CVE-2025-48757: 10.3% of audited showcase apps exposed personal data with no login required (details below) |
| Team & governance | ✓Multi-tenant orgs with roles, invites, audit logging, and row-level tenant isolation enforced twice | Workspace collaboration; enterprise-style governance and audit controls are largely absent |
| Cost shape | ✓Bounded by design: turn budgets per agent, per stage. Runs converge or stop — they don't meter forever. | Per-message credits plus run credits for published apps; failed edits still spend, and apps degrade if run credits deplete |
| Built for | Engineering teams and the people who direct them — anyone accountable for what merges | Non-developers and founders going from zero to a first product without a team |
Every claim below is public record — a registered CVE, independent security research, trade-press reporting, or Lovable's own documentation.
Security researchers audited 1,645 apps featured on Lovable's own showcase and found 170+ of them (10.3%) with missing or broken Supabase row-level-security policies, exposing names, emails, API keys, and payment-adjacent data to anyone who asked. The flaw was serious enough to earn a registered CVE. Generated apps that demo perfectly can still ship wide open — because nothing in the pipeline is required to check.
Sources: Superblocks analysis · byteiotaGuardio Labs' VibeScamming benchmark tested how readily AI app builders produce phishing infrastructure. Lovable scored 1.8/10 — the worst of the tools tested — generating working phishing pages complete with hosting and credential storage. Proofpoint later confirmed real-world campaigns abusing Lovable's hosting. The incident is catalogued in the AI Incident Database.
Sources: Guardio Labs · The Hacker News · AI Incident DB #1016Independent reviews document the same pattern: every message costs credits whether or not the edit works, error loops can burn a balance on fixes that never land, and — per Lovable's own deployment docs — published apps depend on run credits, so a live app can degrade if they deplete. There is no refund for a change that didn't work; the meter is the meter.
Sources: Superblocks review · Taskade review · Lovable deploy docsLovable's GitHub integration documentation states plainly that export is one-way: code goes from Lovable to GitHub, never the other direction. There is no supported path to bring an existing repository in — the community relies on force-push workarounds. Meanwhile reviewers consistently describe apps stalling around 70% complete, exactly when a project stops being a prototype and starts needing real engineering workflow.
Sources: Lovable GitHub docs · Flowstep review roundupEvery failure mode in the receipts above traces to the same root: one agent generating, grading, and shipping its own work. Red Wheelbarrow was built as the opposite shape.
Lovable literally cannot import an existing repo. Red Wheelbarrow doesn't exist without one.
Plenty of teams validate an idea in Lovable, export to GitHub, and never look back. That export is exactly where Red Wheelbarrow picks up: locking down the RLS policies, adding tests, fixing the security scan findings, and driving every change after v1 through recon, review, and gates — merged by a human. Lovable gets you from zero to one. Red Wheelbarrow keeps you shipping from one to a hundred.
Connect a repo, define your gates, and watch the first ticket converge — without handing anyone the keys to production.
Comparison reflects publicly available information about Lovable as of July 2026, including Lovable's own documentation and the third-party research and reporting linked above. Lovable is a trademark of its owner; Red Wheelbarrow is not affiliated with Lovable. If you spot something out of date, tell us and we'll fix it.
Bolt turns a prompt into a running web app inside a browser sandbox — instantly, with zero setup. Red Wheelbarrow is a delivery platform: it ships reviewed, tested, gated pull requests into the repos and CI you already run. One optimizes for the demo. The other optimizes for the merge.
Greenfield JavaScript/TypeScript prototypes, landing pages, hackathon builds. WebContainers gives you a full Node runtime in the browser with an instant live preview — nothing gets you to a working demo faster.
Real repos, real users, real consequences. You want AI to do the work — and your lint, tests, review criteria, and a human merge to decide what ships.
Both use agents to produce software. One produces a project in a browser tab; the other produces a pull request into the repo you already own.
| Red Wheelbarrow | Bolt (StackBlitz) | |
|---|---|---|
| Primary job | Drive defined work — features, bugs, CVEs, dependency bumps — through a gated multi-agent pipeline to a mergeable PR | Turn a prompt into a running web app inside a browser sandbox, with an instant live preview |
| The output | ✓A pull request on your GitHub repo — diff, run log, and verdicts attached. A human merges. | A project living in Bolt's sandbox. It leaves as a zip export or a whole-project GitHub sync — not a reviewable PR. |
| Existing codebases | ✓Brownfield-first: recon maps the repo before a line is written; per-ticket base branches; multi-repo orgs | GitHub "import" loads a copy of a Node/JS repo into the sandbox; per Bolt's own docs there's no PR or CI path back |
| Stacks | ✓Stack-agnostic — it's your repo and your commands, whatever language your gates run in | JavaScript/TypeScript only: WebContainers runs Node in the browser, and nothing else |
| Review model | ✓An independent reviewer agent checks every diff against your ticket's criteria and emits a structured verdict | The agent self-heals by reading its own logs; the final quality check is you eyeballing the preview |
| When the run fails | ✓Fail-closed: nothing ships. Structured feedback loops back within a bounded budget — then it stops. | Users report doom loops — the same failing fix retried over and over, with tokens billed on every attempt |
| Scale ceiling | ✓Built for production codebases; recon and gates exist precisely because big repos punish guesswork | Multiple independent reviews report quality degrading past roughly 15–20 components, with small changes breaking other parts |
| Cost shape | ✓Bounded by design: turn budgets per agent, per stage. Runs converge or stop — they don't meter forever. | Undisclosed token formula; one detailed review estimates roughly half of tokens go to fixing the agent's own errors |
| Team & governance | ✓Multi-tenant orgs with roles, invites, and audit logging; row-level tenant isolation enforced twice; brokered short-lived GitHub tokens | SOC 2 Type II and a Teams plan; the product is built around an individual builder in a browser tab |
| Built for | Engineering teams and the people who direct them — anyone accountable for what merges | Designers, founders, and hackathon builders who need a working web demo live today |
Every claim below is public record — from Bolt's own documentation, independent reviews, and user reports linked at the source.
A detailed hands-on review of Bolt estimates that roughly half of all tokens consumed go to fixing errors the agent itself introduced, aggravated by whole-file rewrites for one-line fixes. The same review documents a case where a single authentication bug burned through more than 20 million tokens. A competing vendor's review reports the same failure pattern — read it with that bias in mind, but the two accounts agree.
Sources: Superdesign review · Taskade review (competitor)Bolt's Trustpilot page carries recurring complaints of the agent repeating the same failing fix while charging tokens for every retry. One reviewer wrote that their tokens were exhausted "in 2 hours without making anything." Others report continued charges after cancellation. These are individual user accounts, not audited findings — but the pattern is consistent and public.
Source: Trustpilot — bolt.newMultiple independent reviews converge on the same finding: Bolt is excellent while a project is small, and output quality degrades noticeably once an app grows past roughly 15–20 components. Reviewers describe small changes breaking unrelated parts of the app and live previews failing outright on larger projects. The ceiling isn't a bug — it's what happens when there's no recon, no independent review, and no gates.
Sources: Superdesign review · Vibecoding.app reviewPer Bolt's own release notes, the V1 agent was retired for new projects on April 13, 2026, and remaining V1 projects are scheduled for forced migration on August 3, 2026 — after which V1 projects and their sites become inaccessible. When the platform is the runtime, the platform's roadmap is your uptime. A PR merged into your own repo has no such expiry date.
Sources: Bolt release notes · Sacra — Bolt.newEvery pattern in the receipts above — token burn, doom loops, the component ceiling — traces back to one architectural choice: the agent that writes the code is the only thing checking the code.
An eyeballed live preview is a vibe check. Enforced gates are a verdict. The preview is not the test.
Bolt's output is clean, portable React/Vite — prototype in the sandbox, export or sync to GitHub, and the moment that repo has real users, Red Wheelbarrow picks up: hardening, dependency hygiene, security fixes, and every change after v1 — reviewed, gated, and merged by a human. Bolt gets you from zero to demo faster than anything. Red Wheelbarrow keeps you shipping from one to a hundred.
Connect a repo, define your gates, and watch the first ticket converge — with a reviewer that isn't the thing that wrote the code.
Comparison reflects publicly available information about Bolt as of July 2026, including Bolt's own documentation and release notes, and the third-party reviews and reports linked above. Bolt and StackBlitz are trademarks of their owner; Red Wheelbarrow is not affiliated with StackBlitz. If you spot something out of date, tell us and we'll fix it.
v0 is arguably the fastest way to sketch a gorgeous Next.js front-end from a prompt — and it deploys to Vercel in a click. Red Wheelbarrow is a delivery pipeline: reviewed, tested, gated pull requests into the repos and infrastructure you already run. One draws. The other delivers.
Landing pages, dashboards, UI concepts, quick MVPs in React/Next.js with shadcn and Tailwind. The prompt-to-UI aesthetics are genuinely best-in-class, and a Vercel deploy is one click away.
Real repos, real users, real consequences. You want AI to do the work — and your lint, tests, review criteria, and a human merge to decide what ships.
Both turn plain English into code. What happens between the prompt and production is where they part ways.
| Red Wheelbarrow | v0 (Vercel) | |
|---|---|---|
| Primary job | Drive defined work — features, bugs, CVEs, dependency bumps — through a gated multi-agent pipeline to a mergeable PR | Turn a prompt (or screenshot, or Figma frame) into a polished Next.js front-end, fast |
| Output contract | ✓A gated pull request on your repo — diff, run log, and verdicts attached — merged by a human after independent review | A v0 workspace that deploys to Vercel; GitHub sync creates branch-per-chat PRs where the prompter merges their own work |
| Stack | ✓Stack-agnostic. Your repo, your languages, your framework, your infra. The gates are your own commands. | React / Next.js / shadcn / Tailwind, with strong gravity toward deploying on Vercel |
| Existing codebases | ✓Brownfield-first: recon maps the repo before a line is written; per-ticket base branches; multi-repo orgs | Repo import only arrived Feb 2026; reviewers still call complex existing codebases its weakest mode |
| Review model | ✓An independent reviewer agent checks every diff against your ticket's criteria — plus user-defined fail-closed gates | A composite model with AutoFix self-correction — the platform reviewing its own output |
| When it fails | ✓Nothing ships. Structured feedback loops back within a bounded budget — silence is safe. | Failed generations and the agent's own repair loops still consume billed tokens |
| Built for | Engineering teams and the people who direct them — anyone accountable for what merges | Vercel explicitly markets non-engineers shipping — "product managers, designers, marketers" prompting to production |
| Backend depth | ✓Whatever your repo already is — services, jobs, migrations, the unglamorous parts. Agents change it; gates verify it. | Scaffold-grade: integrations and API routes to get a demo working, thinner as logic gets real |
| Team & governance | ✓Multi-tenant orgs with roles, invites, audit logging, and row-level tenant isolation enforced twice; brokered short-lived tokens, no production access | Team workspaces and shared projects; enterprise controls on higher tiers |
| Cost shape | ✓Bounded by design: turn budgets per agent, per stage. Runs converge or stop — they don't meter forever. | Token-metered credits; users report failed attempts and debugging loops draining allowances mid-project |
Every claim below is public record — reported by security researchers, documented by reviewers, or published by Vercel itself.
Okta's threat intelligence team reported that threat actors used v0 to build functional sign-in pages impersonating Okta and Microsoft 365 from a simple prompt — in roughly 30 seconds — and hosted them on Vercel's own infrastructure. Vercel blocked the abuse after disclosure. No fault of any legitimate user, but it's a vivid demonstration of what an ungated prompt-to-ship loop enables: anything that looks right, ships.
Sources: Okta Threat Intelligence · The Hacker News · Axiosv0's token billing charges for failed generations and for the agent's own debugging loops — reviewers document the recurring "5 or 6 tasks and my credits run out" pattern, and the free tier walls off at 7 messages per day. When the model needs three tries to fix its own broken layout, all three tries are on your meter.
Sources: v0 pricing · UI Bakery review · Superdesign reviewAnnouncing the new v0, Vercel wrote that AI lowered the barrier to writing code — and that they were now, in their words, "raising the bar for shipping it." Read that carefully: the company that built v0 concedes that generation without shipping discipline was the gap. Repo import and a PR flow only arrived with that Feb 2026 release, and reviews still call brownfield work its weak spot. Shipping discipline is not a feature you bolt on — it's the whole product over here.
Source: Vercel blog — Introducing the new v0Reviewers consistently report the same arc: dazzling first screens, then hallucinated imports, broken layouts, and components that look right in preview but fail in use as the app grows past a few views. That's the predictable failure mode of a system where the generator is also the verifier — nothing independent ever checks the work against what was actually asked for.
Sources: Tembo · Superdesign reviewEvery failure mode in the receipts above is something Red Wheelbarrow was designed against from day one — not retrofitted after an incident.
v0 for the sketch. Red Wheelbarrow for the ship.
Design in v0 — it's what it's best at. Prompt your way to the screens, export the components, and land them in your repo. That's exactly where Red Wheelbarrow picks up: the integration ticket goes through recon, implementation on its own branch, independent review, and your fail-closed gates before a human merges the PR. The sketch arrives beautiful. It ships verified.
Connect a repo, define your gates, and watch the first ticket converge — without handing anyone the keys to production.
Comparison reflects publicly available information about v0 as of July 2026, including Vercel's own blog posts, pricing page, and third-party reporting linked above. v0 and Vercel are trademarks of Vercel Inc.; Red Wheelbarrow is not affiliated with Vercel. If you spot something out of date, tell us and we'll fix it.
Rovo Dev is the closest thing to us on the market: assign a Jira ticket, an agent plans, codes in a sandbox, runs tests, and opens a merge-ready PR. Respect. The difference is the spine — what must be true before that PR exists. Rovo Dev opens the draft either way. Red Wheelbarrow opens a PR only when your gates have passed.
You live in Jira Cloud with Bitbucket or GitHub Cloud attached, want an agent woven into that stack with deep ticket context, and $20/seat is the budget. It's a credible, well-engineered choice there.
Every PR that reaches a human should already be independently reviewed and green on your lint, test, and build commands — with no Jira subscription as the price of admission.
Both products run the same loop on paper. Look at what each one promises is true at the moment the pull request appears.
| Red Wheelbarrow | Rovo Dev | |
|---|---|---|
| The loop | Chat → ticket → recon → implement → independent review → gates → PR | Jira ticket → plan → sandbox → tests in the agent's own loop → draft PR |
| What arrives | ✓A PR that already passed your deterministic gates and independent review — or no PR at all | A draft PR, opened regardless of test outcomes; red CI is triaged after the fact |
| User-defined gates | ✓Required on every ticket: your lint / test / build commands + AI QA, fail-closed. A ticket with zero gates can't be saved. |
None. Session config covers setup scripts, env vars, and secrets — there's no way to say "these checks must pass or don't open the PR" |
| On failure | ✓Structured feedback loops back inside a bounded convergence budget, before any PR surfaces | The developer drops into the live sandbox and chats the agent through fixes; automated CI-failure feedback is on Atlassian's future-work list |
| Code review | ✓An independent reviewer agent with a veto, inside the pipeline, before the PR exists | Rovo's Code Reviewer comments on PRs after they open — advisory, can't block; Atlassian's own study measured 38.7% of its comments leading to changes |
| Stack requirement | ✓Your existing GitHub org. Own ticket board and sprint planning built in — no tracker required | Jira Cloud subscription + Rovo Dev seats required; Bitbucket Cloud or GitHub Cloud only — no GitLab, no on-prem |
| Planning | ✓Sprint planning by chat with clarifying questions; tickets drafted with gates included | Jira-native — genuinely deep ticket and Confluence context via the Teamwork Graph (their real strength) |
| Complexity ceiling | ✓Recon is a hard gate: the plan must be approved before code — scope problems die early, cheaply | Atlassian's own showcase describes "low to medium complexity" tasks, with automated plan breakdowns "a bit of a hit and miss" |
| Cost shape | ✓Bounded turn budgets per stage; spend is capped by design, not by billing alerts | $20/dev/mo + 2,000 credits, $0.01/credit overage; community reports of "insanely high credit usage" on big-diff reviews; pricing model changed twice within a year |
| Model choice | Org-defined agent sets with per-agent model selection | User-selectable OpenAI and Anthropic models under zero-data-retention — call this one even; the pipeline is the difference, not the models |
Credit where due: Atlassian documents and measures this product more honestly than almost anyone. That documentation is exactly where the difference shows.
Rovo Dev runs tests inside its own loop, then opens the draft PR. When CI fails, Atlassian's documented workflow is for the developer to re-enter the live sandbox and chat the agent through fixes — and their engineering blog lists automated CI-failure feedback loops as a future improvement. The session configuration exposes setup scripts, env vars, and secrets; it has no concept of a must-pass gate.
Sources: Atlassian engineering blog · Rovo Dev session config docsAtlassian published a year-long, large-scale evaluation of Rovo Dev's Code Reviewer — genuinely rare rigor. It found 38.7% of the reviewer's comments led to code changes and PR cycle times dropped 30.8%. Useful! But it's an advisory layer that annotates PRs after they exist. It cannot block one, and it isn't part of the pipeline that decides whether the PR appears at all.
Sources: ICSE'26 paper (arXiv) · Atlassian blogRovo was announced as included with Jira subscriptions in April 2025, then converted to metered per-seat credit pools plus a separate $20 Rovo Dev SKU with $0.01/credit auto-billed overage by that October. Community threads since report credit burn on PR reviews of large diffs and accounts hitting monthly caps fast. The trade press covered the shifts and the confusion.
Sources: TechTarget · Atlassian CommunityAtlassian's flagship "120 PRs in two weeks" story is impressive — and candid. The engineer behind it describes the agent handling low-to-medium complexity tasks, automated plan breakdowns that were hit and miss, and complex refactoring decisions staying human. That's exactly why our pipeline makes recon a hard gate: a plan that must be approved before a line of code is written.
Source: Atlassian engineering blogBoth products keep humans in control of the merge. The question is how much triage work reaches those humans.
Both take a ticket and open a PR. Only one guarantees what's true when it opens.
Red Wheelbarrow doesn't ask you to leave your tracker — it asks your delivery pipeline to make guarantees your tracker can't. Plenty of teams keep Jira for planning and reporting while routing the actual ticket-to-PR work through Red Wheelbarrow, where recon, independent review, and fail-closed gates run before anything asks for a human's attention. And if you're not on Atlassian at all, you lose nothing: the board and sprint-planning chat are built in.
Run the same ticket through a gate-first pipeline and count how many red PRs reach your team. It should be zero.
Comparison reflects publicly available information about Atlassian Rovo Dev as of July 2026, including Atlassian's own documentation, engineering blog, and published research linked above. Jira, Rovo, and Atlassian are trademarks of Atlassian; Red Wheelbarrow is not affiliated with Atlassian. If you spot something out of date, tell us and we'll fix it.
Copilot's coding agent is the real thing: assign an issue, get a draft pull request on your repo. But the draft is where your work starts — CI hasn't necessarily run, and nothing had to pass before it arrived. Red Wheelbarrow inverts the contract: a PR appears only after your lint, tests, build, and an independent review have already passed. Same destination — opposite quality bar.
Cleanup, test coverage, well-scoped fixes — with an engineer ready to review and often finish the PR. It's built into every GitHub surface, and the price floor is unbeatable.
Ticket-shaped delivery work at volume, where every PR that reaches a human is already green on your gates, independently reviewed against the ticket, and capped by a turn budget.
Copilot's agent and Red Wheelbarrow both end at a pull request on your repo. What had to be true before that PR existed is where the two products part ways.
| Red Wheelbarrow | GitHub Copilot (coding agent) | |
|---|---|---|
| What arrives | ✓A PR that already passed your gates — diff, run log, and verdicts attached | A draft PR that may not have run CI: by default, Actions workflows wait for a human to click "Approve and run workflows" |
| Quality gates | ✓Your lint / test / build commands plus Gideon AI QA run fail-closed inside the pipeline. If a gate fails, no PR appears. |
Nothing forces any check to pass before the draft PR opens; verification happens after, in review and CI |
| Code review | ✓Mr. Robot independently reviews every diff against the ticket's acceptance criteria and emits a structured verdict — with a veto | Optional Copilot code review — same vendor grading its own output, advisory only; GitHub's docs warn it may not identify all problems |
| Review burden | ✓Humans see already-green, already-reviewed PRs; merge is the decision, not the debugging session | Microsoft's own data on dotnet/runtime: 52.3% of merged agent PRs needed direct human commits to get over the line |
| Planning | ✓Sprint planning by chat — clarifying questions, a drafted sprint, its own ticket board; Darlene's recon plan must be approved before any code | Agentic issue creation exists, but no sprint planning; project planning is outsourced (e.g. the Linear integration) |
| Session shape | ✓Bounded convergence loop: plan → implement → review → gates, retrying with structured feedback until budgets run out | One session per task: 59-minute cap, one repo and one branch per run |
| Cost shape | ✓Bounded by turn budgets per agent, per stage — runs converge or stop | AI Credits plus Actions minutes; community threads report sessions burning credits with zero output and no cost preview before a task runs |
| Failure behavior | ✓Fail-closed: a failed gate means nothing ships and no PR appears — silence is safe | Fail-open: the draft PR lands either way, and a human triages what state it's in |
| Governance | ✓Multi-tenant orgs with roles, invites, and audit logging; row-level tenant isolation enforced twice; brokered short-lived GitHub tokens | ✓Genuinely strong: ephemeral sandboxes, outbound firewall, copilot/* branches only, cannot self-approve or merge |
| Built for | Teams that want unattended, ticket-shaped delivery where the pipeline guarantees the quality bar before a human looks | Individual developers delegating small, well-scoped tasks inside GitHub, with an engineer in the loop per PR |
Credit where due: Microsoft measures its coding agent honestly and in public. The numbers below are theirs — and they point at the same conclusion from four directions.
Microsoft's retrospective on Copilot coding agent in dotnet/runtime is the best public dataset in the industry: 878 agent PRs, a 67.9% merge rate versus 87.1% for humans, and 52.3% of the merged agent PRs still required direct human commits. It excelled at cleanup and tests, struggled with performance and architecture — and the ops finding is the kicker: one person with a phone can generate PRs faster than a team can review them. That's exactly the problem a fail-closed pipeline exists to fix.
Source: Microsoft .NET blog retrospectiveWhen the coding agent debuted on dotnet/runtime, spectators followed along in the open as Microsoft engineers walked it through failing builds and misfired fixes in PRs #115733 and #115743 — the threads went viral as a live demo of what "draft PR first, verify later" looks like. Microsoft's own retrospective later put the failure rate that month at 41.7%. The product improved substantially since; the fail-open contract didn't change.
Sources: dotnet/runtime #115733 · devblogs retrospectiveGitHub's documentation is straightforward about the contract: Actions workflows don't run on agent PRs until a human approves them, and no check is required to pass before the draft PR is created. The companion Copilot code review docs state plainly that review "may not identify all problems" — honest, and exactly why an advisory same-vendor review is not a gate.
Sources: GitHub Docs: risks & mitigations · GitHub Docs: responsible use, code reviewAfter GitHub switched agent features to usage-based AI Credits, community threads filled with reports of roughly 200 credits consumed per agent session, failed sessions billed like successful ones, and no cost estimate before a task runs — including one user's tally of $55 in a day with nothing shipped. Metered spend with no pre-task ceiling is the opposite of a bounded budget.
Sources: GitHub Community #198015 · #197960 · github.blog billing postCopilot's agent can't merge or approve its own PRs — neither can ours. The fork in the road is everything that happens before the PR exists. And with Agent HQ offering model pickers everywhere, the model isn't the differentiator either — the pipeline is the product, regardless of model.
Copilot hands you a draft and the work starts. We hand you a PR because the work finished.
This isn't rip-and-replace. Copilot completions in the IDE are excellent — keep them. The split is about delivery: route ticket-shaped work — features, bug fixes, dependency bumps, CVE patches — through Red Wheelbarrow's gated pipeline, so what lands in your review queue is already green, already reviewed, and budget-capped. Your engineers keep their autocomplete; your repo gets a quality bar.
Connect a repo, define your gates, and watch the first ticket converge — reviewed, tested, and capped before a human ever opens the diff.
Comparison reflects publicly available information about GitHub Copilot and its coding agent as of July 2026, including GitHub's documentation, the Microsoft .NET team's published retrospective, and community threads linked above. GitHub and GitHub Copilot are trademarks of GitHub, Inc. / Microsoft Corporation; Red Wheelbarrow is not affiliated with GitHub or Microsoft. If you spot something out of date, tell us and we'll fix it.
Devin is one autonomous generalist: a single agent per session, working in Cognition's cloud VM with a browser and a shell, grading its own confidence as it goes. Red Wheelbarrow is a structured pipeline: separated recon, implementation, review, and QA roles, with your own deterministic gates deciding — fail-closed — whether a pull request even gets to exist. Both open PRs on real repos. The difference is what you're asked to trust.
Massive parallel migrations, framework upgrades across millions of lines, tasks where a fleet of autonomous VMs that can browse and self-test is the whole value. Devin is genuinely the most autonomous agent for this shape of work.
Features, bugs, and upgrades flowing through a pipeline where every change must pass your lint, tests, build, and an independent review before a PR exists — and where failure is cheap, early, and explicit instead of a surprise invoice.
Devin belongs in the serious tier: it works on existing repos and opens real PRs. So the comparison isn't prototype vs production — it's how each system earns your confidence.
| Red Wheelbarrow | Devin | |
|---|---|---|
| Architecture | ✓Separated roles: Darlene maps the repo, Elliot implements on its own branch, Mr. Robot reviews, an agentic QA crew verifies. No agent grades its own homework. | One generalist agent per session in a cloud VM with browser and shell — planner, coder, tester, and judge are all the same model instance |
| Verification | ✓An independent reviewer agent checks every diff against the ticket's criteria and emits a structured verdict with a veto — on top of your deterministic gates | Self-assessed confidence ratings, plus Devin Review — the same vendor's platform reviewing its own agent's output |
| Quality gates | ✓Your lint / test / build commands plus Gideon AI QA, required on every ticket and fail-closed. If a gate fails, nothing ships. |
Respects your existing CI and iterates until checks pass — but there's no user-defined, fail-closed gate contract in the loop |
| Failure mode | ✓Bounded convergence: runs fail early, cheap, and explicit. Silence is safe. | Documented expensive persistence — in independent testing, days of compute burned attempting tasks that were impossible from the start |
| Blast radius | ✓PR-only contract. Brokered short-lived GitHub tokens; agents never touch production. The entire blast radius is a pull request. | A VM with a live browser and shell that can reach external systems — deployments, dashboards, whatever it can log into during a run |
| Cost shape | ✓Bounded by turn budgets per agent, per stage. Runs converge or stop. | ACU metering history (~$2.25/ACU); mid-complexity tasks reported at $67–$135; community reports of "$20 plans producing $400 invoices." 2026 self-serve details rest on secondary sources. |
| Planning layer | ✓Built in: sprint planning by chat and its own ticket board — plans approved before code is written | Triggered from Slack, Jira, or Linear — assumes you bring and maintain an external tracker |
| Oversight required | ✓Review the PR. The pipeline, gates, and reviewer have already done the babysitting. | Independent evaluations and 2026 reviews consistently report significant babysitting — scoping, monitoring, and rescuing sessions mid-run |
| Multi-tenancy & governance | ✓Multi-tenant orgs with roles, invites, and audit logging; row-level tenant isolation enforced twice | Team and Enterprise workspaces with org controls; governance model centers on Cognition's VM environment rather than your tenancy boundary |
| Track record transparency | ✓Every run leaves an inspectable trail: plan, diff, reviewer verdict, gate results — attached to the PR | Marquee numbers are vendor-reported (Nubank's 12x/20x figures are Cognition's claims); independent evaluations have been notably less flattering — see the receipts |
Everything below is public record — independent evaluations, trade press, pricing documentation, and Devin users describing their own workarounds.
Devin launched on a viral video of it "completing an Upwork job." Software engineer Carl Brown ("Internet of Bugs") went through it frame by frame: Devin solved a different problem than the job actually asked for, and a chunk of its impressive-looking debugging was fixing errors in files Devin itself had created. Cognition's products have improved since — but the pattern of headline claims outrunning verified results starts here.
Source: The RegisterResearchers at Answer.AI ran Devin on 20 real-world tasks: 3 succeeded, 14 failed, 3 were inconclusive. Most telling wasn't the ratio — it was the failure mode. On one task, Devin spent over a day attempting a deployment that was technically impossible, rather than recognizing the blocker and stopping. That's the trust-the-agent problem in one sentence. This evaluation predates Devin 2.x, which improved on several fronts — but "keeps going instead of failing fast" is an architecture property, not a version number.
Source: Answer.AIDevin's compute is metered in ACUs (historically ~$2.25 each), and failed or looping sessions burn them like successful ones. Third-party pricing analyses put mid-complexity tasks at $67–$135 on top of plan fees, and community reports describe entry plans producing invoices many times their sticker price. The commonly recommended mitigation — manually capping each session's ACU budget — is the user hand-building the bounded-budget contract Red Wheelbarrow ships as the default. Cognition's 2026 release notes tout a 4x-cheaper Fast Mode, which changes the rate, not the shape.
Sources: EasyClaw pricing analysis · Brainroad · Devin release notesDevin's own users publicly bolt independent reviewers onto its output — one engineer's workflow: "Devin wrote the PR, Claude Code reviewed it, I merged." And Cognition's Devin Review adding commit status checks is the vendor itself converging toward gate-shaped verification. Separate implementer, independent reviewer, checks that block the merge: that's Red Wheelbarrow's native pipeline, not an accessory you assemble afterward.
Sources: Medium (@huchka) · Devin release notesEvery receipt above traces back to one design choice: whether correctness is asserted by the agent, or enforced by a process the agent can't override.
You shouldn't have to trust an agent's confidence rating. You should be able to read the gate results.
Watch where the Devin ecosystem is heading: Cognition adding review layers and commit status checks; users wiring independent AI reviewers between Devin's PRs and their merge button; everyone manually capping budgets per session. Piece by piece, the market is reassembling a gated, role-separated pipeline around a single autonomous agent. Red Wheelbarrow starts from that premise — separated roles, an independent reviewer with a veto, your gates fail-closed, bounded budgets — instead of retrofitting it one workaround at a time.
Connect a repo, define your gates, and watch the first ticket converge — planned, implemented, independently reviewed, and gated before the PR ever reaches you.
Comparison reflects publicly available information about Devin and Cognition as of July 2026, including Cognition's own documentation and release notes and the third-party reporting and evaluations linked above; some 2026 self-serve pricing details rest on secondary sources. Devin and Cognition are trademarks of Cognition AI, Inc.; Red Wheelbarrow is not affiliated with Cognition. If you spot something out of date, tell us and we'll fix it.