Devin vs ellul
A managed engineer, or your agent's workstation.
Devin is Cognition's product: hand it a task, it works in their sandbox, you get a PR. Ellul is the runtime under your own agent (your Claude Code, your Cursor, your Codex) on a persistent workstation that's yours. Different commitments, different shapes.
Updated
The fundamental difference
Devin is the agent and the runtime, sold together as a managed product. Ellul is the runtime under your agent: your existing Claude Code or Cursor CLI on a persistent workstation, with your credentials and your tools. Devin is high-end SaaS; Ellul is infrastructure. They are not the same kind of purchase.
Where Devin is strong
If you want a fully managed product where Cognition's agent does the engineering, picks the model, runs the sandbox, and produces a PR with minimal handholding, Devin is the highest-profile entry in that category. The product is opinionated end-to-end and well-funded.
Where ellul is stronger
Engineering work where you keep your existing agent CLI, your model contract, your codebase ownership, and your deploy target. Ellul is the runtime; you choose the agent and the model. Flat pricing, persistent workstation, parallel-capable, passkey-gated.
Feature comparison
| Capability | Devin | ellul | Advantage |
|---|---|---|---|
| Bring-your-own-agent | Devin only | Claude Code, Cursor, Codex, OpenCode | |
| Bring-your-own-model | Cognition-managed model stack | Yes (BYOK on every supported agent) | |
| Codebase ownership | Yours, but Devin operates inside its sandbox by default | Yours: git, your repo, your CI | |
| Persistent workstation between tasks | Per-task sandbox; some session continuity | Yes (installed deps, branches, MCP servers persist) | |
| Real-credential operations | Devin-managed credentials inside their sandbox | Passkey-gated, server-side vault | |
| Parallel agents | Multiple Devin sessions; no peering primitive | Multiple workstations, read-only peering | |
| Editor experience | Devin's chat + workspace UI | Pair with your IDE locally; browser file browser as backup | |
| Always-on agent | Tasks run autonomously per session | Yes (workstation persists, agent runs continuously) | |
| Phone-as-keyboard | Devin web app on any device | Yes (passkey approval from any device) | |
| Pricing model | Core $20/mo PAYG at $2.25 per ACU; higher tiers above | $20 / $50 per month flat | |
| Scope of work the product is shaped for | End-to-end task autonomy on bounded engineering tickets | All engineering work an agent is suited to | |
| Open ecosystem | Closed product | Open agent CLIs, open MCP, BYOK |
Pricing
| Tier | Devin | ellul |
|---|---|---|
| Individual | Core $20/mo PAYG (~$2.25/ACU) | $20/mo Hobby |
| Pro | Higher tiers (Pro/Max) and enterprise via sales | $50/mo Pro |
| Bring-your-own-model | No | Yes |
Verdict
Devin for the managed-engineer SaaS pitch; Ellul for the runtime under your own agent.
If you specifically want a managed product where Cognition's agent does the work and you don't want to operate any infrastructure, Devin is in your category. If you want your existing Cursor / Claude Code / Codex agent on a persistent workstation, with your credentials, your model, and your repo, Ellul is in your category. Most engineers we talk to who evaluate both don't actually choose between them; they end up with their own agent on Ellul because that's the shape of their existing workflow.
When to use each
Use Devin when
- You want a fully managed product where the agent and the runtime are bundled.
- You don't have an existing agent CLI you want to keep using.
- You're fine with the per-task / high-tier pricing model.
- You want Cognition to own the model selection and tool integrations.
Use ellul when
- You already use Claude Code, Cursor, Codex, OpenCode, or another agent CLI.
- You want your own model contract (BYOK) rather than a managed model stack.
- You want flat-rate pricing rather than per-task or high-tier subscriptions.
- Your agent needs real-credential operations gated by your passkey.
- You want parallel agents with structural isolation.
Common questions
Can I run Devin on Ellul?
Devin is a managed product; it doesn't ship as a CLI you install on your own infrastructure. So no: you'd run Devin on Cognition's cloud and your other agents (Claude Code, Cursor's CLI, etc.) on Ellul.
Is Devin's autonomy more advanced than Claude Code on Ellul?
Hard to say categorically. Devin is opinionated about the loop and the model; Claude Code on Ellul is composable, so the agent's autonomy is whatever your model and your prompts produce. The decision usually comes down to whether you want a packaged product (Devin) or a runtime you can shape (Ellul).
What about Devin's pricing?
Devin 2.0 launched in April 2025 with a Core plan starting at $20/mo, billed pay-as-you-go at roughly $2.25 per Agent Compute Unit (about 15 minutes of agent work). Higher Pro and Max tiers exist for heavier individual usage; team and enterprise plans are above. Ellul is $20/mo Hobby and $50/mo Pro flat, plus whatever model API you're paying directly. The two products price for very different commercial shapes.
Does Cognition's acquisition of Windsurf change anything?
Cognition acquired Windsurf in 2025. The two products coexist with different deployment models: Devin is managed-cloud, Windsurf is a local IDE. From an Ellul perspective the change is mostly irrelevant. We run agent CLIs from Anthropic, OpenAI, Google, Cursor, Cognition, or anyone else, and the runtime stays the same.
Is Devin safer than running Claude Code on Ellul?
Safer along different axes. Devin's safety is 'we run the agent in our sandbox and curate what it can do.' Ellul's safety is 'kernel-level isolation per agent, passkey-gated privileged actions, credentials never in the agent process.' For real-credential engineering, Ellul's structural model is meaningfully harder to attack; for end-to-end task autonomy on bounded tickets, Devin's curated sandbox is a different reasonable choice.
Related solutions
Topics
Try it
Move your agent off your laptop.
Hobby is $20/month. Pro is $50/month. Bring any agent: Claude Code, Codex, Cursor, OpenCode.
Compare against another tool