Your AGENTS.md,
except it writes itself.

Today, what your team shares is hand-written, and what your agent learns is stuck on one laptop. keepctx joins them: context captured as your agent works, kept current, and shared with everyone.

Stop re-explaining the same thing

You told it three times that you use Kinesis, not Kafka. It still guesses Kafka. The fix isn't a bigger context window — it's writing things down once, in a place the next session reads automatically.

Corrections stick

When you correct your agent, it records the correction. The next session — yours or a teammate's — starts already knowing.

~1,200 tokens, not 50,000

Preloading a company's knowledge every session is about 95% waste. ctx loads a small index and fetches a context only when the task touches it.

Onboarding on day one

A new hire clones the repo and their agent already knows the deploy command, the real index name, and which docs are lying.

Nothing gets wrecked

Every change is versioned server-side and one revert away. A weak model can add noise; it can't destroy what your team already established.

Never in your git history

.ctx/ ignores itself, so context never pollutes diffs and never goes stale on a branch. Your AGENTS.md gets two lines and nothing else.

Plain markdown, open source

Facts are readable text. Run our server or your own. Uninstalling is deleting two lines from a file.

How it works

A context is a list of facts. The bolded lead is the key, and the value can be an IP, a command, or a sentence.

# .ctx/ace/facts.md

- **deploy.command** — `make ship` from the repo root, not the CF CLI
- **splunk.index** — `ace_prod_v2`. The docs still say ace-prod; they're wrong. `[verified]`
- **spacaptive.depends-on** → idcmt, for session validation
- **event.transport** — Kinesis, not Kafka. Inherited, and we're not changing it. `[verified]`

Reads and writes are just files

Your agent opens facts.md with the same tools it uses for any other file, and edits it as it learns. There's no write command to forget and no ceremony to skip — which is exactly why capture actually happens.

Conflicts resolve without anyone arbitrating

Changes sync per key, not per file. Two people learning different things both land. Two people changing the same fact means the later one wins, and every version is kept — so a bad change is one revert away rather than an argument.

SyntaxMeans
— valuean attribute
→ valuea relationship — what your architecture diagram is drawn from
[verified]a human settled it; stop re-deriving it

Quickstart

Two minutes to local. An account only matters when you want to share.

  1. Install

    Python 3.9 or newer. No dependencies. Installs as ctx, with keepctx as a second name in case another ctx is already on your PATH.

    curl -fsSL https://keepctx.com/install.sh | sh
  2. Set up in your project

    Creates .ctx/, adds two lines to AGENTS.md, and ignores itself in git. The name defaults to your directory.

    cd ~/work/ace
    ctx init
    
    ctx: initialised `ace`
      .ctx/ace/facts.md      your facts
      .ctx/instructions.md   how the agent maintains them
      AGENTS.md              pointer added at the top
  3. Work

    Your agent reads .ctx/instructions.md, learns the rules, and starts recording what matters — corrections, hard-won findings, decisions. Nothing else to do.

  4. Share it, when you want to

    Local works forever with no account. ctx remote puts it on a server so your team gets it — and so it survives a dead laptop.

    ctx remote          # one time, creates it on the server
    ctx sync            # two-way. mostly automatic after this
  5. Your teammates

    ctx clone sentity:ace

The commands, all of them

ctxstatus
ctx init [name]set up here. local, no account, no network
ctx remoteone-time. create this context on a server
ctx clone org:nameget a context you don't have
ctx syncupload local changes, download remote ones