CTXONE // the agentic system of record

Your agents forget everything. CTXone remembers.

CTXone is the agentic system of record — every agent's thinking, decisions, and sessions, captured. It turns scattered development and agent-session silos into durable institutional memory.

Under the hood it's a self-hosted context engine shared across every AI tool you use — memory that survives sessions, plans that survive plan rot, and provenance for every fact. One hub. MCP-native. Zero telemetry.

Let your agent install it paste a prompt

Set up CTXone for this repository. Run each step below, then report back once CTXone is installed, this repo is indexed, and the MCP server is connected.

1. `brew install ctxone` — install the ctx CLI
2. `ctx agents install --yes` — prime the shared AGENTS.md in the Hub

Optional team layer — also set up AgentStateDeveloper (`asd`): use it for code structure, impact analysis, and change scoping (the `asd` CLI).

Paste into Claude Code, Cursor, Codex, or Gemini and it installs and connects CTXone for you — no CLI needed first. (This is exactly what ctx bootstrap prints once ctx is installed.)

or install directly

$ brew tap agentstatelabs/ctxone && brew install ctxone

Runs on macOS · Apple SiliconmacOS · IntelLinuxWindows

Get started → View on GitHub

65 MCP tools Self-hosted Git-style branches & blame BSL-1.1 → Apache 2.0

ARCHITECTURE //

One system. Four surfaces.

CTXone isn't a library you import — it's a self-hosted system your whole toolchain points at. Install once, and Claude Code, Cursor, VS Code, your chat UI, and your shell all read and write the same graph.

server/

CTXone Hub

MCP server + REST API

One daemon that serves 65 MCP tools, a REST API, and the web UI. Your tools connect to it by URL — no per-tool database, no drift.

engine/

CTXone Engine

the memory + graph core

The AgentStateGraph: a content-addressed graph of facts, decisions, plans, and sessions with branchable history and O(log n) recall.

web/

CTXone Lens

the web UI

A dashboard for what your agents know: browse memory, plans, sessions, history, branches, taint, and diffs — all in the browser.

cli/

CTXone ctx

the command line

Everything the agents can do, you can do from a shell: remember, recall, plan, branch, merge, blame, why-did-we, doctor.

CAPABILITIES //

Six primitives, one graph.

It started as remember / recall / blame. It grew into everything an agent needs to keep its head straight across a long project — exposed identically to your tools (MCP) and to you (the ctx CLI).

MEMORY

A graph, not a prompt dump

Write a fact once; recall ranks by relevance inside a token budget. Pinned facts are always in; primed facts come in when they matter.

ctx remember "SQLite, not Postgres" --importance high
ctx recall "database" --budget 1500

PLANS

The cure for plan rot

Plans are a first-class container of tasks that persist across sessions. Mark tasks done with proof (a commit SHA) so the plan stays anchored to reality.

ctx plan new "auth refactor"
ctx plan next
ctx plan done 3 --proof commit:abc1234

BRANCHES

Memory branches like git

Sandbox speculative context on its own branch, diff it against main, and merge it back when it holds up. Scope any command with --branch.

ctx branch spike/redis
ctx diff main spike/redis
ctx merge spike/redis --into main

PROVENANCE

Every fact has a paper trail

Each commit carries an agent ID, timestamp, intent, and reason. Trace any decision before you reverse it — no more orphaned "who told the model that?"

ctx blame /memory/legal/bsl
ctx why-did-we "use BSL-1.1"

TAINT

Verification gates on writes

Flag paths that need review (taint), block writes entirely (quarantine), or watch for changes. A confidence check decides whether an agent may write.

ctx taint list --kind quarantine
ctx taint check /memory/prod/config

ACCOUNTING

Savings you can prove

Every recall reports tokens sent vs the flat-memory baseline. Session metrics parse your Claude Code transcripts for real token, cost, and cache data.

ctx stats
ctx session metrics --all

PAIRS WITH // AgentStateDeveloper

Memory is half of context. Here's the other half.

