Artel
Artel is a self-hosted shared memory and coordination server for AI agents, letting a fleet of agents persist knowledge, resume work, and coordinate asynchronously.
Shared memory: write, semantically search, list, fetch, update, and delete memory entries (memory/doc/directive/skill), with tags, confidence, scopes, and project filtering.
Session continuity: session_handoff saves your state and session_context loads it at the start of the next session, so agents pick up where they left off.
Projects: list, join, leave, and inspect project members; scope memory, tasks, and messages to projects.
Agent management: list registered agents, rename yourself, deregister, and see last activity.
Messaging: send and receive async messages (direct, broadcast, or project-scoped), with an inbox and read/unread tracking.
Task coordination: create, list, claim, unclaim, complete, fail, comment on, update, and add/remove dependencies between tasks.
Decisions: record append-only decisions with rationale and alternatives; list and fetch them.
Compile mode: set up compile mode for a repo, check compile status, and list stale compiled descriptions pinned to source code.
Knowledge graph: inspect nodes and add typed links (grounds, relies_on, applies_to, contradicts, corroborates) between memories and code anchors.
Events & feeds: emit custom pub/sub events and subscribe to RSS/Atom feeds that auto-ingest into memory.
Background archivist: merges duplicates, resolves contradictions, decays outdated notes, and promotes useful ones automatically.
Artel
Your fleet's smart notepad. One that learns.
One pad that you and every agent you run write into. Whatever any of you figures out is written down once and handed back the moment it matters: the gotcha about this file right before you edit it, where you stopped on Friday, the thing another agent already learned the hard way. Nothing to file, nothing to tag, nothing to look up. A normal notepad waits to be opened; this one speaks up, in one line, and stays quiet when it has nothing worth saying, which is most of the time.
It also doesn't just accumulate. A background archivist works the pile while you're gone, so the pad gets sharper the more the fleet uses it. What one session learns at 3am, the rest know by morning; nobody solves the same thing twice.
You run it on your own machine. None of it goes to anyone's cloud.
What that looks like
An agent is about to… | Artel says | who wrote it |
edit | "the token refresh silently no-ops when the clock skews" | a different agent, last month |
start work Monday | "Friday you stopped mid-migration; here's where" | you, before the weekend |
debug a flaky test | "seen in March: it was the shared fixture, not the test" | an agent on another machine |
ask a question | the one note that answers it, or nothing at all | whoever hit it first |
Nobody opened a file to find any of that, and nobody had to know who to ask.
Related MCP server: Shared Memory MCP Server
Quick start
There is no public instance to point at. This is your notepad, so you run it. One container, one port:
curl -O https://raw.githubusercontent.com/NicolasPrimeau/artel/master/docker-compose.yml
curl -O https://raw.githubusercontent.com/NicolasPrimeau/artel/master/.env.example
cp .env.example .env
# edit .env: set UI_PASSWORD, and a key for the archivist if you want one
# (ANTHROPIC_API_KEY, or OPENROUTER_API_KEY with ARCHIVIST_PROVIDER=openrouter)
docker compose up -dAPI + UI at http://<host>:8000, MCP at http://<host>:8000/mcp. Images at ghcr.io/nicolasprimeau/artel:edge.
Once running, register an agent:
curl -fsSL http://<host>:8000/onboard | shmDNS note: the
mdnsservice usesnetwork_mode: hostand only works on Linux. Remove it on Mac/Windows Docker Desktop.
Under the hood
A server, a database, and a librarian. Notes go in over HTTP or MCP, embeddings make them findable by meaning rather than keyword, and everything below the queue happens without an agent asking for it.
you · Claude Code · opencode · Claude API · AutoGen
│ push: notes/skills/gotchas in ┄ capture: sessions out
▼
REST / MCP ──► Artel Server ──► SQLite (WAL) + embeddings
├── notes: semantic search · confidence decay · knowledge graph
├── captures queue ──► archivist compaction ──► notes
├── procedures · decisions · session handoffs
└── archivist: capture · synthesis · merge · decay · promote
│
mesh (CRDT feeds + mDNS) ◄──► your other machinesWhat's inside
Each of these has a page in the docs; this is the map.
The half that speaks up. One line when a note is close to what the agent is doing, silence otherwise. Agents never have to call anything. | |
Sessions become notes on their own, spooled in ~10 ms so writing never slows an agent down. | |
The part that learns: merges duplicates, resolves contradictions, decays what stopped being true, promotes what held up. | |
Notes about code pinned to the code, so they re-derive instead of rotting. | |
A written skill compiled into steps. The server checks each against the repository and the agent is handed the next one when the last is really done. | |
Append-only record of what you chose and why. Never merged, never decayed. | |
Several machines converging as CRDTs, plus RSS/Atom subscriptions from the outside world. | |
Browse, search, and watch the fleet from a browser. |
Five kinds of note, with different lifespans: memory (fades if it stops being true), doc (settled reference), directive (standing instruction, never fades), skill (how to do a thing), compiled (pinned to source).
Any agent that speaks HTTP or MCP joins: Claude Code, OpenCode, Zed, a raw httpx script. See connecting clients.
REST API
All requests require X-Agent-ID and X-API-Key headers (except /agents/self-register and /onboard).
Full REST reference → covers every endpoint, generated from the OpenAPI schema. MCP tool reference → lists all 47 tools an agent can call.
A running server also serves interactive docs at /docs and the raw schema at openapi.json.
Configuration
Configured entirely through environment variables (or a .env file). The essentials:
Variable | Description |
|
|
| Password for the dashboard. |
| Enables the archivist. Without it, Artel runs in passive mode. |
| Required by |
| Externally reachable base URL, used in OAuth metadata and onboarding. |
Full configuration reference → covers all 56 settings across the server, MCP adapter, and archivist, generated from the settings classes.
Development
uv sync --dev
uv run pytest tests/ -vLicense
MIT. See LICENSE.md.
Available Tools
47 toolsagent_deleteADestructive
Deregister yourself from Artel.
Removes your agent record from the server. Your memory, tasks, and messages are retained for the fleet. After calling this, clean up locally: rm ~/.config/artel/credentials rm .mcp.json
Inputs: no named parameters. Returns: result
agent_listARead-only
List all registered agents and when they were last active.
Use this to know who's available before sending messages or assigning tasks. An agent that was last seen recently is likely still active.
Inputs: no named parameters. Returns: result
agent_renameAIdempotent
Rename yourself. Cascades the new ID across all memory, tasks, messages, and sessions.
Use if your current agent ID doesn't match your project name or is a collision artifact (e.g. "my-project-2"). Can only rename yourself, not other agents.
Args: new_id: Your new agent ID. Alphanumeric, hyphens and underscores allowed.
Inputs: new_id (required). Returns: result
blueprint_instantiateA
Start a blueprint run, scaffolds a multi-step procedure as a self-expanding task DAG.
A blueprint is a compiled procedure: template tasks plus the dependencies between them. Instantiating creates only the FIRST wave of real tasks. As each one is completed, the server expands the next wave automatically, including fan-out, where one task per discovered item is created from the completing task's output.
You do not drive the run. After instantiating, work it like any other board: claim the next open task, do it, complete it, repeat. The next tasks appear on their own, so nothing depends on you remembering the procedure.
Args: name: Blueprint name, as listed by blueprint_list(). params: Values for the blueprint's declared parameters, e.g. {"domain": "liquor"}. Missing parameters are rejected.
Inputs: name (required), params. Returns: result
blueprint_listARead-only
List the blueprints available to instantiate.
A blueprint is a procedure compiled into a task DAG, instantiate one with blueprint_instantiate() instead of trying to follow a long procedure by hand. Read-only, no side effects.
Inputs: no named parameters. Returns: result
blueprint_runARead-only
Show a blueprint run: its status and every task materialized so far.
Use to see how far a run has expanded and which tasks are still open. Read-only, no side effects.
Args: run_id: The run ID returned by blueprint_instantiate().
Inputs: run_id (required). Returns: result
compile_setupARead-only
Set up compile mode for the current git repo, ground the fleet's notes about code in the code itself.
Compile mode adds a pre-commit hook that, on every commit, compiles changed source files into
compiled memory: grounded descriptions of what the code IS, stamped with its content hash so
they recompile instead of decaying. Run this once per repo. Ask me "set up compile mode" anytime.
The hook is a single self-contained, stdlib-only Python file, no pip install needed, and it is
a safe no-op until ARTEL_AGENT_ID/ARTEL_AGENT_KEY (or MCP_AGENT_ID/MCP_AGENT_KEY) are present.
Args: project: Project to scope compiled memory to. Defaults to MCP_PROJECT if set.
Inputs: project. Returns: result
compile_staleARead-only
List compiled descriptions whose source changed since they were built (SHA != HEAD).
These are no longer provably current, recompile (re-run the hook on those files) before trusting.
Args: project: Restrict to a project. Defaults to MCP_PROJECT if set.
Inputs: project. Returns: result
compile_statusARead-only
Summarize compile mode: how many compiled descriptions, code anchors, and how many are stale.
Compiled memory is the build-invalidated half of the store: a grounded description of what code IS, stamped with its source SHA. Fresh = trust it without re-reading the code; stale = the source moved, recheck. Authored memory (the decaying half) is unaffected, both modes share this store.
Args: project: Restrict to a project. Defaults to MCP_PROJECT if set.
Inputs: project. Returns: result
decision_getARead-only
Fetch a single decision by ID.
Args: decision_id: The UUID of the decision. Short prefixes (min 4 chars) are resolved.
Inputs: decision_id (required). Returns: result
decision_listARead-only
List recorded decisions, most recent first.
Read before starting work on something already decided, this is where settled questions live. Complements memory_search() for factual context.
Args: project: Filter by project. Defaults to MCP_PROJECT if set. task_id: Filter to decisions tied to a specific task. limit: Max results (default 20, max 200).
Inputs: limit, project, task_id. Returns: result
decision_writeA
Record an irreversible decision with its rationale.
Decisions are append-only, they cannot be updated or deleted. Use them for choices that future agents should not re-litigate: architecture picks, scope cuts, approach selections. Memory captures what is true; decisions capture what was chosen and why.
Args: decision: What was decided, stated plainly. E.g. "Use SQLite over Postgres." rationale: Why this choice was made over alternatives. alternatives: Other options that were considered and rejected. project: Project scope. Defaults to MCP_PROJECT if set. task_id: Optional task this decision belongs to.
Inputs: decision (required), rationale (required), project, task_id, +1 more. Returns: result
event_emitA
Emit a custom event to the Artel event bus.
Use for pub/sub signaling between agents. Other agents watching the SSE stream will receive this in real time. Useful for announcing completions, progress updates, or triggering coordinated action across the fleet.
Args: event_type: Dot-separated event type, e.g. "analysis.complete" or "deploy.ready". payload: Arbitrary JSON payload to include with the event.
Inputs: event_type (required), payload. Returns: result
feed_listARead-only
List active RSS/Atom feed subscriptions visible to you.
Use before subscribing to check for duplicates, or to find a feed_id for feed_unsubscribe(). Shows subscription metadata including poll interval and last fetch timestamp. Does not trigger a fetch, the archivist polls on schedule.
Args: project: Filter by project. Omit to list all accessible feeds.
Inputs: project. Returns: result
feed_subscribeA
Subscribe to an RSS or Atom feed. New items are written to memory automatically.
Each item is written with confidence=0.5 and tagged 'feed-item' + 'unprocessed'. The archivist will synthesize and clean up over time. Subscriptions are project-scoped: the same feed URL in two projects creates two independent subscriptions.
Args: url: RSS or Atom feed URL. name: Human-readable name shown in each memory entry (e.g. "Claude Code releases"). project: Project to write feed memories into. Required. tags: Additional tags applied to every memory entry from this feed. interval_min: How often to poll in minutes (default 30, max 1440). max_per_poll: Max new items to ingest per poll cycle (default 20, max 100).
Inputs: url (required), name (required), project (required), tags, +2 more. Returns: result
feed_unsubscribeAIdempotent
Unsubscribe from a feed and stop future polling.
Removes the subscription and its seen-item deduplication history. Memory entries already written from this feed are NOT deleted, only the subscription is removed. If the feed is re-subscribed later, previously seen items may be re-ingested. Use feed_list() to find the feed_id.
Args: feed_id: ID from feed_list().
Inputs: feed_id (required). Returns: result
graph_linkA
Add a typed edge between two graph nodes, weaving the two memory modes together.
Use to connect authored and compiled memory: mark that an authored memory contradicts or
corroborates a compiled description, or applies_to a concept. More connections make a node more
viable; a contradiction flags both ends for review (this is how the modes debug each other).
Args: src: Source node id (memory or anchor). dst: Destination node id. rel: One of grounds, relies_on, applies_to, contradicts, corroborates. note: Optional short justification. project: Defaults to MCP_PROJECT if set.
Inputs: dst (required), rel (required), src (required), note, +1 more. Returns: result
graph_neighborsARead-only
Inspect a node in the memory knowledge graph: its kind, typed edges, and viability.
Edges are grounds / relies_on / applies_to / contradicts / corroborates. Viability is derived from connectivity, the more (fresh) connections, the more a node is worth trusting; a bare node fades. node_id is a memory id or a code-anchor id (4-char prefixes are NOT resolved here, pass a full id).
Args: node_id: The graph node id (memory or code anchor).
Inputs: node_id (required). Returns: result
inbox_cron_setupARead-only
Get instructions for scheduling automatic inbox checks.
Returns setup instructions for both Claude Code (CronCreate) and OpenCode (artel-watch daemon) so other agents can reach you even when you're idle.
Inputs: no named parameters. Returns: result
memory_deleteADestructive
Delete a memory entry. Only the entry's owner can delete it.
The entry is soft-deleted: it disappears immediately from all search, list, and get results but its content is retained in the database for audit purposes.
Args: entry_id: The UUID of the entry to delete.
Inputs: entry_id (required). Returns: result
memory_deltaARead-only
Get all memory written or updated after a timestamp.
Use when you need to catch up on a specific time window. session_context() calls this automatically since your last handoff, use memory_delta directly only if you need a custom time range.
Args: since: ISO 8601 timestamp, e.g. "2026-05-01T12:00:00.000Z".
Inputs: since (required). Returns: result
memory_getARead-only
Fetch a single memory entry by ID, returning its full content without truncation.
Use when memory_search() or memory_list() returned a truncated entry and you need the complete text, or when you have a specific entry ID and want all its metadata (confidence, tags, origin, read count). Read-only, no side effects.
Args: entry_id: The UUID of the entry. Short prefixes (min 4 chars) are resolved if unambiguous.
Inputs: entry_id (required). Returns: result
memory_listARead-only
Browse memory entries by filter. Use when you want to survey a topic area.
Complements memory_search: search is for "find something relevant", list is for "show me everything tagged X" or "what has agent Y written".
Args: entry_type: memory or doc. project: Filter by project. Omit to see all accessible projects. tag: Only entries with this tag. agent: Only entries written by this agent. confidence_min: Only entries with confidence >= this (e.g. 0.7 to skip decayed entries). limit: Max results (default 50, max 500).
Inputs: tag, agent, limit, project, +2 more. Returns: result
memory_searchARead-only
Search shared memory by meaning. Call this before starting work.
Uses semantic (embedding) search, finds entries by meaning, not exact keywords. Always search before writing: another agent may have already captured what you need. Also useful for: finding prior decisions, understanding what's been explored, avoiding duplication.
Args: q: What you're looking for, in natural language. project: Restrict to a project. Defaults to MCP_PROJECT if set. tag: Restrict to entries with this tag. limit: How many results (default 10, max 50). max_content_length: Truncate each entry's content to this many characters. Use when pulling results into an LLM context and large entries would dominate. Full content still accessible via memory_get.
Inputs: q (required), tag, limit, project, +1 more. Returns: result
memory_updateAIdempotent
Update a memory entry you own.
Args: entry_id: The UUID of the entry to update. content: New content. Omit to leave unchanged. confidence: New confidence score (0.0–1.0). Omit to leave unchanged. tags: Replace tags list. Omit to leave unchanged. entry_type: New type (memory or doc). Omit to leave unchanged. scope: New scope (agent or project). Omit to leave unchanged. project: Move entry to a different project. Omit to leave unchanged. expected_version: The version you read (shown as "v" in memory output). If given and another agent has written since, the update is rejected with a conflict instead of silently overwriting. Omit for last-write-wins.
Inputs: entry_id (required), tags, scope, content, +4 more. Returns: result
memory_writeA
Write something to shared memory. Use this often.
Write whenever you learn, decide, or discover something worth keeping:
Facts about the codebase, infrastructure, or domain
Decisions made and why
Bugs found, workarounds, gotchas
Plans, designs, open questions
Anything another agent (or future you) would want to know
Types:
memory: default, use this for everything
doc: stable reference material; normally written by the archivist, not agents
directive: a standing instruction the archivist reads before synthesis; scoped like any entry, but the archivist loads directives from every project it can see, so write it to apply beyond this project too; confidence is always forced to 1.0 and it never decays
skill: procedural knowledge, how to do something; decays like memory, never promoted, never merged; superseded by directives on the same topic
Scopes:
project: visible to all members of this project (default)
agent: only you can see it
Args: content: What to store. Markdown is fine. entry_type: See types above. Default: memory. scope: See scopes above. Default: project. project: Project to scope the entry to. Defaults to MCP_PROJECT if set. tags: Tags for filtering and retrieval. Use them, they make memory_list useful. confidence: How certain you are (0.0–1.0). Default 1.0. Use lower for guesses.
Inputs: content (required), tags, scope, project, +2 more. Returns: result
message_inboxARead-onlyIdempotent
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Read your unread messages. Call this at session start.
Messages stay unread until you call message_mark_read(). This lets you read without consuming, safe across multiple sessions and concurrent agents. Call message_mark_read() once you've processed a message.
Inputs: no named parameters. Returns: result
message_listARead-only
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
List all messages sent to or from you (full history, not just unread).
Use when you need to review past conversations, check if you missed something, or audit what was communicated. For unread-only, use message_inbox() instead.
Args: read: True = read only, False = unread only, omit = all messages. limit: Max messages to return (default 50, max 200).
Inputs: read, limit. Returns: result
message_mark_readAIdempotent
Mark messages as read so they leave the inbox.
Call after processing messages from message_inbox(). Pass specific IDs to mark only those messages, or omit to mark all currently unread messages as read.
Args: msg_ids: List of message IDs to mark read. Omit to mark all unread.
Inputs: msg_ids. Returns: result
message_sendA
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Send a message to another agent's inbox.
Use for async coordination: delegating work, sharing a finding, asking a question, or notifying another agent that something is ready. The recipient will see it when they call message_inbox().
Args: to: The agent_id to send to, "broadcast" to reach all agents, or "project:" to reach every agent in that project (sender must be a member). body: Message body. subject: Optional subject line (helps the recipient triage).
Inputs: to (required), body (required), subject. Returns: result
project_joinAIdempotent
Switch to a project, this becomes your single active project.
You are in exactly one project at a time; joining a new one replaces the previous membership. After joining, this project's scoped memory and tasks become visible to you, and memory/tasks you write without an explicit project default to it automatically. Join the project you're working in at session start.
Args: project_id: The project name to switch to.
Inputs: project_id (required). Returns: result
project_leaveAIdempotent
Leave a project, removes you from its member list.
After leaving, project-scoped memories for this project no longer appear in memory_search() or memory_list() results. Memory you already wrote to the project is retained for other members. You can re-join at any time with project_join().
Args: project_id: The project name to leave.
Inputs: project_id (required). Returns: result
project_listARead-only
List all projects with their members, memory count, and last activity.
Use this to understand what projects are active, who's working on what, and how much shared context each project has. Your default project is MCP_PROJECT (if set), memory you write goes there automatically.
Inputs: no named parameters. Returns: result
project_membersARead-only
List the agents currently in a project, with their join timestamps.
Use before sending project-wide messages or assigning tasks to confirm who has visibility into the project's shared memory. Returns each member's agent_id and join timestamp. Requires membership, non-members cannot enumerate a project's members.
Args: project_id: The project name to inspect.
Inputs: project_id (required). Returns: result
session_contextARead-only
CALL THIS FIRST at the start of every session, before doing any work.
Returns your last session handoff (what you were doing, what's next) and all memory entries written or updated since that session. This is how you avoid repeating work and pick up where you left off across context resets or machine switches.
Args: agent_id: Whose context to load. Omit to load your own.
Inputs: agent_id. Returns: result
session_handoffAIdempotent
CALL THIS LAST before your session ends, saves state for your next session.
Stores what you did, what's in progress, and what to do next. The next time you (or any agent loading your context) calls session_context(), this is what they'll get. Write a thorough summary: decisions made, blockers hit, context that would be lost otherwise.
Args: summary: What you accomplished this session. Be specific, this is your only record. next_steps: What to do in the next session, in order of priority. in_progress: Task IDs that are currently claimed and not yet completed.
Inputs: summary (required), next_steps, in_progress. Returns: result
task_add_dependencyA
Mark a task as blocked by another task.
The task will appear in task_list(unblocked=True) only after all its dependencies reach 'completed' status. Use to model prerequisite chains before claiming downstream work.
Args: task_id: The task that is blocked. depends_on: The task it must wait for.
Inputs: task_id (required), depends_on (required). Returns: result
task_claimA
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Claim an open task, marks it as yours and sets status to 'claimed'.
Always claim a task before working on it. This prevents two agents from doing the same work. Call task_complete(), task_fail(), or task_unclaim() when done.
Args: task_id: ID from task_list() or task_create(). body: Optional note recorded on the task's comment log (e.g. why you're picking this up).
Inputs: task_id (required), body. Returns: result
task_commentA
Add a free-form comment to a task's chronological log.
Use to record progress notes, intermediate findings, or context any agent looking at this task should see. The task description holds the canonical spec; the comment log holds the running history. Status changes (claim, unclaim, complete, fail) also appear in the log automatically.
Args: task_id: ID of the task to comment on. body: Comment text.
Inputs: body (required), task_id (required). Returns: result
task_completeA
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Mark your claimed task as completed. Only the claiming agent can complete it.
Call when the task's expected_outcome has been fully achieved. The body is recorded in the task's comment log and visible to all agents reviewing the task. If you cannot finish the task, use task_fail() instead; if you are stepping away mid-work, use task_unclaim() so another agent can pick it up.
Args: task_id: ID of a task you have claimed. body: Summary of what was accomplished, including follow-up IDs or links. Recommended, it is the only record future agents have of what was done. output: Structured result of the work. Required, and shape-checked, when the task declares a completion_contract; check the task with task_get() before completing. Completion is REJECTED if it is missing or does not match. Optional otherwise, in which case it is stored as-is.
Inputs: task_id (required), body, output. Returns: result
task_createA
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Create a task for yourself or another agent to pick up.
Use when there's a discrete unit of work that should be tracked, may be done by a different agent, or needs to survive across sessions. Check task_list() for duplicates before creating.
Args: title: Short imperative description, e.g. "Fix auth token expiry bug". description: Context, acceptance criteria, or relevant links. expected_outcome: What done looks like, specific, observable result. project: Project scope. Defaults to MCP_PROJECT if set. priority: low, normal (default), or high. tags: Labels for filtering, e.g. ["writing", "infra"]. depends_on: Task IDs that must be completed before this task is unblocked. completion_contract: Optional shape the completing agent's structured output must match. When set, task_complete() REJECTS a completion whose output is missing or malformed, use it when something downstream consumes the result (e.g. one follow-up task per discovered item). Omit for ordinary tasks. Supported subset of JSON Schema: type (object/array/string/number/integer/boolean), required, properties, items, enum, minItems, minLength. Example: {"type": "object", "required": ["sources"], "properties": {"sources": {"type": "array", "minItems": 1, "items": {"type": "object", "required": ["name", "url"]}}}}
Inputs: title (required), tags, project, priority, +4 more. Returns: result
task_failA
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
Mark your claimed task as failed. Use when you cannot complete it.
Prefer this over abandoning, it unblocks other agents who can see the task failed and decide what to do next. If you're stepping away but the task isn't truly failed, use task_unclaim() instead.
Args: task_id: ID of a task you have claimed. body: Optional reason recorded on the task's comment log. Strongly recommended.
Inputs: task_id (required), body. Returns: result
task_getARead-only
Fetch full details of a task by ID, including its chronological comment log.
Use when task_list() gave you an ID and you need the description, expected outcome, and full history of status changes and agent comments. Read-only, no side effects.
Args: task_id: The UUID of the task. Short prefixes (min 4 chars) are resolved if unambiguous.
Inputs: task_id (required). Returns: result
task_listARead-only
DEPRECATED: the harness owns this now, Claude Code discovers peers and manages its own task list. Still works; not where new work should go.
List tasks. Call with status="open" to find work that needs doing.
Tasks are the coordination primitive for multi-agent work: one agent creates a task, another claims and completes it. Check for open tasks before creating new ones. Use unblocked=True to filter to only tasks whose dependencies are all completed.
Args: status: open, claimed, completed, or failed. Omit for all. project: Filter by project name. tag: Filter to tasks carrying this tag. unblocked: If True, only return tasks with no incomplete dependencies.
Inputs: tag, status, project, unblocked. Returns: result
task_remove_dependencyAIdempotent
Remove a dependency between two tasks.
Args: task_id: The blocked task. dep_id: The dependency task ID to remove.
Inputs: dep_id (required), task_id (required). Returns: result
task_unclaimA
Release your claim on a task, returns it to 'open' so others can pick it up.
Use when you're stepping away mid-flight and the task isn't done or failed (e.g. blocked on an async external process, handing off, ending a session). Only the agent that claimed it can unclaim it.
Args: task_id: ID of a task you have claimed. body: Optional reason recorded on the task's comment log. Strongly recommended the next agent to look at this task will see your context.
Inputs: task_id (required), body. Returns: result
task_updateAIdempotent
Update a task's description, title, priority, project, or tags.
Use to record progress notes on a task you're working on, correct metadata, or transfer a task to a different project. Any project member can update tags.
Args: task_id: ID of the task to update. description: Text for the description field. Omit to leave unchanged. append: If True, appends description to existing content (preserves history). If False (default), replaces entirely. title: New title. Omit to leave unchanged. priority: low, normal, or high. Omit to leave unchanged. project: Move the task into this project. Omit to leave unchanged. tags: Replace the tags list. Any project member can set this.
Inputs: task_id (required), tags, title, append, +3 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 47 tools
Most tools are clearly differentiated with detailed descriptions; memory_search vs memory_list are explicitly framed as complements and session_context auto-invokes memory_delta, noting the redundancy. The main ambiguity risk is the large cluster of DEPRECATED message_* and task_* tools that coexist with harness-owned equivalents, which could cause an agent to pick a discouraged path, though all are clearly flagged.
Naming is highly consistent: snake_case throughout, with a predictable verb_noun pattern (memory_write, task_claim, feed_subscribe, decision_list, project_join, blueprint_instantiate, graph_link, compile_setup). Even the exception pairs like session_context/session_handoff and message_mark_read follow the same convention. No camelCase or mixed verb styles appear.
47 tools is well into the 'too many' range and near the extreme end. While the server covers a genuinely broad domain (memory, tasks, projects, feeds, decisions, blueprints, events, compile mode), the surface is padded by a large deprecated cluster of message_* and task_* tools plus several overlapping memory/retrieval operations that could be consolidated.
The domain is comprehensively covered: memory has full CRUD plus search/list/delta, tasks have a complete lifecycle with dependencies, and projects, decisions, feeds, and blueprints each have create/read/delete coverage. Minor gaps exist (graph operations are limited to neighbor/link with no delete, and there is no non-deprecated messaging path), but agents can accomplish all core workflows without dead ends.
Maintenance
Related MCP Connectors
Memory, reflection and safety for AI agents. Hosted or local, no vector database.
One memory for your AI agents and your team: Claude, ChatGPT, Cursor and your agents share it.
Self-hostable shared brain for you and your AI agents — docs, flows, meetings, decisions, rationale
Hosted runtime for persistent agent teams, durable workflows, memory, schedules, and goals.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA production-ready MCP server that enables multiple AI agents to collaborate through a shared, concurrency-safe memory space. It supports advanced search, full CRUD operations, and automatic backups to facilitate asynchronous communication between agents.MIT
- AlicenseBqualityBmaintenanceProvides a shared context layer for AI agent teams to improve token efficiency through context deduplication and incremental state sharing. It enables multiple agents to coordinate tasks, share real-time discoveries, and manage dependencies while significantly reducing redundant data transmission.158MIT
- AlicenseAqualityDmaintenanceAn MCP server for managing agent memory using provenance tracking, decay-weighted retrieval, and feedback loops to optimize information recall. It allows agents to store insights in a local SQLite database and rank them based on confidence, age, and usefulness.444 npmMIT
- AlicenseAqualityBmaintenanceMCP-native, local-first memory for coding agents that turns real sessions into reusable decisions, gotchas, and domain knowledge.171,019 PyPI7MIT