Devin vs Merlin: Vendor Cloud vs Your Own Machines

Some of your engineers already run Claude Code or Codex on their laptops, with their repositories cloned, their credentials signed in and their MCP servers wired up. Now you want the rest of the company to hand an agent work from Slack or Linear, and you're weighing Cognition's Devin against keeping that work on the machines your team already uses with Merlin.

"Runs on your own machines" sounds like one question, and it's actually three: where the brain runs (the agent loop that plans and calls the model), where the hands run (commands, file edits and repository access), and where the environment is defined (a vendor snapshot you configure, or a teammate's machine that already works). Devin now lets you move the hands onto your hardware with Outposts and Local Hands, while its brain stays in Cognition's cloud. Merlin keeps both the brain and the hands on a teammate's machine, and the honest price of that choice is that a teammate's MacBook can close its lid and a vendor cloud never does.

If you're just here for a quick recommendation, start with these.

The short answer

• You want zero machines to babysit and agents that run while every laptop is closed: Devin. Every session boots a fresh cloud VM on Cognition's side.
• Your engineers already have Claude Code or Codex set up with repos, credentials and MCP servers: Merlin. The team reaches those existing setups from Slack, Linear and GitHub without rebuilding them in a VM.
• You need code execution inside your network and are fine with a vendor-hosted agent loop: Devin with Outposts, available on Pro, Max and Teams.
• You want a flat workspace fee and model usage on your existing Claude or ChatGPT plans: Merlin. Workspace plans run $19 to $99 a month.
• You want many parallel sessions on clean machines: Devin, with up to 10 concurrent sessions on Pro and Max and unlimited on Teams.
• You need Microsoft Teams, Jira, GitLab, Bitbucket or Azure DevOps: Devin. Merlin covers Slack, Linear and GitHub.

Devin and Merlin at a glance

Prices and features were seen on November 2, 2026.

What lives where

Most comparisons treat "cloud vs local" as a binary switch, or compare Devin to a single-player terminal session (if you want a broader field, see the roundup of Devin alternatives). Once you put Devin's Outposts next to Merlin, you need a finer map.

The brain is the loop that reads the task, picks the next tool call and decides when the job is done. In Devin, that loop always runs in Cognition's cloud, even when Outposts puts the shell and the git checkout inside your VPC. In Merlin, the loop is the local Claude Code or Codex process on a teammate's machine, and Merlin's server routes the request and streams the reply back to Slack, Linear or GitHub.

The hands and the environment split the same way. Devin gives every session a fresh VM booted from a snapshot you set up, or hands commands to an Outposts worker you run. Merlin skips the snapshot step and runs inside the machine an engineer already works on, with all the convenience and all the blast radius that implies.

Where the agent loop runs

Devin is Cognition's own agent harness, built around its compound model system and hosted by Cognition. Merlin is a team layer that drives the Claude Code and Codex harnesses your engineers already run locally.

Devin

• On every cloud plan, the brain stays with Cognition. Even in the Outposts docs, Cognition is explicit: "Devin's agent loop (inference and planning) continues to run in Devin's cloud, while all command execution, file edits, and repository access happen on machines you operate."
• The enterprise deployment overview states the same rule for dedicated environments: "Devin's workspace operates under the control of its brain, which always resides within Cognition's Cloud." On Enterprise, Cognition can host that environment in an auto-scaling, single-tenant VPC.
• Cognition also ships two single-user local tools: Devin CLI, "a local coding agent that runs directly in your terminal", and Devin Desktop, which is Windsurf renamed on June 2, 2026. Neither is the team agent that answers in Slack or Linear.

Devin runs each session in a fresh cloud VM that Cognition hosts.

Merlin

• The desktop app or CLI daemon on a teammate's machine runs Claude Code through its Agent SDK and Codex through its App Server (how Merlin works).
• Merlin's server picks which connected runtime takes a task, delivers the prompt and relays progress back to the thread. Per the security docs, "Merlin does not host a model of its own and does not stand between your prompts and the provider."

What people say

• On the gap between Cognition's cloud agent and its desktop app: "the lack of parity between Devin cloud and Devin desktop is downright embarrassing." (Hacker News)

My read: if your security review cares about where planning and prompts are orchestrated, notice that Outposts leaves the brain in Cognition's cloud. And if your engineers already trust the way Claude Code or Codex plans a change, Merlin lets the rest of the team use that exact loop instead of switching harnesses.