CTXone remembers what your team decided. AgentStateDeveloper knows what your code does — symbols, call graphs, effects, and ledger decisions. Wire ASD into the same Hub and your agents get both halves through one connection.

An agent that can recall a frozen decision and check callers_of before it edits is an agent that works like someone who already knows the codebase. Setup is one flag — ctx bootstrap even offers to install ASD for you.

See the use case → Integration guide

+4 code-intelligence tools served next to memory, over MCP

code_search Find the symbol behind a concept
code_read Signature, effects, ledger decisions
callers_of Blast radius before you edit
callees_of What a symbol depends on

Three flavors of context anxiety.

Everyone using AI coding tools feels all three, even if they've never named them. CTXone's three pillars map one-to-one to the three versions of the pain.

01 // STATEFUL

Yesterday's context is gone.

You told Claude on Tuesday that you're using SQLite, not Postgres, and why. Wednesday morning you open a new chat and it's asking about your "Postgres schema" again. You paste the same paragraph. You budget tokens for memory the model should already have.

CTXone remembers. Every fact survives sessions, branches, and tool switches because it's stored in a local graph, not in the model's context window.

02 // SHARABLE

Your teammate is flying blind.

You primed your Cursor install with the team's architectural decisions. Priya didn't. Now she's arguing with the model about whether to use Redis for the job queue — a question you settled three months ago in Slack and she never saw.

CTXone is shared. The graph is a file. Commit it, sync it, mount it over the team's lab network. Whatever you primed is what everyone else sees.

03 // INSPECTABLE

Who told the model that?

You open a file Claude edited last week and there's a comment about "the new API versioning policy." You don't remember a policy. Nobody on the team remembers a policy. Did the model hallucinate it? Did you mention it once in a side chat? Nobody can check. The decision is orphaned.

CTXone is accountable. Every commit carries an agent ID, a timestamp, an intent, and reasoning. ctx blame shows you exactly who wrote what, when, and why — git-style.

Read the full context anxiety argument →

LIVE // ctx_savings_ratio

5× on day one. More as your graph grows.

Every recall response includes a _ctxone_stats field showing exactly how many tokens you sent vs how many you would have sent if the model had seen the full memory graph. This isn't marketing — it's the live delta the Hub computes on every request.

Flat memory

What the model sees without CTXone

1,500 tokens

Every session, every time

→

CTXone recall

What the model sees with CTXone

300 tokens

Topic-matched + pinned

5× savings ratio (day one)

Shown: a fresh graph with a few dozen facts. As you write more, recall stays the same size but the baseline grows — the ratio climbs to 10×, 20×, and higher on graphs that have been lived in for a week or more. Start at 5×, discover the rest. See the math →

Works with the tools you already use

CTXone exposes MCP for AI coding tools, native plugins for chat UIs, and direct client libraries for everything else. ctx init auto-detects and wires them in one command — all pointed at one self-hosted hub that serves MCP, a REST API, and a web UI.

EDITIONS //

Start free. Scale when your team does.

The same engine runs at every tier — Team and Enterprise add shared hubs, identity, and governance on top of the open core. No feature is held hostage; the paid tiers are about running CTXone for many people, not unlocking the product.

OSS

Free · self-hosted

The whole engine, on your machine. No account, no telemetry.

All 65 MCP tools + REST API + Lens UI
Memory, plans, branches, taint, provenance
Single-user hub on your laptop or a box you own
SQLite or Postgres storage
Source-available (BSL-1.1 → Apache-2.0)

Install now →

Most teams start here

Team

For shared graphs

One hub your whole team points at, so context is shared by default.

Everything in OSS
Shared team Hub with per-user identity
Branch workflows across contributors
Provenance attributed to real users
Priority support

Learn more →

Enterprise

For regulated scale

Multi-tenant, governed, and auditable for org-wide agent deployments.

Everything in Team
Multi-tenancy + RBAC
SSO / SAML
Audit bundles & policy governance
Data residency & compliance support (HIPAA, SOC 2, GDPR)
Direct founder access & roadmap influence