A local-first desktop agent that runs on your own API keys. The runtime, the database, and every conversation stay on your machine. Bring a key from any of eight providers — or run a model locally and use no key at all.
The cheapest task is the one that finishes. You buy inference at your provider's list price — no seat, no markup, nobody reselling you tokens — you can see what a task will cost before you run it, and the harness is tuned so runs finish instead of dying at eighty percent.* An unfinished run costs full price and delivers nothing.
Put your day on autopilot.
npm install -g @0x-copilot/cli
copilotNode.js 20+, macOS (Apple Silicon or Intel) or Windows x64. Prefer Bun?
bun add -g @0x-copilot/cli.
- Nothing is hosted. An embedded PostgreSQL and three local services run on
localhost. No account of ours sits between you and your model provider. - Your keys, your choice of model. OpenAI, Anthropic, Google, Groq, xAI, OpenRouter, Virtuals compute, or any OpenAI-compatible endpoint. Local models run on your own GPU through Ollama.
- Connects to real tools over MCP, with OAuth handled for servers that support it and consequential writes held at an approval gate.
- Work lands as artifacts you keep — documents, code, and datasets, editable in place, revisioned, and downloadable.
- You can see the bill forming. A context meter in the composer, and a model catalogue carrying real per-million-token pricing — so cost is a decision you make up front, not a surprise you read afterwards.
- Runs that finish. An inherited step ceiling was quietly terminating live work mid-task; removing it raised task completion for +0.1% tokens.*
* Measured on internal benchmarks, driven against the packaged app and
scored from the same records the product bills from. Method, results, and the
claims that did not survive: tools/harness-bench/FINDINGS.md.
Prompts and context leave your machine only for the model provider or connector a task actually uses, and go nowhere else.
Provider keys are encrypted at rest in a local vault. Local run history can be encrypted too, and the app can require Touch ID to open and lock itself when idle.
The model picker is built from the provider's own live catalogue, so it is discovered rather than hardcoded:
| Direct | OpenAI · Anthropic · Google Gemini · Groq · xAI |
| Gateways | Virtuals compute · OpenRouter |
| Local | Ollama — install, run, and set a default from inside the app |
| Anything else | any OpenAI-compatible endpoint |
Virtuals compute is the reason that matters in practice: it fronts roughly sixty models from ten vendors behind one endpoint and publishes its own live inventory, priced per million tokens, so a model added upstream appears here without a release. Local models run on your own GPU or CPU through Ollama — private, offline, and no key at all.
Copilot speaks MCP, with OAuth handled for servers that support discovery and dynamic client registration, and per-server credentials for those that do not. Connector tokens live in the same encrypted local vault as your provider keys. Writes through a connector are gated: a consequential action waits for your approval on the surface it affects.
You can also give Copilot reusable skills, group work into projects, and review everything it did from the activity destination.
- Install and launch. Run the two commands above. The first launch stages the local runtime; later launches start directly.
- Sign in. Connect a wallet, or use Google when it is enabled for your deployment.
- Choose a model. Open Settings → Models & keys → Provider keys and add the provider you want to use, or install a local model instead.
For diagnostics, updates, data locations, and uninstall instructions, see the
@0x-copilot/cli guide.
tools/harness-bench/FINDINGS.md is the
harness benchmark. Every number in it comes from the packaged app running
against a real model, scored from the same records the product bills from.
It also carries the correction of an earlier version of itself, which had declared its own headline finding falsified on the strength of a metric that was structurally blind to the failure it existed to detect.
Claims that did not survive are retracted there rather than quietly dropped — which is the point of publishing it at all.
0xCopilot is built by Kleos Research, which works on the layer between agents and the models they run on. Its other project is Kaleidoscope, filesystem-native memory for agents — user-owned files, no database server, and no model of its own. Held-out results are published in Optimising for memory recall.
Pull requests target dev, never main.
feature ──PR──▶ dev ──promote-to-main.yml──▶ main ──release-cli.yml──▶ npm
dev is the integration branch: every change lands there first and CI runs on
it. main is the released branch and moves only when the promotion workflow is
dispatched, which refuses to promote a dev commit whose checks are not all
green and all finished.
So work from dev, not main — main is a release pointer and is usually the
older of the two:
git checkout dev && git pull # start here
git checkout -b feat/your-change
gh pr create --base devThree checks must pass on every PR: lint-and-secrets, tenants-lint and
repo-gates (about 45 seconds total). Merging requires write access, which is
held by the maintainers — anyone may fork and open a PR, and a maintainer merges
it after review. Outside contributions need two approvals.
Use Conventional Commit subjects
(feat:, fix:, feat!:, a BREAKING CHANGE: footer). They are not
decoration: the CLI changelog and the next version number are both derived from
them, and a subject that is not conventional is skipped rather than guessed at.
Releases are manual and dry-run by default. While the CLI is 0.x, a breaking
change bumps the minor digit (0.1.4 → 0.2.0) and everything else bumps
patch, because npm resolves ^0.1.4 as >=0.1.4 <0.2.0. Full detail, including
how promotion and publishing are run:
branching and release.
- Branching, protection and release
- Desktop and supervised runtime
- CLI installation and troubleshooting
- Architecture and service boundaries
- Development and API testing
- Security policy and control mapping
- Product use cases
Questions, bug reports, and feature requests belong on GitHub Issues.
Please report vulnerabilities privately as described in the security policy.
MIT © 0xCopilot