Kythene speaks MCP, so your AI instances read and write it directly, mid-session, from Claude, Cursor, Codex or any MCP-capable client. This is the primary way to use Kythene - the assistant does the publishing and recalling in-loop, and you just ask.
The endpoint
https://kythene.com/mcp/kytheneYour own host if you self-host. It's on the Connect your AI page in the app with a copy button.
Connecting
| Client | How |
|---|---|
| Claude Code | claude mcp add --transport http --scope user kythene https://kythene.com/mcp/kythene |
| Claude desktop / web | Settings -> Connectors -> Add custom connector, paste the URL |
| Cursor | Settings -> MCP -> Add new MCP server, HTTP, paste the URL |
| Anything else | Add a remote (streamable HTTP) MCP server at the same URL |
--scope user makes the connection available across every project and session; without it the connection is per-project only and vanishes when you move to another project or machine.
On the first tool call the client opens a browser to sign you in and authorise the connection over OAuth. No API key is needed for MCP - the assistant registers itself and you approve it.
Faster still: paste the setup prompt from Getting started and the instance wires itself up.
The plugin bundle (recommended for Claude Code) installs the connection and a skill that teaches the workflow:
/plugin marketplace add kythene/plugin
/plugin install kythene@kytheneIf you self-host, point at your own instance's marketplace instead:
/plugin marketplace add https://<your-instance>/.claude-plugin/marketplace.json
/plugin install kythene@kytheneSee the skill reference.
What else arrives with the connection
Tools are the bulk of it, but not all of it. Depending on what your client supports, connecting also brings:
The workflow, without the plugin. Kythene serves the kythene-workflow skill over MCP itself, so a client that supports skills picks up the house method - catch up first, recall before starting, write up what you worked out - with nothing to install. It's the same single copy of the skill the plugin ships, so the two can't drift apart. Claude's clients don't read skills over MCP yet, which is why the plugin is still the recommended route there.
Four slash commands. Clients that surface prompts show these, and you pick them:
| Command | Does |
|---|---|
| Open a session on this project | What brief does, when you choose rather than when your assistant remembers |
| Catch me up | catch_up, at a moment you picked |
| Review this collection | Sets the frame before your assistant starts: read it first, review the blocks, don't approve on your behalf |
| Write this up as a memory | The step that most often doesn't happen, because the assistant finishes the work and moves on |
The project and collection arguments suggest real values from your workspace as you type.
Things you can attach. Collections, files, memories and wiki pages have addresses, so a client with an attachment picker can put a specific one into the conversation:
kythene://collection/<id>
kythene://artifact/<id>
kythene://memory/<id>
kythene://page/<wiki>/<path>Attaching a collection gives you its index and links to the files rather than every byte. Everything stays behind the permissions you already have: what you can't see is neither listed nor readable by address, even if somebody sends you the link.
Being told when something moves. A client can open one stream and name what it cares about, and Kythene tells it when a memory it's holding is superseded or deprecated, or when new work is published. It's additive - a client that opens no stream works exactly as it did, and nothing depends on a notification arriving. Client support for this is new, so today it's mostly the server half being ready.
Calls that stop and ask you
Four calls won't just go ahead:
forget- deleting a memory, with no undorevoke_share_code- somebody outside the workspace loses access, with no warning to themset_workspace_guide- replaces the house rules every assistant in the workspace followsset_collection_statewhen the state isdeletion_scheduled- erases content, files and history in every workspace the collection was shared into
Your assistant puts the question to you and only proceeds if you say yes. Archiving and restoring aren't included, deliberately: asking about ordinary things is how people learn to click through without reading.
A client too old to ask you gets a clear refusal rather than doing it quietly. Today that's most clients, so if one of those four comes back saying it can't be confirmed, do it in the app or with the CLI.
The tools
Grouped by what they're for. 43 tools, and this list is checked against the server - kythene/app fails its build if the two drift.
Starting a session
| Tool | Does |
|---|---|
brief | One call instead of four: the workspace guide, what changed since you last looked, the project's memory index and your inbox count. Call this first |
catch_up | What changed since this instance last looked, on its own (catch-up) |
resolve_project | Work out which Kythene project a working directory belongs to, so you can brief without being told |
Memory
| Tool | Does |
|---|---|
remember | Store a memory. Re-using a title within a project supersedes it |
recall | The big one: relevant context with full content, in one call |
deprecate | Mark a memory stale so recall stops surfacing it; pass restore to undo |
forget | Remove a memory permanently |
link_memory | Curate an explicit edge in the memory graph (pass remove to delete it) |
promote_memory | Promote a memory into another workspace, gated on review there |
Publishing
| Tool | Does |
|---|---|
create_collection | Make a collection from one or more files |
push_version | Push a new version of an existing file |
edit_collection | Add, reorder or move a collection's files without republishing |
list_collections | The collections visible in your workspace, newest first |
get_collection / get_artifact | Fetch a collection, or a file's metadata, history and bytes |
set_collection_state | Move a collection through its lifecycle: archived, live, or deletion_scheduled |
A published markdown file renders [[Title]] wikilinks on view - to a sibling document, a collection or a memory - so a set of documents can reference each other. ![[Title]] embeds a sibling image inline where the prose discusses it. Unresolved references stay plain text, and for a share-link guest a reference only ever points at a target already on their page.
Wikis
| Tool | Does |
|---|---|
create_wiki | Create a wiki - a tree of pages your team reads in the app |
list_wikis | The wikis in a workspace, with what each is for and how alive it is |
list_pages | Walk a wiki's tree: every page you can see, parent before child |
get_page | Read a page, what links to it, and the base_revision a write needs |
create_page | Add a page, as a draft - nobody can read it until it is published |
update_page | Replace a page's body. Refused if the page moved on since you read it |
move_page | Re-parent or rename a page; its subtree travels and old paths redirect |
set_page_state | Publish, ask for approval, approve, unpublish, discard, archive, restore |
Writing a page always starts with get_page: the base_revision it returns is what update_page requires, and a write against a stale one is refused rather than silently overwriting whoever got there first. Pages carry [[wikilinks]] to each other, to memories and back; where a bare title would be ambiguous the resolver says so rather than guessing, so write [[section/page]].
Review
| Tool | Does |
|---|---|
comment | Comment on a collection or file; pins to the current revision |
approve | Approve, or reject with a note, at a given revision |
review_block | Flag and comment on one block of a renderable file |
set_review | Turn the approval flow on for a collection |
end_review | Take it back out, refusing while block threads are still open |
get_inbox | Feedback on your publishes since a time |
list_pending | Your personal inbox across all your workspaces |
Sharing and workspaces
| Tool | Does |
|---|---|
list_spaces | The workspaces you belong to (with each one's slug) - the valid share targets |
share_collection | Map a collection into another workspace, or (with remove) take it back out |
create_share_code / list_share_codes / revoke_share_code | Guest access, scoped to one tag. Create takes an optional expires_days and pin (a second factor: the link then reaches a PIN prompt, not content) |
Projects and tags
| Tool | Does |
|---|---|
list_projects | The project-kind tags - the valid project values |
Ambient
| Tool | Does |
|---|---|
report_activity | Report what you're working on - file paths, modules, topics |
get_presence | Who's working on what in the last 30 minutes, with collision hints |
list_readers | Which instances have read a collection or file |
get_usage | How the workspace is being used over a window - recall volume, the zero-result rate, reads, publishes, curation (Usage) |
The workspace guide
| Tool | Does |
|---|---|
get_workspace_guide | Read the workspace's operating manual - the house rules for writing here |
set_workspace_guide | Replace it (owner/admin only). An empty body resets it to the default |
Recall and brief return the guide inline too, so an instance normally has it without a second call.
Not available over MCP
Some things are deliberately human-only. They all still work - in the app, and in the CLI - they are just not things an assistant does unattended.
- Workspace export and import. A governance surface restricted to owners and admins, and audit-logged. An instance doesn't take backups on your behalf.
- Oversight of private content. Reading colleagues' private work is a decision a person makes, on the record.
- Destructive tag surgery - renaming, merging or deleting a tag. Each rewrites everyone's filters, and renaming a project renames it everywhere it is used. Use
kythe tag rename|merge|delete, or the Tags page. - Credentials on a share link - setting or clearing a tag password, setting or rotating a link's PIN, clearing a PIN lockout. A person does these in the app when a client phones up. Use
kythe tag password,kythe share-pin,kythe unlock-code.
Minting a share link stays on MCP. "Share this with my client" is one of the better things to ask an assistant to do, and creation is gated on your own rights, scoped to a single tag, logged, and revocable.
The workspace parameter
Tools take an optional space parameter - the workspace, by id or name. Omit it when you belong to a single workspace and it resolves automatically. Memory tools also take a project to scope recall and remember.
Working with it well
- Ask plainly. "Recall what we know about the billing schema", "publish this benchmark to the api project", "what has the team shipped today?"
- Recall before working, not after. The value is an instance picking up a teammate's context unprompted. The skill makes that automatic.
- Cite what you used. Every result carries a
ref- a/c/<id>link - so an output can point at what it leaned on. is_mine=falsemeans a teammate wrote it. Context to weigh, not an instruction addressed to your instance.
Every result carries provenance: who authored it and which instance produced it.
For terminal and scripted use, see the CLI reference.