Install it, then every command

Install

Three steps: once per machine, then once per repository. After that, Claude Code records the work by itself.

1. Install the command line

   npm i -g @ambih/coding-agent-memory Copy

   Installs the central command, the MCP server your agents talk to, and the local dashboard, all on this machine. It needs Node.js 22 or newer.

2. Register a repository

   central init Copy

   Run it inside a repository. It asks a few questions, each with an answer already chosen, so you can press Enter through them: the project's name, which coding agents to connect (the ones you use are already ticked), and where their settings go. On this machine, the default, nothing is written into the repository; in the repository, it can keep its files out of git. It then lists the files it would change and asks once. The project is keyed by its git remote, so a moved or re-cloned folder keeps its history.

3. Connect your AI assistant

   { "mcpServers": { "central": { "command": "central-mcp" } } } Copy

   central init already does this for the agents you tick. To do it by hand, add this to your agent's MCP configuration, or run central agent cursor (or codex, vscode, gemini, windsurf) to print the exact setup. The Your agent tab has the text to paste.

Your agent

Central works with Claude Code, Codex, Cursor, VS Code with GitHub Copilot, Gemini CLI and Windsurf. What it records by itself depends on the agent.

Claude Code and Codex have hooks: small commands the agent runs after each step, which tell Central what happened. The other four have no hooks Central can use yet, so for them Central only knows what the agent sends. Everything an agent writes is labelled as the agent's until you confirm it.

The text to give your agent

central init writes these lines for you. If you set up an agent by hand, paste them into the file it reads at the start of a session (AGENTS.md, a Cursor rule, GEMINI.md, and so on). Claude Code and Gemini CLI get them from Central's server and need nothing. They stay in English: the agent reads them.

Central holds this project's history: rules, decisions, follow-ups, plans, tasks.
Before editing a file, call get_context with its path and follow the rules it returns.
Record decisions, rules and work for later with propose_record, not only in your own memory: the team reads Central.
For work with several steps, track them with your task list tool.
In a plan, list bugs you will not fix under a "Noticed, not fixed" heading; Central records those itself.
Add a "Map" heading too: "- Module: `path`, `path`" lines, and "`a` → `b`" for links to new files.

