v0.5 · open beta · Google sign-in

Version control,
but for context.

Your agent context is code now — it ships features, breaks builds, and gets out of sync the moment two engineers touch it. Contexo gives it the same discipline your repo has: diffs, history, branches, reviews, and a single source of truth.

Open source MCP-native Self-host ready
~/payments-svc feat/refunds-v2 · clean
$ ctx status on context feat/refunds-v2 · 3 modified · 1 staged ──────────────────────────────────────────── M   .ctx/rules/payments.md +12 −3 M   .ctx/mcp/stripe.json +4 −1 A   .ctx/prompts/refund-flow.md +48
$ ctx diff payments.md − never call /charges without an idempotency key + require idempotency key on /charges and /refunds + surface 409 conflicts back to the user
$ ctx push origin feat/refunds-v2 enumerating: 3 files, 64 lines pushed to contexo.live/acme/payments-svc requested review from @maya, @jules

Your team learns once,every agent knows. The next session starts from your team's combined work, not from zero, and not from someone else's laptop.

Wired into the stack you already use
Claude Code Cursor Windsurf Zed Continue MCP GitHub
01 / The drift

Your context is everywhere,
and yours alone.

CLAUDE.md in this repo, .cursor/rules in that one, a private Notion doc with the "real" system prompt, a Slack thread that explains why. Multiply by every teammate. Nothing is versioned. Nothing is shared. The agent always feels worse on someone else's machine.

01 — silent drift

Two engineers, two agents, two answers — to the same question.

Local rule files quietly diverge. The agent that ships Maya's PR is not the agent reviewing yours, and you can't tell.

02 — tribal prompts

The good system prompt lives in one person's dotfiles.

When they leave, the institutional taste leaves with them. The next hire spends six weeks reinventing it from scratch.

03 — no audit trail

Production agents shouldn't change behavior without a review.

Today, a prompt edit is a one-line copy-paste. No diff, no approver, no rollback. That's not engineering, that's vibes.

02 / The workflow

Same verbs
you already know.

Contexo is a CLI and a service. If you've used git, you've used Contexo. The four commands below cover 95% of day-to-day work — the rest reads like a git man page on purpose.

STEP 01 / INITctx init

Make your scattered context a repo.

Point Contexo at your project and it picks up CLAUDE.md, .cursor/rules, .windsurfrules, AGENT.md, and any MCP config you've got. One .ctx directory, every agent reads from it.