Where commands and files run

This is where Devin gives you three choices (its cloud VM, Outposts on your servers, or Local Hands on a laptop) and Merlin gives you one (a connected machine running Claude Code or Codex).

Devin

• By default in Devin Cloud, "Devin boots a fresh copy of the snapshot. Every session starts from the same clean state. Session changes don't persist back to the snapshot." Snapshots are Linux by default, with macOS snapshots for Xcode and iOS Simulator, and Windows "available on a limited basis" through sales.
• Devin Outposts runs the session's commands on "your own VMs, containers, Kubernetes clusters, or even a Mac Mini on your desk." It is available on all Pro, Max and Teams accounts, workers only need outbound HTTPS access, "N workers serve N concurrent sessions", and you can target one from Slack with !outpost followed by the outpost's name. The docs note that "Outposts shifts significant infrastructure and operational responsibility to the customer."
• Local Hands attaches your personal computer to a cloud session: "Your computer does not replace the session's VM. Devin keeps its VM and gets a second set of tools that run on your machine." By default every local tool call stops and asks you, and even with bypass on, built-in rules make some calls ask every time. Scheduled sessions, automations and service-user API sessions "cannot request a machine", and the feature is off by default for enterprise orgs.

Outposts moves command execution onto your hardware. Inference and planning stay in Devin's cloud.

Merlin

• Every task runs on a connected macOS, Windows or Linux machine through the local Claude Code or Codex (devices and runtimes). Per the security docs, "The files, repositories and tools the agent uses are the ones already on the device" and "It does not upload the working directory."
• Each conversation gets its own working directory, and the docs are plain about what that is and isn't: "This is not an operating-system sandbox or a separate user account." When a teammate names a project in their request, Merlin moves the task into that local checkout so its CLAUDE.md or AGENTS.md files apply.

In Merlin the machine is a teammate's own computer, listed with the Claude Code and Codex runtimes it reports.

What people say

• From a team lead who ran an evaluation: "The agent running in a VM - at least by default - was a key feature during the AI pilot I ran" (Hacker News).

My read: Devin's clean-VM-per-session model is a real comfort when you want an agent to try something risky without touching anyone's checkout. Outposts brings that model inside your firewall if you're willing to run the worker fleet. Merlin goes the other way: no VM to build, no worker pool to size, and also no VM boundary between the task and the machine owner's user account.

Setting up the environment

Every cloud agent makes you teach it how your project builds. A local agent inherits whatever a working engineer already set up on Tuesday.

Devin

• In Devin's environment docs, an environment is "a Linux-based virtual machine with your repositories cloned, tools installed, dependencies resolved, environment variables set, and configuration applied." Cognition calls configuring it "the single highest-leverage thing you can do to improve Devin's effectiveness on your codebase."
• You can configure it interactively or with YAML Blueprints, and Devin can write the YAML for you: "Start a Devin session and ask: 'Set up your environment for this repo.'"

Merlin

• The prerequisites are a machine that "has the repositories, credentials, tools, skills and MCP servers the work needs" with Claude Code or Codex "already installed and authenticated". If an engineer can build the repo on their machine today, Merlin can run tasks there without a separate setup step.
• The trade-off is consistency across machines: as how Merlin works notes, "A different runtime may have different local files, credentials, skills and MCP tools."

What people say

• The first-hour complaint: "I tried Devin today and it couldn't get it to work after one hour of fiddling. How do you store the repo's setup scripts?" (Hacker News)
• And from someone past that hump: "90% of my dev workflows have moved to Devin cloud agents. I don't miss the days of fumbling around with my local repos" (Hacker News).

My read: those two quotes are both true, and they're separated by whether you've invested the afternoon it takes to get a Devin snapshot green. If your build needs private package registries, a VPN, three Docker services and five MCP servers, Merlin's shortcut is that an engineer has already done that work on their own machine.

Credentials and data

When an agent runs in a vendor VM, you bring secrets to the agent. When it runs on a teammate's machine, you bring the agent to the secrets, and you need to be thoughtful about who else in the workspace can use that machine.

Devin

