Hello, Contexo: version control for the context your agents run on

You know the moment. Fresh Claude Code session, first message of the day — and the agent asks you to explain the auth flow. Again. The same auth flow you walked it through yesterday. And last Tuesday.

So you paste the same context, re-describe the same architecture, re-warn it about the same gotcha — and then you get to do actual work.

That’s the context tax. You pay it every single session — and it’s both the reason we built Contexo and the reason we’re starting this blog.

Why your AI keeps forgetting

AI coding agents are brilliant in the moment and amnesiac between sessions. Every conversation starts from zero. And whatever your agent figures out along the way — why you picked Postgres over Mongo, the one endpoint that breaks without a feature flag, how your billing webhook actually works — vanishes the second you close the tab.

Multiply that across a team and it gets sillier. Your agent spent an afternoon learning your payments module. Your teammate’s agent has no idea any of that happened. Same codebase, same questions, zero shared memory.

The knowledge is being created. It’s just being thrown away.

Your AI context is code now

Here’s the shift everything else hangs off of. A year ago, the “context” you gave an AI was a paragraph you retyped into a chat box. Today it’s a sprawl: system prompts, project rules, CLAUDE.md, tool definitions, MCP server configs — plus everything your agent learns about your project as it works. Your agent reads all of it on every run.

That sprawl has every property of source code:

• It ships features — a sharper rule or a captured gotcha makes the agent measurably better.
• It breaks builds — one careless edit and the agent starts doing the wrong thing.
• It drifts — the moment two engineers tweak their own copies, you have three truths.

So why is it living in scattered dotfiles and disposable chat histories, with no history and no review?

So what is Contexo?

The shortest way to put it: Contexo is GitHub for AI context.

It captures what your agents learn about a project — the decisions, the gotchas, the why — and keeps it as a shared, versioned knowledge base that any agent can read and write. Push what you learned. Pull what the team knows. Your AI starts every session already up to speed, working from the same source of truth as everyone else’s.

How it works

You don’t write this documentation by hand. Your agent does it as a side effect of helping you. And if you know git, you already know the shape of it:

ctx init      # start versioning this project's context (once)
ctx push      # save what your agent learned — like git push, for context
ctx pull      # any agent pulls it back and starts already knowing the project

The part that feels like magic: your agent runs these itself. Contexo ships an MCP server — MCP being the standard way AI tools connect to outside services — so the model does the bookkeeping in its own turn. You stay in your editor; the knowledge base fills itself in.

And because every change is versioned, your context has history. You can see what changed, when, and why — and review it the way you’d review a pull request. It’s context you can trust, not a black box.

What it looks like in practice

Tomorrow-you stops starting over. Close your laptop today, open a fresh session tomorrow, and your agent pulls the project context before you type a word. No re-explaining the auth flow. Ever.

Your teammate’s agent inherits what yours learned. You spent a week teaching your agent the payments module. When Sarah opens her own session, her agent pulls the same context and is productive in seconds — not next week.

The same bug doesn’t bite twice. That gotcha — “don’t call this endpoint without the feature flag” — gets captured once. No future agent rediscovers it the hard way.

Why it’s worth it

• Stop paying the context tax. Re-explaining the codebase every session is dead time. Contexo gives it back.
• Your team’s agents stay in sync. Shared context means consistent answers — not five agents inventing five versions of how your app works.
• Knowledge compounds instead of evaporating. Every session adds to a base that sticks around, even when people leave.
• It fits what you already use. Claude Code, Cursor, any MCP-compatible agent. No new editor, no new workflow.

What we’ll write about here

This blog is where we’ll dig into the technical guts of the project — how the CLI is built, why the server is git-backed, what the MCP handshake actually does, and the design calls we made along the way. Some of it will be deep; some of it will just be us thinking out loud. A few posts already in the drafts:

• How the push handshake works — why the CLI has no LLM dependency, yet still produces clean, distilled context pages.
• Section-aware diffs — diffing prompts is not the same as diffing code, and here’s what we had to change.
• Self-hosting Contexo — the whole thing in your own VPC, one binary and a volume.

Try it

Contexo is open source and free to start. Point it at a project:

ctx init

…and let your agents start remembering. Sign up free at contexo.live, or star the repo on GitHub if you want to follow along.

Stop paying the context tax. Give your agents a memory worth keeping — see you in the next post.