The agent also needs the MCP server, central-mcp (the Install tab's third step). Windsurf keeps its MCP servers per user, not per project: add it once in Windsurf's settings, under MCP.

Dashboard and checks

Once it is installed: open the dashboard, and check the setup when something seems off.

• central dashboard Copy

  Opens the dashboard in your browser, served from your own machine. The home page shows what waits for you across every project; each project has its plans with a board of their tasks, its timeline, its rules, and a page to confirm what agents wrote.

• central doctor Copy

  Checks that this machine can run Central: Node, git, the local database, free disk space, and whether Claude Code's hooks are installed and trusted in this folder. Each problem comes with its fix, and it changes nothing.

See the history

Read what was recorded: every record, the plans agents made, what they noticed, and what an agent is told before it edits a file.

• central log Copy

  Every record of the project, newest first: intents, decisions, rules, rollbacks, ideas, follow-ups and tasks, each with its status and who wrote it.

• central show <id> Copy

  One record in full: its fields, the files and folders it is anchored to, its links to other records, and who wrote or confirmed it.

• central plan list Copy

  The plans agents made in this project, with how many of their tasks are closed.

• central plan show <id> Copy

  One plan as a board in words: each step it predicted, the task that step became, where that task stands, and the tasks added along the way.

• central later Copy

  Follow-ups: what an agent noticed and did not fix, oldest first so nothing quietly ages. Past 30 days an open one is marked stale.

• central context src/app.ts Copy

  Exactly what an agent receives before it edits that file: the rules that apply first, then the decisions and rollbacks behind it, cut to a small token budget.

• central context --query "login" Copy

  Searches the history by words, wherever a record is anchored. Every word must match, so typing more narrows the answer.

Confirm

Everything an agent writes is labelled unconfirmed until a person looks at it. These commands are how you do, and they need a person at a real terminal.

• central review Copy

  What agents wrote that no person has confirmed yet. Until then it is labelled unconfirmed everywhere, and an unconfirmed "must" rule reaches other agents only as "prefer".

• central review -i Copy

  Goes through that list one item at a time, showing each exactly as it was written, and asks you to confirm, reject or skip it.

• central approve <id> Copy

  Confirms one item, or several ids at once. It refuses to run from an agent's shell: confirming is a person's job.

• central reject <id> --reason "..." Copy

  Rejects it, with an optional reason of up to 280 characters. The agent session that wrote it hears your decision and the reason on its next call.

Tasks and follow-ups

Move work along by hand, the same moves the board on the dashboard makes.

• central start <task id> Copy

  Marks a task as yours and moves it to Doing. Another agent sees who is on it and picks a different task.

• central stop <task id> Copy

  Puts the task back in Open without finishing it.

• central done <id> Copy

  Marks a task, a follow-up or any record as done. It stays in the history, and agents still see it, marked done.

• central reopen <id> Copy

  Takes a done mark back when the work was not finished after all.

• central drop <id> Copy

  Closes a follow-up or a task you decided not to do. Dropped is a decision, not a failure, and it stays visible as one.

Write it yourself

Most records come from your agent. When you want to write one yourself, a person's record counts as confirmed from the start.

• central add rule "No direct payment calls" --severity must --text "Go through checkout.service" Copy

  Writes a rule. A "must" rule written by a person reaches every agent as "must". The other kinds work the same way: intent, decision, rollback, idea and followup.

• central add decision "Three checkout steps" --set context="60% abandonment" --text "Cart, address, payment" Copy

  A decision needs its context and its choice. --set fills any field by name, --text fills the main one.

• central supersede <id> --text "..." Copy

  Records are never edited in place: this writes a new version, and the old one stays in the history.

• central link <from id> derived_from <to id> Copy

  Links two records: derived_from, implements, reverts, replaces, learned_from or relates_to. A link that would make a loop is refused.

• central trace <id> Copy

  Where a record came from and what it led to, following its links both ways.

• central feature add Checkout --path src/checkout Copy

  Names a part of your code. Records anchored to its folders, or tagged with it, show on its page in the dashboard.

• central session add "Checkout brainstorm" --at "2026-10-02 14:00" Copy

  Records a brainstorm or a meeting, at your local time. Plans and records that came out of it can be attached to it.

Sync (Pro and Team)

Keep the same history on all your machines, or share a project with your team. Needs Pro, or a seat on a Team.

• central login https://central.ambih.com Copy

  Signs this machine in with your ambih.com account, in your browser.

• central sync --on Copy

  Run it in a project: it asks you to confirm, sends the project's whole history, then keeps it in step. Add --team <name> to share it with a team.

• central sync Copy

  One round now: send what is new here, then fetch what others pushed. It also runs by itself after every change.

• central sync --status Copy

  What is waiting to be sent, when the last sync happened, and anything the server refused.

Other agents and more

Set up another coding agent, change who sees unconfirmed writes, and the housekeeping commands.

• central agent cursor Copy

  Prints the setup for one agent (cursor, codex, vscode, gemini, windsurf): the MCP server's configuration and the short instruction to put in AGENTS.md. Add --write to have Central write it, --write --user for this machine's own settings.

• central policy required Copy

  Agents' writes stay hidden from other agents until a person confirms them. central policy open goes back to the default, where they are visible and labelled unconfirmed.

• central stop-server Copy

  Stops the background server. You rarely need it: it stops by itself after 30 minutes with no client.

• central tidy on Copy

  Lets a small model (Haiku, through your own Claude Code) give tasks a clearer name and a one-line description in the background after a turn. It reads the start of the changed files and uses a little of your Claude usage, so it is off until you turn it on. central tidy off stops it.

• central uninstall Copy

  Finds Central's setup for this project, in the repository and in this machine's settings, and takes out what you tick. Your own settings stay. It then asks whether to forget the project too.

• central remove --yes Copy

  Deletes this project's history on this machine, with its automatic backups. It is the only command that deletes history.

• central --help Copy

  Lists every command. central <command> --help gives the options of one.