$ ctx init
found 4 sources · merging into .ctx/
CLAUDE.md → .ctx/rules/root.md
.cursor/rules/* → .ctx/rules/cursor/
mcp.json → .ctx/mcp/
! 2 conflicts — run `ctx resolve`
STEP 02 / SYNCctx pull

Start with the knowledge
your team already has.

Pull the latest concepts, entities, and reasoning trails from your team's Contexo. Your agent walks in with the same context everyone else has — no re-deriving what's already known.

$ ctx pull
7 new pages · 3 updates · 1 new source
wiki/concepts/stripe-subscription.md (by @maya)
wiki/entities/stripe.md
raw/sessions/2026-05-21-stripe-billing.md ← reasoning trail
STEP 03 / PUSHctx push

Ship the change
like you ship code.

Push to a Contexo remote and open a context-request. Teammates review the diff, leave comments, approve. Merge to main and every agent in the org pulls it within seconds.

$ ctx push origin prompt/strict-refunds
contexo.live/acme/payments-svc
pushed · CR #142 opened
→ requested review: @maya · @jules
→ ci: golden-evals queued
STEP 04 / INVITEctx invite

Hand off access
in one command.

Mint an invite key for a teammate, a contractor, or your whole team. The key expires after a week, or an owner can revoke it at any time.

$ ctx invite mint --label for-contractor
ctxi_a9f1c20… · expires in 7 days
they run:
$ ctx join ctxi_a9f1c20
$ ctx pull
134 files · ready · linked to ./cursor, ./claude
03 / Inside a context-request

Review prompts
like you review pull requests.

Every change to a system prompt, rule file, or MCP config gets a real review surface. Side-by-side diffs, threaded comments, eval CI, approvers. Nothing ships to production agents without a sign-off.

.ctx /
rules
M payments.md
· root.md
mcp
M stripe.json
+ prompts
+ refund-flow.md
.ctx / rules / payments.md 12 additions · 3 deletions
14## Refunds
15 
16Never call /charges without an idempotency key.
16Require an idempotency key on /charges and /refunds.
17If Stripe returns 409, surface the conflict to the user verbatim —
18do not silently retry partial refunds.
19 
20### Tools
21The agent may call stripe.refunds.create with scope "refunds:write".
.ctx / rules / payments.md abc1234def5678
Section-aware view · 4h ago · @you
Frontmatter
~ updated2026-05-22 → 2026-05-24 + tagsidempotency
Sections
~ ## Refunds 3 lines changed
introduced by @maya at 8c2a1f9
+ ## Tools 1 line added
added by @you in this CR
= ## Authorization unchanged
= ## Webhook handling unchanged
History of .ctx / rules / payments.md 4 commits · newest first
def5678 4h ago @you Make refund flow idempotent by default
+ ## Tools  ~ ## Refunds  + tags: idempotency
8c2a1f9 3d ago @maya Add Refunds section to payments rule
+ ## Refunds
ba7e190 2w ago @jules Clarify webhook retry semantics
~ ## Webhook handling
c1d0d22 1mo ago @maya Initial payments rule
+ ## Authorization  + ## Webhook handling
golden-evals / refunds
Claude Sonnet 4.5 · 24 cases · 5.2s
refund full amount, idempotent0.12s
retry on 409 conflict surfaces error0.18s
reject refund without idempotency key0.09s
partial refund splits across captures — regressed from v0.30.21s
20 more passing4.6s
acme / payments-svc
M
maya@acme.dev / engineering
write
J
jules@acme.dev / engineering
write
S
support-team@acme.dev / group · 14
read
C
@oss-contractor / expires 14d
read · scoped
everyone @ acme.dev / org default
read
04 / The shape of it

Built for context,
not for documents.

Generic file-sync misses the point. Contexo understands what a rule, a prompt, a tool scope, and an MCP server are — and treats them like first-class objects with their own diff semantics, eval hooks, and access scopes.

Feature · 01

A semantic diff for your context.

Token-level diffs miss the point — Contexo also surfaces behavioral diffs: what the agent said before, what it says now, on the same eval suite.

a9f1c20 mainproduction
3e88b04
7b1029e prompt/strict-refunds+12 −3
02ac4d1
e4b9d77 exp/voice-tonedraft
Feature · 02

Eval CI, built in.

Define golden cases once. Every push runs them across the models you ship to. Regressions block merge, the way they should.

refunds-golden · 24 cases23 / 24
partial-refund splitsregressed · blocking merge
Feature · 03

Owner and member roles, not group chats.

Every repo has owners and members, tracked in a real access table. Invite a teammate with a shareable key that expires after a week — and an owner can remove anyone's access in a single call.

Y
you
owner
M
maya
member
J
jules
member
Feature · 04

Editor-native, agent-agnostic.

A single .ctx folder feeds Claude Code, Cursor, Windsurf, Zed, and your own scripts. Switch tools without rewriting your prompts.

claude-code cursor windsurf zed mcp/*
Feature · 05

Self-host in an afternoon.

One binary, Postgres, S3-compatible object store. Air-gap clusters supported. Your context never has to leave your VPC.

$ docker compose up
listening on :8443 · ready
05 / Your second brain

Get your own local
knowledge base.

Context-sharing is only half of it. Every session your agents run, Contexo distills into linked, plain-markdown notes — concepts, entities, decisions, dead-ends. Even solo, even if you never share a thing, you walk away with a personal knowledge base of everything your agents figured out. The Karpathy-style append-only brain every engineer wishes they'd kept — except Contexo writes it for you.

drag a node · hover to trace its links
06 / Why Contexo

A 4,000-line CLAUDE.md that everyone edits and no-one owns isn't a knowledge base — it's a liability. Contexo gives agent context the discipline of a repo: history, diffs, review, a single source of truth.

— why we built Contexo

Open
The server and CLI are open source on GitHub — read every line, run your own.
$0
Free to version your own agent context across machines. No credit card.
MCP
Agents read and write context over the Model Context Protocol, natively.
Self-host
One container, your data stays in your VPC. No lock-in.
07 / Pricing

Free for solo,
fair for teams.

Free for small projects on our hosted server. During the beta, just $5/mo per owner (50% off) unlocks unlimited repos and members. Self-host on your own infra for free, forever.

Hacker // solo - small team
$0/mo

Use our online Contexo server for small-to-medium projects — no infra to deploy. Up to 5 repos and up to 3 members per repo.

  • Up to 5 private repos
  • Up to 3 members per repo
  • Hosted on our server
  • Full CLI & dashboard
Go to the app
Org // open source
Self-host/ free forever

Run Contexo on your own infra. The server and CLI are open source — clone the repo, deploy with Docker, never pay a per-seat tax.

  • Self-hosted binary
  • Air-gapped deploys
  • Bring-your-own keys
  • Full source on GitHub
  • Docker compose ready
Go to Github Repo
08 / Frequent questions

The honest FAQ.

Things we wish vendors told us about their tools, but they don't. So we will.

How is this different from just putting CLAUDE.md in git? +

Git versions the file, not the behavior. More bigger the CLAUDE.md more ineffective it is, with contexo the context will be divided into reasonable chunk. Semantic diffs on prompts, scoped sharing across repos, and a single mount that every editor and agent reads from, without you maintaining six different rule files.

Do you store our context on your servers? +

On Team, yes — encrypted at rest with a per-org key. On Org self-host, never; the data stays in your VPC. Either way, your context aren't used to train models. Ever.

What about MCP servers and tool configs? +

First-class. .ctx/mcp/*.json is part of the contexto, we inject the mcp by default to your agent, this mcp basically just a guide for you agentic to use contexo, so if you're not feeling doing manual "git"-like task, just ask your AI Agent. Also will be compatible with major AI Agent provider*"

Can I keep using my existing editor? +

Yes. ctx link writes shims for Claude Code, Cursor, Windsurf, Codex, Continue — they all keep reading their own paths, you stop hand-syncing them.

Is there a real CLI or is this a SaaS console with extra steps? +

Real CLI, written in Go, ships as one binary. The web app is for the extention of feature, just like git and git-hub. Everything you do day-to-day still happens in your terminal, but with the web app, you can check the context more easily

What does "paid-plan" actually for? +

Pretty much to support the Web app, this contexo is personal project of mine, so i need support for you if you're enjoing the web app usage. But no cost for the local cli usage

09 / From the blog

Notes from building it.

Technical writing on version-controlling AI context — architecture, patterns, and the occasional opinion.

View all posts

Give your agent
the same discipline
as your codebase.

Free plan available, and 50% discount on team plan while on beta launch. Takes about as long to install as a fresh git config.

macOS / Linux $ curl -fsSL https://raw.githubusercontent.com/sugihAF/Contexo/main/scripts/install.sh | sh
Windows > iwr -useb https://raw.githubusercontent.com/sugihAF/Contexo/main/scripts/install.ps1 | iex