Book a Demo Talk to Sales

Comparison · Coding agents

Curiosity and GitHub Copilot
Different jobs, used together

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

Book a Demo Talk to Sales

Their deployment GitHub Actions runners, your IDE or terminal Their data model Files in your GitHub repository 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.

GitHub Copilot

GitHub’s AI coding product. Its agents are the cloud agent, which works on GitHub Actions and delivers a pull request, agent mode in the major IDEs, and Copilot CLI. It suits teams whose code and review already live on GitHub, offers a broad choice of models, and its cloud agent follows the branch protections and review rules a repository already has.

How Curiosity compares

Where the boundary falls

Copilot is not an alternative to Curiosity, and teams use both. It fits into the review process a GitHub repository already has. 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. Curiosity is that system, and through curio Copilot 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

GitHub Copilot 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.

CuriosityGitHub Copilot 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

GitHub Copilot writes it. Sudo checks it. You approve it.

curio is Curiosity’s command line. It gives GitHub Copilot 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

    One command where Copilot runs, then sign in to your workspace in the browser.

  2. 02

    Give GitHub Copilot the skill

    curio skills install ./.github/skills puts the skill where Copilot looks. It reads .claude/skills and .agents/skills too.

  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 login --server https://studio.example.com
 curio skills install ./.github/skills

For the cloud agent, install curio in copilot-setup-steps.yml, add CURIOSITY_SERVER and CURIOSITY_TOKEN as Agents secrets, and put your workspace on the firewall allowlist.

curio on curiosity.sh Coding Agents in the Docs

Side by side

Feature comparison

The same five questions, answered for both.

CuriosityGitHub Copilot

Deployment

Cloud or self-hosted, ready to use

GitHub Actions runners, your IDE or terminal

Data model

Managed context layer and knowledge graph

Files in your GitHub repository

Industrial fit

Built for industrial and enterprise teams

Software teams working on GitHub

Data reach

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

One repository, plus MCP servers you configure

Residency

EU hosted, or entirely your own infrastructure

GitHub and model providers, US or EU option

Customization

What your team can change

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

CuriosityGitHub Copilot

Your own code

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

Writes, builds and tests code in your repository

Your own interface

Your own front end in C#, deployed from git

Writes interface code, does not host it

Data model

Typed node and edge schemas you define

Not available, works on your files

Configuration as code

Every change committed to git, pushed to your remote

Instructions, AGENTS.md, skills and custom agents in git

APIs and SDKs

REST API, C# and Python library, connector SDK

Copilot SDK in six languages, CLI over ACP

AI integration

What AI can build and reach

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

CuriosityGitHub Copilot

AI that builds

Sudo drafts endpoints, tools, schemas and screens

Plans, edits, runs tests, opens pull requests

Review before it applies

Every change a diff a person approves, in a sandbox

Pull request review, workflows wait for approval

Model choice

Any major provider, or an OpenAI compatible endpoint

OpenAI, Anthropic, Google, xAI and other models

Models on your servers

Open weights on your servers, or air gapped

Your own key in IDE and CLI, Ollama included

Assistant permissions

Built in tools search as the user, per record

Cloud agent: its own identity, one branch, firewall

Agent protocols

MCP server and an OpenAI compatible API

MCP client, CLI speaks Agent Client Protocol

Which to use

When each is the right choice

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

GitHub Copilot alone

  • The code and its review already live on GitHub.
  • 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.

GitHub Copilot 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

Google Antigravity

Antigravity runs the agents that write the code; 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