• Per the secrets guide, Devin starts with a blank slate: "it cannot discover your credentials." Cognition recommends "a dedicated account for Devin to use (e.g. devin@company.com) on each service", and organization secrets "are persisted to future sessions and apply to the entire organization."
• On data retention, the security page states: "By default, we may use your data for model training purposes... If you're on a paid plan, you can opt out at any time." Opting out turns on Zero Data Retention with model providers, and on Teams only an admin can flip the switch. Enterprise plans never train without written consent, and Cognition has held SOC 2 Type II since September 2024.

Merlin

• Provider credentials, personal MCP configs, repository contents, local files and shell environments stay on the device and are not uploaded as inventory (security). Merlin's server stores accounts, integration authorizations, request records and the shared context you publish (skills, memory, guidance and automations). The docs also spell out the boundary: "Local execution does not mean all information remains on the device. Slack, Linear, GitHub, model providers, MCP tools and Merlin process the information needed for the authorized task."
• For runtime sharing, "New runtimes begin private. Only their owner can change them to public." Once public, "A public runtime delegates real execution capability to eligible workspace members" and "Merlin does not ask the device owner for a new mid-run approval for each command."

Each runtime's owner decides who may use it, how many tasks it takes at once and which model it runs.

My read: Devin's devin@company.com pattern is clean for audit trails, because the agent only ever holds the keys you paste into it. Remember to opt out of training on day one if you're on Pro, Max or Teams. On Merlin, keep personal laptops private and put shared team work on a dedicated Mac Mini or Linux box with its own service accounts.

Models and who pays

Devin bundles model calls and VM compute into one subscription with usage quotas. Merlin charges a workspace fee for the coordination layer and runs model calls on the Claude or ChatGPT accounts your team already pays for.

Devin

• On Devin's pricing page (seen November 2, 2026), plans are Free at $0 (no cloud agents and no integrations), Pro at $20 a month, Max at $200 a month, Teams at "$80/month for team plan + $40/mo per full dev seat", and Enterprise billed in ACUs. Cognition retired its old $500 Team entry point on April 14, 2026. Allowances reset daily and weekly (weekly only on Max), exact quota numbers aren't published, and extra usage is "consumed at API pricing."
• Pro includes "frontier models from OpenAI, Claude, Gemini, and SpaceXAI, plus leading open source models" along with Cognition's own SWE-2, and the cloud model picker lists Fable 5.1, Opus 5 and GPT-6 Astra as of the September 23, 2026 release notes. Per the enterprise docs, "Devin is a compound AI system and does not currently support third-party LLM API keys."
• You can link a ChatGPT Go, Plus or Pro plan on self-serve Pro, Max and Teams: "Your ChatGPT plan pays only for GPT model requests in sessions you own." Machine time and automations not run as you still draw Devin quota, "Devin Cloud sessions also still need available Devin quota or on-demand credits to start", and there is no equivalent link for a Claude subscription.

Merlin

• On Merlin's pricing page, workspace plans are Starter at $19 a month (up to 5 active users and 1,000 requests), Team at $59 a month (up to 50 users and 5,000 requests) and Scale at $99 a month (up to 200 users, unlimited requests), with a 14-day Team trial that needs no card.
• Model usage runs on the Claude or ChatGPT plan (or API key) signed in on the machine that takes the task. The runtime owner sets the default model, reasoning effort and mode, and anyone asking in Slack can override it for a turn with phrases like "max effort" or "use Alice's" (devices and runtimes). The trade-off is vendor breadth: Merlin only supports Anthropic through Claude Code and OpenAI through Codex.

What people say

• On Enterprise ACUs: "ACU are entirely too opaque/confusing/complicated. The entire description of them is shrouded in mystery." (Hacker News)
• On the $20 Pro tier: "I've been hitting the limits of the $20/month plan way more quickly than I'd expect, and definitely more quickly than with Claude Code or Codex." (Hacker News)
• On scheduled runs: "Devin Automations is the most obvious one: solid UX, but can get very expensive to run." (Hacker News)

My read: if your engineers already pay $20 to $200 a month each for Claude or ChatGPT plans and leave quota on the table every week, Merlin keeps model usage on each machine owner's own plan for a $59 workspace fee. If you want Gemini, open-source models or SWE-2 alongside Claude and GPT under one bill, that's Devin.

Where your team asks for work

Both tools meet your team in Slack, Linear and GitHub, and both run scheduled and webhook automations. Devin covers more enterprise ticketing and git hosts.

Devin

