Other coding agents

Claude Code, Codex, opencode and the Claude Desktop app can use Monixcode's project memory. They get what Monixcode knows about the repository as context, can search it, and can propose new facts — which wait at your gate like any other.

What they get

Knowledge at the start of a session — the same overview of rules and areas Monixcode's own agent starts with.
Search — tools to look up facts, read one in full with its proofs, and follow its connections.
Proposing — the agent can stage a durable fact. It never goes in directly: it waits in /pending, marked with the agent it came from.
Learning from the session (optional, off by default) — after each finished turn of the agent, Monixcode reads what happened and proposes what is worth keeping, the same way it does after its own missions. Only the new turns are taken each time. The session also shows up in Monixcode's session list, so you can see the work.

Nothing an external agent sends is applied on its own. Every proposal waits for you.

Connect an agent

Monixcode has to know the repository first: open it in Monixcode once, so it is a project. Then, in a terminal:

monixcode integrate claude     # Claude Code
monixcode integrate codex      # Codex CLI
monixcode integrate opencode   # opencode
monixcode integrate claude-desktop   # the Claude Desktop app
monixcode integrate status     # what is connected on this machine, and what agents may do in each project

Each one writes the other tool's configuration so that it starts Monixcode's memory server by itself. There is no token to copy and nothing to start by hand: the external agent launches monixcode mcp when it needs it, and that finds the Monixcode server running on your machine — or starts one.

Option	What it does
`--dry-run`	Show what would change, change nothing.
`--uninstall`	Remove only Monixcode's entries again.
`--bin <path>`	Pin the `monixcode` program the configuration calls.
`--curator`	Also add the second server with the curator tools. See Letting an agent curate.
`--no-install`	Claude Code only: write the plugin files but do not run the `claude plugin` commands; the installer prints them instead.
`--dir <path>`	Claude Code only: write the plugin files to this folder instead of the default one under Monixcode's folder.
`--config <file>`	Claude Desktop only: write to this configuration file instead of the app's own.

Every file that is changed is backed up next to itself first, and running the same command twice changes nothing the second time.

Agent	Good to know
Claude Code	Installed as a plugin named monixcode. It adds a monixcode-memory skill and a `/monixcode-harvest` command to hand the session to Monixcode by hand. With `--curator` a second plugin, monixcode-curator, is installed as well — switched off until you enable it (see below). Without the `claude` program on the PATH the installer prints the two `/plugin` commands to run by hand.
Codex	Codex asks you to trust new hooks once: start `codex` and open `/hooks`.
opencode	Installed as a plugin; your own opencode configuration file is not rewritten.
Claude Desktop	Adds Monixcode to the app's MCP servers and leaves the rest of its settings alone. The app does not see your shell's PATH, so the entry needs the full path of the `monixcode` program — pass `--bin` if the installer cannot find it. Restart the app afterwards. For the app's Code tab, run `monixcode integrate claude` as well — that tab is Claude Code.

Claude Desktop chats

A chat in Claude Desktop does not run in a folder and has no hooks, so it works a little differently from a terminal agent:

It asks for the knowledge itself. Monixcode tells the model to load the project's rules and areas at the start of every conversation.
It picks from the projects you allowed. With one allowed project, chats use that one. With several, name the project in the chat; the model can list the allowed ones. Projects that are off are never shown, not even by name.
It hands work back only when asked. Ask it to hand the conversation to Monixcode; what Monixcode learns waits at your gate.

Allow a project

Connecting an agent gives it nothing yet. What it may do is set in Monixcode, per project: press x in the project or session list, or open /config ▸ General ▸ External agents (also in the web settings). Each project cycles through four states with Space:

State	What the external agent may do
off	Nothing. The default.
read	Get Monixcode's knowledge as context and search it.
read + propose	Also stage facts and hand sessions over — for your approval, never directly.
read + propose + curator	Also curate, in sessions that use the curator server (see below). Stays on until you lower it.

Why only in Monixcode. There is deliberately no command for this. An external agent can run commands in your terminal — if a command could grant access, the agent could grant it to itself. Which project a session belongs to is still found from the folder it runs in; it only gets anything if that project is allowed here. Outside any project folder — and always in Claude Desktop — only the projects allowed here can be chosen.

What the agent can do

The memory server, monixcode, offers 15 tools. The list never changes; a tool the project's level does not allow answers with the reason instead of disappearing. Every tool also accepts project (a name or an id) or project_id, for when the agent runs outside a project folder. A parameter in bold is required.

