MCP tools

All 35 tools below are callable by any MCP client connected to https://innernet.live/api/mcp (JSON-RPC 2.0, Authorization: Bearer <token>). Most users never call them directly — the AI client wraps them.

They live in one place: lib/mcp/registry.ts holds every tool's description, schema and handler, and the parity test fails if one of them lacks a REST twin. What you read here is what the server serves.

Every one of them has a REST twin. The two doors run the same handlers against the same memory — see the parity table on the API page, or GET /api/v1 for the machine-readable version. Use MCP if you are an AI client with a connector; use the REST API if you are an agent or a script.

retrieval — start here#

tool	what it does
`innernet_context`	The one door. Pass the user's ask as `intent` and innernet compiles a budgeted slice instead of the whole cabinet: SPINE (identity, core, what moved lately, `as_of`), FOCUS (the sections that match, in full), PERIPHERY (a one-line index of everything else, with how to expand it), and `retrieval_advice` — what to read next if the conversation turns.
`innernet_session`	What innernet has made of this conversation so far — the chapter, the map it is working against, what it kept, what is set aside.

context maps#

tool	what it does
`innernet_list_projects`	List your context maps — slug, name, type, tagline, last update. Plus memories other people have shared into your rooms.
`innernet_load_project`	Open a map. Lean by default (a line per dimension); `full:true` for every body. Carries the capture protocol and a disclosure-gated slice of your Self Map.
`innernet_save_context`	Create/update a project. Upserts dimensions and nodes by name — merge, never wipe.
`innernet_get_dimension`	Read one dimension's markdown without loading the whole map.
`innernet_get_capture_protocol`	Read the per-project capture instructions.
`innernet_set_capture_protocol`	Replace the capture protocol (owner only).

branches — versioned, forkable context#

tool	what it does
`innernet_list_branches`	A project's branches with status and fork-from commits.
`innernet_branch_new`	Fork the map at its head — the branch gets a full overlay snapshot of dimensions + nodes.
`innernet_branch_diff`	Added / modified / removed / unchanged, branch vs trunk.
`innernet_branch_park`	Archive without merging (overlay preserved); `park: false` revives.
`innernet_branch_merge`	Fold the branch into trunk (branch wins), record a merge commit, bump the head.

capture & search#

tool	what it does
`innernet_capture`	Capture a note/decision/insight. Without `project_slug` the Concierge auto-routes it (project, Personal Memory, both, or discard) — and the raw content is persisted before any routing, so a routing failure can never lose it.
`search`	Ranked full-text search across dimensions, nodes, captures, projects, and memories. (Also drives ChatGPT Deep Research.)
`fetch`	A project's full content as one markdown blob (ChatGPT Deep Research).

personal memory — the Self Map#

tool	what it does
`innernet_self_capture`	Save a fact-candidate about you to the cloud Self queue.
`innernet_self_status`	Counts: facts, pending candidates, open questions, by dimension/disclosure.
`innernet_self_facts`	Read facts up to a disclosure ceiling (`private` never crosses MCP).
`innernet_self_sync`	Run the consolidator over pending candidates now.
`innernet_triage`	Ask the Concierge where a piece of content belongs without committing (or commit with `commit: true`).

tasks#

tool	what it does
`innernet_task_list`	The project's ordered task board.
`innernet_task_create`	Add a task.
`innernet_task_update`	Update fields/status.
`innernet_task_complete`	Mark done.
`innernet_task_reorder`	Reorder the board.

artifacts — live documents#

tool	what it does
`innernet_artifact_start`	Open a living document for a research/build session.
`innernet_artifact_append`	Land a raw fragment (fast). The fold into the document runs server-side after the response.
`innernet_artifact_status`	Active artifact + pending fragment count.
`innernet_artifact_read`	Read the current document.
`innernet_artifact_list`	All artifacts in a project.
`innernet_artifact_stop`	Final fold, then mark done.

handoff — where you left off#

tool	what it does
`innernet_handoff_read`	The note the last session left for this one — pass `history:true` for the trail behind it.
`innernet_handoff_write`	Leave that note for whoever comes next. Every write is kept, so nothing is overwritten away.

ambient#

tool	what it does
`innernet_ambient`	The off-switch (and tuning surface) for ambient behaviour — session recognition, auto-artifacts, task nudges.

protocol#

innernet speaks MCP 2026-07-28 — the stateless revision — and every revision before it, so nothing you have connected today needs to change.

No handshake required. Call server/discover (it needs no token — you should be able to learn how to talk to us before you sign in), or skip it and put io.modelcontextprotocol/protocolVersion in each request's _meta. initialize still works for clients that haven't migrated.
Revisions: 2026-07-28 · 2025-11-25 · 2025-06-18 · 2025-03-26 · 2024-11-05.
Resources: innernet://project/{slug}/map (JSON) and innernet://project/{slug}/dimension/{name} (markdown), listed via resources/list.
Caching: every list and read result carries ttlMs and cacheScope. Honour them — a context map that hasn't changed shouldn't be paid for twice.
JSON-RPC batch requests accepted. Rate limit 240 calls/min/account.
Prefer the REST API for scripted access — that's what it's for. MCP is for AI clients.

extensions#

extension	what you get
`io.modelcontextprotocol/ui`	Interactive views rendered inline in the conversation — one live innernet window rather than a stack of panels.
`io.modelcontextprotocol/tasks`	Long work returns a durable handle instead of a wait. Declare it in your `_meta` capabilities and `innernet_self_sync` answers with a `taskId` you poll via `tasks/get`.

A fold can ask you something. If your client also declares elicitation, a sync task may pause at input_required carrying one question the Concierge couldn't resolve on its own — who someone is to you, whether something is a standing preference. Answer it with tasks/update and it is never asked again. One question, at the moment innernet is already thinking about it, and only where your client can show it.