• In Slack, you mention @Devin in any channel and it replies in-thread with the thread history as context. Each user links their Slack profile once, and bang commands like !outpost and !windows steer where the session boots.
• Beyond Slack, Linear and GitHub, Devin integrates with Microsoft Teams, Jira, GitLab, Bitbucket and Azure DevOps on paid plans, and Devin Automations trigger from Slack, GitHub, Linear, schedules and webhooks.

Merlin

• Teammates mention @Merlin or DM it in Slack, delegate or mention it on Linear issues (where an agent session streams progress and takes follow-up steering), and mention it on GitHub issues and pull requests.
• Automations run on schedules and webhooks and can be created in the web app or by asking in Slack, and each Slack channel can keep its own Markdown memory. There is no Microsoft Teams, Jira or GitLab integration today.

My read: if your company runs on Microsoft Teams, Jira or GitLab, pick Devin and stop reading here. If your work lives in Slack, Linear and GitHub, both cover the loop from ticket to pull request.

When the machine is asleep

This is the everyday trade-off that decides whether you're happy a month in. A cloud VM is always there when a webhook fires at 3 a.m. A laptop in a backpack is not.

Devin

• Pro and Max allow up to 10 concurrent sessions, and Teams and Enterprise allow unlimited concurrent sessions (pricing).
• Per the usage docs, "Devin sleeps automatically after 30 minutes of inactivity by default" and "While sleeping, Devin does not consume usage." With Outposts, concurrency equals the number of workers you keep running.

Merlin

• Per the prerequisites, "The machine must stay awake, online and running the Merlin client while it accepts work. The client opens an outbound connection to Merlin, so you do not need to expose an inbound port on the device."
• Each runtime accepts between 1 and 16 concurrent tasks (4 by default), and you can connect as many machines as you like (devices and runtimes). For scheduled work and webhooks, the rule in how Merlin works is strict: an automation runs only on the runtime its creator chose, one they own, and when that runtime is offline or busy the run is skipped.

My read: don't point a nightly automation at a MacBook that rides home on the train. If you use Merlin for shared Slack requests and scheduled jobs, put a Mac Mini on an office shelf or run the CLI daemon on an always-on Linux box, and leave laptops for each engineer's own tasks.

Which one should you pick

Four common team shapes make the choice straightforward.

1. You want an autonomous cloud engineer with zero machines to manage, or your team uses Jira, GitLab or Microsoft Teams. Pick Devin. Every session starts in a clean VM, up to 10 run in parallel on Pro and Max (unlimited on Teams), and nothing breaks when people close their laptops.
2. You need code and commands to stay inside your network, and you have the platform team to run worker nodes. Pick Devin with Outposts, as long as your security policy is comfortable with the agent loop itself staying in Cognition's cloud.
3. Your engineers already live in Claude Code or Codex, and you want PMs, designers and other engineers to hand those setups work from Slack, Linear and GitHub. Pick Merlin. You skip rebuilding your environment in a vendor snapshot, and model usage stays on the Claude and ChatGPT plans you already pay for.
4. You want both a local setup and always-on reliability in Merlin. Put the Merlin client on an always-on desk machine or Linux server with its own service credentials, mark that runtime public for the workspace, and keep personal laptops private.

5 things most comparisons skip

• Outposts moves the hands, and the brain stays in Cognition's cloud. Commands, file edits and repo access run on your worker, while inference and planning stay in Devin's cloud on every tier, including Enterprise single-tenant VPC.
• Local Hands cannot run unattended. Scheduled sessions, automations and service-user API sessions cannot request a Local Hands machine, and by default every local tool call waits for a human click.
• Linking ChatGPT to Devin only covers part of the bill. A linked Go, Plus or Pro account pays only for GPT model requests in sessions you own, and a cloud session still needs available Devin quota or on-demand credits to start.
• Devin's training opt-out is off until you flip it. Paid plans can opt out of model training (which also turns on Zero Data Retention with model providers), and on Teams an admin has to toggle it.
• A Merlin machine is a real user account, not a disposable sandbox. Making a runtime public lends that machine's credentials and files to teammates without per-command prompts, which is why shared runtimes belong on a dedicated machine with dedicated accounts.

FAQ

If you want clean cloud VMs that run while everyone sleeps and plug into Jira, GitLab or Microsoft Teams, start a session on Devin. If your team already trusts Claude Code or Codex on their own machines and just wants a way to reach them from Slack, Linear and GitHub, try Merlin on a machine you already have open.