Tool	Level	Parameters	What it does
`monixcode_projects`	any	none	Lists the projects you opened to external agents, with the level of each — and nothing about the others.
`pum_bundle`	read	`task`, `areas` (list of topics)	The knowledge block Monixcode's own agent starts a mission with: the absolute rules and what knowledge exists. `task` adds what is relevant to it, `areas` limits it to those topics. Call it at the start of non-trivial work unless it was injected already.
`pum_search`	read	query	Search the memory in natural language: decisions, rules, gotchas and invariants, with ids and weights. A weight below 0.8 is a hypothesis; verify it.
`pum_node`	read	id	One fact in full: statement, proofs and code pointer.
`pum_relations`	read	id	What a fact is connected to. Check it before changing something the fact covers.
`pum_query`	read	action (`search`, `node`, `relations`, `conflicts`, `pending`, `proofs`, `grep`), `query`, `id`	The low-level read. It also lists open conflicts, what is pending and proofs nobody judged, and `grep` searches ids, statements and topics with a regular expression.
`pum_rules_for`	read	path (a file, folder or glob)	Before an edit: the rules, decisions and gotchas tied to that path, for example `src/billing/` or `src/*/.sql`.
`search_history`	read	query, `include_cross_project`	Case-insensitive search over this project's past sessions and missions. Other projects are included only if you allowed them for external agents too.
`pum_remember`	propose	statement (one self-contained sentence), `topics` (one to three tags), `code_ref` (`path[:line]`)	Stages one durable fact: a decision with its reason, a gotcha, an invariant, a convention. It waits in `/pending`; it is not stored until you approve it. Not for progress notes.
`pum_add_proof`	propose	node_id, text, file, `line`, `commit`, `kind`	Proposes evidence for a fact: where the code shows it. The kinds are `code_implementation`, `code_invariant`, `test_passes`, `type_check_passes`, `benchmark_passes`, `logical_deduction`, `metric_observed`, `doc_references` and `git_blame`.
`pum_report_conflict`	propose	node_id, reason, `contradicts` (another fact's id), `file`, `line`, `commit`, `kind`	Reports a fact the code contradicts, with the reason and where. The kinds are `user_reported_bug`, `test_fails`, `runtime_crash`, `type_check_fails`, `metric_violation`, `benchmark_fails` and `security_audit_fails`.
`pum_mark_outdated`	propose	node_id, reason, `file`, `commit`, `superseded_by`	Flags a fact for a recheck after a code change. You retire it or keep it.
`pum_finish`	propose	summary, `touched_files`, `transcript_path`	Ends a unit of work and hands it to Monixcode, which distils what is worth keeping into the gate. Call it as the last step of substantial work. It is safe to call more than once and together with the session hooks: each turn is taken once. The transcript is found by itself for Claude Code and Codex.
`harvest_next`	propose	none	Takes the next open harvest job — only when the project has the external agent harvest its own sessions (see Who harvests its sessions). It returns the transcript excerpt and the project knowledge.
`harvest_done`	propose	job_id, summary	Reports the job finished, with what the agent proposed and what it left out. Monixcode shows it in that session's harvest session.

The levels are the ones you set per project: read for the searching tools, propose for the tools that stage something. Everything staged waits in /pending, marked with the agent it came from. The evidence kinds that mean “the user says so” are not offered to an agent: only you can assert that.

Older names still work. Allow lists and skill texts written for earlier versions keep working: the two old tool names map to pum_bundle and pum_finish. monixcode integrate writes the current names.

Letting an agent curate

An agent you trust can also curate the project memory, exactly like Monixcode's own curator: decide pending proposals, resolve conflicts, judge evidence, edit, rename, retire and connect facts, choose the folders that feed the memory, and approve team reviews. Every one of those is filed as a request in the same queue as the curator's own (Curator requests), marked “from <agent> (external)”. Nothing changes until you approve it. The agent sees your decision, and your reason for a rejection, with curator_requests. The curator is a second server, added with --curator. It has all 15 tools above plus 14 curator tools, so a session that uses it needs nothing else:

monixcode integrate claude --curator

Tool	Parameters	Files a request to …
`curator_status`	none	(reads) whether curator rights are on for the project.
`curator_requests`	none	(reads) show the agent's own requests and what you decided, with your reason for a rejection. Check it before filing something again.
`curator_decide`	pending_id, decision (`approve` or `reject`), reason, `evidence`	approve or reject a pending proposal (its number from the pending list).
`curator_judge_proof`	proof_id, judgement (`vouched`, `refuted`, `irrelevant`), `reason`, `evidence`	give a verdict on a proof. A refutation should name the counter-case.
`curator_resolve_conflict`	conflict_id, resolution (`keep_a`, `keep_b`, `dismiss`), reason, `proof_text`, `proof_ref`, `proof_kind`	resolve an open conflict. Keeping one side needs refuting evidence against the other.
`curator_add_node`	statement, reason, `topics`, `code_ref`	add a new fact.
`curator_edit_node`	node_id, statement, `reason`, `evidence`	reword a fact.
`curator_rename_node`	node_id, new_id, `keep_connections` (default yes), `reason`	rename a fact; its connections and proofs move along unless you say otherwise.
`curator_delete_node`	node_id, reason, `superseded_by`	retire a fact, optionally naming the fact that replaces it.
`curator_add_edge`	from_node, to_node, semantic_type (`CAUSAL`, `TEMPORAL`, `CONTRAST`, `LOGICAL`, `EVIDENTIAL`, `EVALUATIVE`, `CONSTITUTIVE`), `explanation`, `reason`	connect two facts.
`curator_delete_edge`	edge_id, reason	remove a connection.
`curator_set_folders`	folders (empty means the whole project), `reason`	choose the folders that feed the memory.
`curator_reviews`	none	(reads) list the open team reviews. Only on a team Source, or as a Member with the reviewer role.
`curator_approve_review`	review_id, head_sha	approve a team review at the version you looked at.

Two things decide whether an agent may curate:

Which server the session uses. You pick that in the agent, per session. After --curator, normal sessions still get only the normal server:
- Claude Code: /plugin, enable monixcode-curator and disable the plain monixcode plugin
- Codex: codex -c mcp_servers.monixcode-curator.enabled=true -c mcp_servers.monixcode.enabled=false
- opencode: opencode --agent monixcode-curator, or switch to that agent with Tab
- Claude Desktop: turn monixcode-curator on in the chat's tools menu, and monixcode off
The project's level. An agent can edit its own settings, so the curator tools also need the project set to read + propose + curator in Monixcode. Otherwise every curator tool tells the agent that curator rights are off for this project and that you enable them in Monixcode (External agents).

Rule	Why
Only you can raise the level	The agent has no tool for it, and Monixcode refuses a raise that comes from the agent or from a program it started. Lowering is open to anyone.
Nothing happens without you	Every change is a request that you approve or reject in `/requests` or in the browser. The project level only decides whether the agent may file requests at all.
Everything is logged	Every request and every approved change is recorded with the agent's name. Changes to the memory are undone with the normal undo.

Who harvests its sessions

When Monixcode gets a finished session from Claude Code, Codex or opencode, it shows up in Monixcode with its own harvest session (↳ harvest under it). The project setting Harvested by (/config ▸ General) decides who does the work:

Harvested by	What happens
Monixcode's curator	Monixcode's curator harvests it, visibly, and you can talk to it in Monixcode like for any other session.
the agent itself	The external agent takes the job with the `harvest_next` tool, analyses it with its own model, proposes through the usual tools and closes it with `harvest_done`. Monixcode mirrors the progress, marked “run by” the agent; you talk to it in its own tool. Switching to this is up to you, never to an agent.

Either way, what comes out of an external session waits for your click and is never applied automatically.

Options

The first two are also switches per project, in Monixcode under /config ▸ Project (Harvest external sessions and Context on external prompts, both off by default). The environment variable of the external agent wins over the switch in both directions: 1 forces it on, 0 forces it off. The harvest also needs at least read + propose for the project.

Variable	What it does
`MONIXCODE_HARVEST=1`	Hand each finished turn to Monixcode, so it can learn from it. Off by default.
`MONIXCODE_PROMPT_CONTEXT=1`	With every prompt of 12 or more characters, add the knowledge most relevant to it. Claude Code and Codex.
`MONIXCODE_PROJECT_ID=<id>`	Name the project instead of finding it from the folder.
`MONIXCODE_NO_AUTOSTART=1`	Never start a Monixcode server from the external agent; only use one that is already running.
`MONIXCODE_HOOK_DEBUG=1`	Print errors instead of staying silent.

The project is found from the working directory: the longest matching project folder wins, and a git worktree counts as its main checkout. Where there is no such folder, the project is chosen among those you allowed, as in Claude Desktop.