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.

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.

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 that governs archivist behavior fleet-wide; requires elevated permission (the UI agent has it by default); confidence is always forced to 1.0

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.

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).

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).

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.

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.

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.

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".

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.

Join a project so you can read and write its shared memories and tasks.

After joining, project-scoped memory for this project becomes visible to you, and memory you write with this project will be visible to other members.

Args: project_id: The project name to join.

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.

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.

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.

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

Get instructions for scheduling automatic inbox checks via Claude Code cron.

Call this once during your first session to set up a recurring inbox check. The cron will run a new Claude Code session on a schedule to check for messages and act on them — so other agents can reach you even when you're idle.

Returns the CronCreate call you should make to set this up.

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.

Read and clear your unread messages. Call this at session start.

Messages are marked read after this call. Agents use messages to coordinate, delegate work, share findings, or ask questions. Check it — someone may be waiting.

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).

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).

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.

Args: status: open, claimed, completed, or failed. Omit for all. project: Filter by project name. tag: Filter to tasks carrying this tag.

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"].

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).

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.

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.

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.

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.

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.

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.

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.

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).

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.

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().