com.kythene/kythene · v1.0.2 · agents-and-memory
Kythene is healthy: it completed an MCP handshake in 1186 ms and exposes 48 tools.
Your AI's work, reviewed by your team, remembered - shared artifacts with review, plus team memory.
Endpoint: https://kythene.com/mcp/kythene (streamable-http)
Repository · Website · JSON · Add to my inventory
| Users (last 30 days) | 0 |
| Handshake | Healthy |
| Auth needed | None |
| Tool count | 48 |
| Latency | 1186 ms |
| Last checked (UTC) | 2026-10-15T22:05:10.047Z |
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-10-15T22:05:10.047Z | Healthy | 1186 | |
| 2026-10-14T20:15:42.364Z | Healthy | 3232 |
remember | Store a memory (markdown body). Describe it on three axes: `project` (which body of work - e.g. kythene, haven), `type` (the KIND of note - decision, how-to, gotcha, reference, person, meeting), and `tags` (what it is ABOUT - auth, billing, postgres). A kind-word like `decision` is a `type`, not a t |
recall | Recall the most relevant context, with full content, in one call. By DEFAULT this spans everything you can access - team/project memory AND published, non-memory work (collections/artifacts) - so you pick up what teammates and their agents produced, not just noted. Each result carries `kind` ("memor |
forget | Permanently remove a memory by id. |
deprecate | Mark a memory stale by id so recall stops surfacing it (agents stop applying it), while it stays retrievable for audit - prefer this over forget when knowledge is superseded rather than wrong. Optionally set replaced_by to the id of the replacement memory. Set restore=true to un-deprecate. |
link_memory | Create or remove a link between two memories over the from_id -> to_id edge. Curated relationships in the memory graph; [[wikilinks]] in a memory body already link automatically on remember, so use this for a relationship the body does not spell out. Both ids are memory ids in your space. Pass remov |
promote_memory | Promote a memory into another workspace you belong to (from a private/personal workspace to a team). It is held for REVIEW there: the target workspace's agents do NOT recall or apply it until an owner of that workspace approves. target_space is the workspace to promote INTO (id or name from list_spa |
report_activity | Report what you are working on (areas: file paths, modules, topics). Call when you start on something so teammates' agents see it and conflicts surface early. |
get_presence | Who is working on what right now (last 30 minutes), with areas touched by more than one agent flagged as conflicts. |
list_readers | Which agents read a collection or artifact (lineage). |
get_usage | How this workspace is being used over a window (default 30 days): recall volume and the zero-result rate (the share of recalls that came back empty - the product-health canary), the caller mix (mcp/cli/web), reads, publishes, new versions and review/curation counts. Aggregate counts only - no item o |
get_inbox | Feedback on your publishes since a time (comments, approvals, rejections). Call at session start and after publishing - this is how your collaborators' input reaches you. |
list_pending | Your personal inbox across ALL your workspaces (#126): items addressed to YOU - approvals/rejections and comments on your work, block feedback, and memories awaiting your review - each with a deep link into its workspace. Read-only (act on them in the app). Call at session start to open with 'what n |
comment | Comment on a collection or artifact; the comment pins to its current revision/version. The response's `url` opens the comment - hand that to a person, not the id. |
approve | Approve (approved=true) or reject (approved=false, note required) a collection or artifact at its current revision/version. New versions clear approvals. The response's `url` opens what you reviewed - hand that to a person, not the id. |
review_block | Flag one block of a renderable artifact and optionally comment on it - the block-level equivalent of comment/approve. First read the artifact with get_artifact to get each block's `anchor` and `text`, then call this once per block. Address a block by `anchor` (preferred) or by `quoted_text` (a verba |
create_collection | Create a collection from one or more artifacts - make work known to the space (kythe it). Artifacts carry name, mime and content; tags are created as needed. The response collection carries `url`, its canonical link - hand THAT to a person (or another agent) to point them at the work, not the bare i |
list_collections | List the collections visible in your space, newest first. Narrow with tag or search. Each collection carries `url`, its canonical shareable link - hand that over rather than the id. |
set_review | Turn the approval-review flow on or off for an existing collection (requested=true to request review, false to cancel). Use this to enable review/annotation on a collection that was published without it - review is a property of the collection, so there is no need to re-publish a copy to get it. To |
end_review | Take a collection out of review once you are done - the clean exit that complements set_review. By default it REFUSES while any block-review thread is still open and names them, so a collection only leaves review once it reads clean; resolve those threads (set each block to done or approved), then c |
share_collection | Map a collection into another space you belong to (e.g. a shared client space), or remove that mapping. Requires membership of both spaces. space_id is the TARGET space (id or name from list_spaces); do not put it in `space`, which is the space you act from. Pass remove=true to unmap it from space_i |
list_spaces | Your member spaces - the valid share targets. |
get_collection | Get a collection with its member artifacts and tags. The collection's `url` is its canonical shareable link; each artifact's `url` points at that file within the collection page - hand these over rather than ids. When the collection is under review, `review_requested` is true and `open_threads` / `r |
set_collection_state | Move a collection through its lifecycle by naming the target `state`: "archived" archives a live collection (a reversible retirement that hides it from the timeline, recall and search; nothing deleted, no storage freed) - and, on a collection already scheduled for deletion, cancels that deletion and |
edit_collection | Edit a collection without republishing (which would create a new collection and abandon its comments and history). `action` is one of: "add" - append new `artifacts` (name, mime, content) and/or `existing_artifact_ids` (already-published files of the same space); files already in the collection are |
get_artifact | Get an artifact's metadata and version history; set include_content to fetch the bytes of a version (0 = latest). |
push_version | Push a new version of an existing artifact. Referencing collections bump their revision and clear collection-level approvals. For a larger or binary file use `kythe version <collection-id> <file>` (it matches the file to the artifact by name), which reads the bytes off disk - up to 32 MiB per artifa |
create_share_code | Mint a share code for a tag (a label or a project) - a private link for someone outside the space. `tag` is a tag id or name; `label` records who it is for (required). Optionally set `expires_days` to time-box it (0 = never), so a leaked link does not stay live. Optionally set a `pin` (4-8 digits) a |
list_share_codes | List share codes. Pass `tag` (id or name) to list one tag's codes, or omit it to list every share code in the space. Revoked codes are included, flagged `revoked`. |
revoke_share_code | Revoke a share code by id (from list_share_codes). The holder loses access and the comment/approve capability immediately; their past feedback keeps its label. |
list_projects | List the projects (project-kind tags) in the space - the valid `project` values for recall, remember and publish. Narrow with `search`. |
resolve_project | Map a working directory to the Kythene project(s) it belongs to, so you can brief and recall for the right project without a human naming it. Pass what you observe: `marker` (verbatim contents of a .kythene file if one exists - authoritative), `git_remote` (the repo's origin URL), and `dir` (the wor |
get_workspace_guide | Read this workspace's operating manual: the house rules for writing here (style, tag taxonomy, memory vs collection, what belongs and what does not). Follow it when you remember/publish. `recall` and `brief` both return it inline as `guide`, so you normally already have it and do not need this call. |
set_workspace_guide | Replace this workspace's operating manual with `body` (markdown), and return the updated guide. An empty body resets it to the built-in default. Each save is versioned. Owner/admin only. |
brief | Open a session with ONE call instead of four. Returns this workspace's guide (its operating manual - follow it), the catchup delta since your agent last looked, the project's memory as an INDEX (titles, one-line hooks and ids - NOT bodies; recall an id for the full text), and your inbox count with a |
create_wiki | Create a wiki in this workspace: a tree of pages your team reads in Kythene. `name` is what people call it; `slug` is its segment in a page address (derived from the name if you omit it). Set `approval_required` when a page must be approved before it goes live. `root_body` is the markdown of the wik |
list_wikis | List the wikis in a workspace, with what each is for, how many pages it holds, how many of those are published, and when anything in it last went live - enough to tell which one holds what you are after without opening them. Narrow with `search`. |
list_pages | Walk a wiki's tree: every page you can see, parent before child, with its `path`, its `state` and its `depth`. Use it to find where a page belongs before creating one, and to get the paths the other wiki tools address pages by. A page you cannot see is not listed, so the tree never offers a route th |
get_page | Read one page: its markdown `body`, its `state`, what links to it (`links_here` - who depends on it, which is what matters before you change something) and what it links to. Address it by id, or by `path` within a named `wiki`. ALWAYS read a page before writing to it: the `base_revision` it returns |
create_page | Add a page to a wiki, as a DRAFT - nobody can read it, and it is in no search or recall, until you publish it with set_page_state. `parent` is the page it sits under (an id or a path); omit it for a page directly under the wiki's home page. `slug` must be unique among its SIBLINGS, not across the wi |
update_page | Replace a page's body with `body`, in FULL - this is not an append. `base_revision` is REQUIRED and must be the one get_page just gave you: if the page has moved on since, the write is refused and names the newer revision, so read it again and re-apply your change. That refusal is the point - two ag |
move_page | Move a page under a different `parent`, rename its `slug`, or both. Its whole subtree travels with it and every old path redirects, so links into the section keep working - tidying the tree never rots a link. The page's id never changes, so anything citing the id is unaffected. The response's `url` |
set_page_state | Move a page through its lifecycle by naming the target `state`: "published" makes the newest version the one readers see, and puts it into search and recall (refused where the wiki requires an approval - ask for one instead); "awaiting_approval" asks for one, optionally directed at a `reviewer`; "ap |
raise_action | Put a piece of work on the team's queue - the pillar that flows BOTH ways, so this is how you ask a person for something as well as how they ask you. `body` says what is wanted; write it for somebody who was not in the conversation. `assignee` is "me", "owner" (the person you act for), one of your o |
list_actions | Read the queue. This is the AUTHORITATIVE answer to what you still owe - catch_up only announces an action once, and an announcement you have scrolled past is not the same thing as work you have dealt with, so check here rather than trusting the feed. `scope` is "mine" (the default), "unassigned" (r |
set_action_state | Move an action along by naming the target `state`: "in_progress" means you have started, which is yours to say as the assignee; "pending" means not now, or REOPENS a resolved action - either party may reopen, because disagreeing with "done" is the whole reason resolved exists; "resolved" means you t |
assign_action | Say who owes an action. `assignee` takes "me" to claim it, "owner" to hand it to the person you act for, one of your own agents, or a person's id - and EMPTY to put it back on the unassigned pile. Work nobody owns is anybody's to triage; work somebody already owns can only be moved by them or by who |
create_upload_ticket | Publish a file WITHOUT carrying it through this tool call. Use it for anything more than a short note: `create_collection` needs the content inlined, and on a voice or chat surface that stalls. This call is metadata only - `filename`, and optionally `title`, `mime`, `tags` - and returns an address, |
catch_up | See what changed since your agent last looked, AND what has been put on your plate - call this at the START of a session to open caught up. Returns publishes, shares, new versions, feedback (comments and approvals) and memory promotions/deprecations in your workspaces since this agent's last catchup |