Book a Demo Talk to Sales

Comparison · Coding agents

Curiosity and Devin
Different jobs, used together

Devin takes a ticket and writes the code in its own cloud; Curiosity is the platform the tool runs on.

Book a Demo Talk to Sales

Their deployment Cognition’s cloud VMs, a dedicated tenant, or Outposts Their data model Your repositories, cloned into its VM Our deployment Cloud or your own servers Our residency EU, or your own

Your data · your environment

Who each tool is for

Different problems, honestly stated

Curiosity

For industrial and regulated teams whose knowledge sits in engineering systems and structured records, where the answer depends on how those records connect, and where the deployment has to run on their own infrastructure.

Devin

Cognition’s autonomous software engineer. Each session runs in a Linux VM in Cognition’s cloud, or in a single tenant VPC Cognition hosts, and you assign work from the web app, Slack, Teams, Linear, Jira or its API. It suits teams that delegate scoped tickets, migrations, tests and fixes, and review the pull requests it opens.

How Curiosity compares

Where the boundary falls

Devin is not an alternative to Curiosity, and teams use both. It takes a ticket and returns a pull request with no local setup. What it does not bring is the system an enterprise tool runs on: connected records, permissions per record, sign in, an audit trail and hosting on your infrastructure. Curiosity is that system, and through curio Devin builds on it.

The platform the code runs on

A coding agent writes code. An enterprise app also needs its data connected and kept current, a data model, search, sign in and hosting. Curiosity ships those, so the agent writes the part that is yours.

Permissions the code cannot forget

Code an agent writes checks access only where it remembers to. In Curiosity, access is synced from the source systems and applied per record, so a tool built on it inherits what each user may see.

A change a person approves

Through curio the agent works in Sudo’s sandbox: it edits, builds against the workspace and stages a commit. Nothing runs until a person approves the diff.

Keep the agent you have

curio is a command line, so any coding agent that can run a shell command can work on your workspace. Your developers keep their tools; the platform keeps its rules.

Out of the box

What an enterprise app needs before its first screen

Devin can write each of these. Then your team owns it: keeps the connectors current as the source systems change, and shows an auditor that every screen checks access. In Curiosity they come with the platform.

CuriosityDevin alone

Data from your systems

70+ systems connected, kept in sync

Connectors the agent writes and your team runs

A data model

A typed graph of records and their links

A schema the agent designs for each app

Search

Keyword, semantic and hybrid search in one query

A search stack to choose, host and tune

Permissions

Synced from each source, applied per record

Access checks the code has to remember

Sign in

SSO through Google, Microsoft, Okta, Auth0 or SAML2

An identity integration for each app

Audit trail

User actions, downloads and AI interactions logged

Logging the agent adds when someone asks

Change control

Every change a diff a person approves

Your repository’s pull request review

Hosting

Your servers or private cloud, with replicas and backups

Infrastructure your team builds and runs

Use them together · curio

Devin writes it. Sudo checks it. You approve it.

curio is Curiosity’s command line. It gives Devin a session on your workspace: Sudo’s skills to read, a sandbox to edit in, and a build that checks the change against the workspace. The agent never gets more than that session.

  1. 01

    Install curio

    Install curio in the VM’s blueprint, and add CURIOSITY_SERVER and CURIOSITY_TOKEN as secrets.

  2. 02

    Give Devin the skill

    curio skills install ./.agents/skills in the repository. Devin reads .agents/skills in every repository it works on.

  3. 03

    Approve what it builds

    The agent edits and builds in a session, and stages a commit. A person approves it on Sudo’s review screen, and only then does the workspace run it.

Terminal
 curl -fsSL https://curiosity.sh/install.sh | bash
 curio skills install ./.agents/skills
 curio whoami

Devin runs in Cognition’s cloud, so your workspace has to be reachable from there: a public address, Devin’s published IPs on your allowlist, or a VPN. Devin binds a secret only to the commands that need it, so tell it curio reads these two.

curio on curiosity.sh Coding Agents in the Docs

Side by side

Feature comparison

The same five questions, answered for both.

CuriosityDevin

Deployment

Cloud or self-hosted, ready to use

Cognition’s cloud VMs, a dedicated tenant, or Outposts

Data model

Managed context layer and knowledge graph

Your repositories, cloned into its VM

Industrial fit

Built for industrial and enterprise teams

Teams delegating backlog tickets

Data reach

70+ systems connected, and yours through a connector you write

Repositories, VM shell, browser, MCP servers

Residency

EU hosted, or entirely your own infrastructure

Cognition’s cloud, or a single tenant VPC

Customization

What your team can change

Your own code, interface, data model and configuration. Devin as its own documentation described it in October 2026. Where it says Not available, the vendor documents no such capability.

CuriosityDevin

Your own code

C# endpoints, AI tools and tasks, compiled in Studio

Writes code and opens pull requests

Your own interface

Your own front end in C#, deployed from git

Writes interface code, does not host apps

Data model

Typed node and edge schemas you define

Not available, works on your repositories

Configuration as code

Every change committed to git, pushed to your remote

AGENTS.md, repository skills, blueprints, Playbooks

APIs and SDKs

REST API, C# and Python library, connector SDK

REST API, Devin MCP server, CLI

AI integration

What AI can build and reach

Whether AI can build on it, who reviews the result, and which models it runs. Devin as its own documentation described it in October 2026.

CuriosityDevin

AI that builds

Sudo drafts endpoints, tools, schemas and screens

Autonomous agent builds, tests, opens pull requests

Review before it applies

Every change a diff a person approves, in a sandbox

No approval per step, you review its PRs

Model choice

Any major provider, or an OpenAI compatible endpoint

Chosen by Cognition in the cloud

Models on your servers

Open weights on your servers, or air gapped

Only in air gapped federal deployments

Assistant permissions

Built in tools search as the user, per record

Org GitHub app and secrets, isolated VM

Agent protocols

MCP server and an OpenAI compatible API

MCP client and server, ACP in Desktop and CLI

Which to use

When each is the right choice

Building on Curiosity does not mean giving up Devin. The question is what it builds on.

Devin alone

  • You delegate scoped tickets from Slack, Teams, Linear or Jira.
  • The application already has its data, sign in and hosting.
  • The tool reads one system, or none.
  • It is a prototype, not a tool people run on production records.

Devin on Curiosity

  • The tool needs records from several systems, kept current.
  • Each user may see only what the source systems show them, per record.
  • It runs on your infrastructure, with SSO and an audit trail.
  • You want every change built, reviewed and approved before it runs.
At Airbus, we developed the next generation of customer support AI assistance tools with Curiosity, enhancing our technical support’s ability to access and navigate vast data from multiple sources, including millions of documents.

Services Innovation Team

Airline Services at Airbus

Coding agents

Other comparisons in this group

All Comparisons

Claude Code

Claude Code writes the code from your terminal; Curiosity is the platform the tool runs on.

Compare

OpenAI Codex

Codex writes the code, locally or as parallel cloud tasks; Curiosity is the platform the tool runs on.

Compare

GitHub Copilot

Copilot writes the code and opens the pull request; Curiosity is the platform the tool runs on.

Compare

Your data. Your infrastructure.

Build on it with the agent you have

Book a Demo Talk to Sales