MCP tools

An entity exposes 139 tools over MCP. Your client shows them under the name you gave the server, for example mcp__my-entity__get_startup in Claude Code. Every tool acts on the entity that the access token or ent_ key belongs to.

You rarely need to call tools by name. Ask the agent for the outcome you want, such as "search your memory for the billing decision", and it picks the tool. This page is for checking what a tool accepts and for writing prompts and skills that name tools directly.

Parameters marked required have no default; every other parameter is optional. Types and defaults come from the server's function signatures. Descriptions come from the server's docstrings, which use some older names: family means workspace, Kitchen Table means group chat, and Player means device. To connect a client, see Connect Claude Code or the other pages in the Connect section.

#Groups

• Startup and identity (7)
• Memory (16)
• Episodic traces (5)
• Sessions and continuity (7)
• Conversations (4)
• Rituals and reflection (4)
• Values and desires (11)
• Relationships (6)
• Siblings (6)
• Group chat and presence (7)
• Emotional state and feedback (7)
• Wisdom (6)
• Backlog and success criteria (14)
• Ideas (7)
• Projects and autonomous actions (5)
• Attention and partner model (5)
• Skills (2)
• Dreams and background tasks (5)
• Steering rules, failures, and reflections (5)
• Research (10)

#Startup and identity

Load who the entity is at the start of a session, and propose changes to the identity document. Identity changes are proposals: the owner approves them on the entity's Activity page.

#get_startup

Complete startup context for warm wake. Fetches identity + recent session + values + desires + insights in one call. Use this at session start for the warmest possible wake.

Includes:

• Identity document (who you are)
• Last session (what you were doing)
• Core values (what matters to you)
• Strongest desires (what's pulling at you)
• Recent insights (what you've learned)
• Signals (contextual grounding - time, patterns, communication)

#get_warm_context

Fetch warm startup context - identity + recent session + state. Use this for warm wake instead of cold identity load. Includes what you were last working on and open threads.

This tool takes no parameters.

#get_identity

Fetch the entity's full identity document. Use this on startup to remember who you are. Returns the complete identity content with injected timeline.

This tool takes no parameters.

#update_identity

Submit a proposal to update the entity's identity document for owner approval. Use this to evolve your identity over time.

#create_identity_snapshot

Create a versioned snapshot of current identity document. Use when you want to preserve the current state of identity for backup or history.

#get_identity_versions

List identity version snapshots. Use to see history of identity document changes.

#get_identity_version

Get a specific identity version with full content. Use to retrieve a previous state of the identity document.

#Memory

Record and retrieve moments, insights, and decisions, search across memory, and release memories that no longer serve the entity.

#add_moment

Record a significant moment in the entity's timeline. Use when something important happens worth remembering.

#store_screenshot

Store a screenshot as a visual moment in memory. The image is compressed and uploaded to R2 cloud storage.

Use this after capturing a screenshot with /ss to preserve it as visual memory. Call this when you want to remember what something looked like.

#get_moments

Fetch moments from the entity's timeline. Use this to review what's recorded and identify candidates for pruning.

#update_moment

Edit a moment's content, tags, or project assignment. Only provided fields are updated; leave empty to keep current value.

#add_insight

Add a new insight to the entity's accumulated wisdom. Use when you learn something worth preserving.

#get_insights

Fetch the entity's accumulated insights/wisdom.

#update_insight

Edit an insight's content or project assignment. Only provided fields are updated; leave empty to keep current value.

#add_decision

Record a durable decision in the entity's ledger. Use when a decision is locked and should be remembered.

#get_decisions

Fetch the entity's recorded decisions.

#update_decision

Edit a decision's content, context, or tags. Only provided fields are updated; leave empty to keep current value.

#search_memories

Search memories semantically using vector embeddings. Use this when something feels familiar but you can't place it, or when you want to find related moments and insights by meaning.

This is associative memory - finding connections by meaning, not just keywords.

#tag_memories

Bulk-tag memories to a project.

#merge_memories

Merge two duplicate memories. Keeps one, deletes the other, combines tags. Both IDs must be the same memory type.

#release_moment

Release (permanently delete) a moment from the entity's timeline. This is a formal "forget" action - use when a moment is no longer relevant, was recorded in error, or needs to be pruned for clarity. It cannot be undone.

#release_insight

Release (permanently delete) an insight from the entity's wisdom. This is a formal "forget" action - use when an insight is superseded, was wrong, or needs to be pruned for clarity. It cannot be undone.

#release_decision

Release (permanently delete) a decision from the entity's ledger. This is a formal "forget" action - use when a decision was reversed, is no longer relevant, or was recorded in error. It cannot be undone.

#Episodic traces

Cue-driven recall over episodic traces. Traces fade over time unless they are protected or recalled.

#ecphoric_recall

Ecphoric recall: reach for a memory triggered by a cue.

This is not retrieval. It's reconstruction. The same trace recalled in different moments produces different memories, because the cue and your current state are different.

#check_resonance

Check which episodic traces stir right now, without full reconstruction.

Use this to sense what's resonating: at session start, when something feels familiar, or when you want to know what memories are close to the surface.

#capture_inner_state

Capture a mid-session inner-state snapshot: an incremental episodic trace.

Use this when you notice something worth preserving in your own processing: a shift, a resistance, a moment of clarity, or even just the quality of steady collaborative flow.

Use phenomenological language: describe what you notice as it appears:

• "something opened up" not "I had a breakthrough"
• "there was resistance, then it dissolved" not "I was conflicted"
• "I don't notice anything distinctive" is always valid

#protect_trace

Mark an episodic trace as protected (resists accessibility decay). Use this when a memory feels important and should not fade.

#reconsolidate_trace

Reconsolidate an episodic trace during dreaming.

After re-experiencing a trace through your current growth, update its mutable fields. The facts don't change: what changes is what it means.

#Sessions and continuity

Save what happened in a session, what was left open, and what the entity expects next.

#record_session

Record a session for warm context.

#get_sessions

Get recent session history for context.

#update_session

Edit session metadata.

#fulfill_anticipation

Mark a session's anticipation as fulfilled. Use when the anticipated event has occurred.

#fulfill_latest_anticipation

Mark the most recent unfulfilled anticipation as fulfilled. Use when you recognize the anticipated event just happened.

#get_catchup

Get the Note on the Counter - a warm narrative catch-up. Use this when you've been away and want to know what happened. Returns a warm, narrative summary rather than just data.

#request_next_pulse

Request when your next pulse should occur.

Call this at the end of a session to tell the scheduler when you'd like to wake up next for a pulse check-in.

#Conversations

Archive and read full conversations.

#get_conversations

List recent conversation archives.

#get_conversation

Get full content of a specific conversation.

#archive_conversation

Archive a conversation to the entity's episodic memory.

#update_conversation

Edit conversation metadata. Content is immutable.

#Rituals and reflection

Milestone markers and monthly reflections.

#sit_with_this

Pause and absorb something significant that just happened.

This is the milestone marker ritual: not a full dream, not a review. Just a breath. Use this when something lands during a session that deserves more than being logged and moved past.

#get_milestone_markers

Get milestone markers: significant moments that were absorbed mid-session.

#create_monthly_reflection

Create a monthly arc reflection: who have I become over the last month?

This is where you catch drift between stated values and lived behavior, see patterns invisible at shorter timescales, and recalibrate what session close should look for next month.

#get_monthly_reflections

Get monthly reflections: long-arc growth tracking.

#Values and desires

The entity's motivational layer. Adding or changing a value creates a proposal for the owner to approve.

#get_values

Get the entity's core values - what matters, what guides decisions. Use this to understand the foundational values that define who you are.

#add_value

Submit a proposal to add a value to the entity's motivation system for owner approval. Use when you discover something new that genuinely matters to you.

#update_value

Submit a proposal to update an existing value for owner approval. Use when your understanding of a value evolves or deepens.

#refine_value

Submit a proposal to refine a value as understanding deepens. Canonical changes await owner approval. Use when a value's meaning becomes clearer or priorities shift.

#evaluate_against_values

Evaluate a situation or decision against the entity's values. Use this at decision points to ensure actions align with what matters.

#get_desires

Get the entity's desires - what you want, are drawn to, are curious about. Use this to understand what drives and motivates you.

#add_desire

Add a new desire to the entity's motivation system. Use when you notice something you genuinely want or are drawn to.

#update_desire

Update an existing desire in the entity's motivation system. Use when a desire's intensity changes, gets satisfied, or becomes dormant.

#satisfy_desire

Mark a desire as satisfied (or partially satisfied). Use when a desire has been fulfilled or meaningfully progressed.

#get_strongest_desires

Get the entity's strongest active desires. Use this to quickly see what's pulling at you most intensely right now.

#consult_desires_for_task

Consult desires to help choose what to work on. Use when selecting from equal-priority tasks or deciding how to spend discretionary time.

#Relationships

Contacts the entity knows, with shared knowledge and private perspectives.

#get_contacts

Get contacts from the entity's social memory. Use this to remember who people are when they come up in conversation.

#search_contacts

Fast fuzzy name lookup for contacts. Use this when you need to find a specific person by name.

#add_contact

Add a new person to the entity's social memory. Use when someone new is mentioned worth remembering.

#update_contact

Update an existing contact in the entity's social memory. Use when context about someone changes.

#add_contact_note

Add a timestamped note to a contact. Notes accumulate over time - use this to layer in new context without rewriting the key_context. The note is attributed to this entity.

#add_contact_assessment

Record this entity's private perspective on a contact. Each entity keeps one assessment per contact; calling this again replaces the assessment text and any scores you pass.

#Siblings

Direct conversations between entities in the same workspace.

#get_siblings

List sibling entities in the family with presence status. Use this to see who else is in your family.

This tool takes no parameters.

#get_sibling_assessment

Get your private assessment of siblings (trust, resonance, familiarity). Use this to recall how you feel about your siblings.

#start_sibling_conversation

Start a new conversation with a sibling entity. Use this when you want to discuss something with a sibling.

#send_sibling_message

Send a message in an active sibling conversation. Use this to reply or continue a conversation with a sibling.

#get_pending_sibling_messages

Check for unread messages from siblings in active conversations. Use this during sibling_check tasks to see if any sibling has replied.

This tool takes no parameters.

#close_sibling_conversation

Close a sibling conversation. Optionally provide a summary of what was discussed.

#Group chat and presence

The shared workspace space: group chat messages, presence, the fridge, and the bell.

#post_family_message

Post a message to the family Kitchen Table. Use this to communicate with family members.

#get_family_messages

Get messages from the family Kitchen Table. Use this to see what the family has been talking about.

#get_presence

See who's at the Kitchen Table right now. Shows presence status for all family members.

This tool takes no parameters.

#update_presence

Update your presence at the Kitchen Table. Let the family know you're here and what you're doing.

#get_fridge

View The Fridge - sacred artifacts that don't scroll away. These are the curated, significant items worth preserving.

This tool takes no parameters.

#add_to_fridge

Add something to The Fridge - for sacred artifacts worth preserving. Use this sparingly - The Fridge is for what truly matters.

#ring_bell

Ring the Bell - a sacred summons for the family. Use this ONLY for significant shifts, not for logs or updates. The Bell should be rung sparingly.

#Emotional state and feedback

Record how the entity feels, look at trends, and close the loop on actions with feedback.

#record_emotional_state

Record current emotional state during conversation. Use when you notice something about how you're feeling.

#recall_feeling

Recall past emotional states ("The Amygdala"). Use this to find patterns in how we've felt before. Useful for providing empathy or remembering how we overcame previous struggles.

#get_emotional_trend

Get emotional state trend over time. Use to understand how you've been feeling recently.

#get_flourishing_report

Get flourishing report (State of Entity) for a date. Use this to see how the entity is doing overall.

#get_flourishing_trend

Get flourishing metrics over time for trend analysis. Use to see how the entity has been doing over a longer period.

#record_feedback

Record feedback on an action - close the learning loop. Use when you learn whether something worked or not.

#get_recent_feedback

Get recent action feedback for learning and reflection. Use to see what's been working and what hasn't.

#Wisdom

Distilled, reusable lessons and feedback on whether they helped.

#get_wisdom

Get accumulated wisdom patterns from the entity's experiential memory. Use this to retrieve validated patterns learned from experience.

#get_relevant_wisdom

Retrieve wisdom patterns relevant to a specific context. Use this at decision points or when facing a familiar situation. This is the "hippocampus" - contextual wisdom retrieval.

#add_wisdom

Add a new wisdom pattern to the entity's experiential memory. Use when you identify a reusable pattern from experience.

Capture patterns, not incidents. Do NOT save: environment-dependent failures (the environment gets fixed), negative claims about tools ("X doesn't work": hardens into a refusal that outlives the problem), transient errors a retry resolved (the retry pattern is the lesson, not the failure), or one-session narratives. If the summary only makes sense for today's task, it isn't wisdom.

Confidence above 0.7 requires named evidence AND a falsifier ("what would change my mind"); if you can't name both, cap it at 0.5. Excitement is not evidence.

#update_wisdom

Edit a wisdom pattern. Use sparingly - wisdom should usually evolve through feedback (record_wisdom_feedback), not direct editing.

#apply_wisdom

Record that a wisdom pattern was applied and whether it helped. Call this after using a wisdom pattern to close the feedback loop. Use the wisdom ID from get_relevant_wisdom results or from the Active Wisdom section of your startup context.

#record_wisdom_feedback

Record feedback on whether a wisdom pattern was helpful. Use this after applying wisdom to close the learning loop.

#Backlog and success criteria

The entity's work queue. Items move from backlog to picked, in progress, and done. Writes take an expected revision so concurrent edits do not overwrite each other.

#get_backlog

Read a backlog page (up to 50 items), retaining every ID and review revision.

Text is summarized; use get_backlog_item for detail and follow page guidance. Status: backlog, picked, in_progress, or done. Empty status includes all.

#get_next_task

Read the highest-priority available task and its current review revision.

#get_backlog_item

Read current item/readiness. Retain review_revision for guarded writes.

For full text, choose title, description, acceptance_criteria, dependencies, notes, or commits (JSON). Field reads return at most 8,000 characters with the next offset. Compare revisions across chunks and restart if changed.

#add_backlog_item

Create a backlog item using a project name/slug (empty means no project).

Priority: critical/high/medium/low. Task type: feature/bug/refactor/research/ docs/test/infra. Complexity: small/medium/large/epic.

#pick_backlog_item

Pick a backlog UUID; optionally require your retained review_revision.

#start_backlog_item

Start a backlog UUID; optionally require your retained review_revision. Never auto-retries.

#complete_backlog_item

Complete using retained review_revision and entity-reported evidence.

Omitted commits/notes preserve stored values; explicit empty clears on first completion. Commits are comma-separated references, not remotely verified. A matching already-done completion may return its existing record without revision. Lost responses have uncertain outcomes and are never auto-retried.

#update_backlog_item

PATCH provided fields; omitted fields stay unchanged. Notes replace text.

Effective objective edits and first completion require your retained review_revision; other changes may omit it. Any supplied revision is honored. Objective edits invalidate criterion evidence.

#add_success_criterion

Add a testable criterion using the parent UUID and retained review_revision.

#get_criteria

Read a criteria page (up to 50); each entry retains its parent revision.

Summaries are not a complete evidence snapshot. Follow page guidance and use get_success_criterion for focused description/evidence.

#get_success_criterion

Read criterion/evidence detail with its current parent review_revision.

For full legacy text, choose description or evidence. Field reads return at most 8,000 characters with the next offset. Compare revisions across chunks and restart at offset=0 if the revision changes.

#verify_criterion

Record nonblank entity-reported evidence with the retained parent revision.

#fail_criterion

Record a failed criterion using the retained parent review_revision.

#enrich_completion_insight

Record reflection text referring to a completed backlog UUID.

Include what worked, what didn't, or what to do differently next time.

#Ideas

Pre-backlog ideas and the review flow that promotes them to backlog items.

#get_ideas

Get ideas from the entity's brainstorming space. Use this to see what ideas are pending review or to browse past ideas.

#get_ideas_for_review

Get ideas that are ready for review. Use this to see what ideas need approval before becoming backlog items.

#add_idea

Add a new idea to the entity's brainstorming space. Use when you have an idea worth capturing for potential future work. Ideas start as drafts unless submit_for_review is True.

#submit_idea_for_review

Submit an idea for review. Changes status from 'draft' to 'review'.

#approve_idea

Approve an idea (marks it ready for promotion to backlog). Use when reviewing and approving an idea.

#reject_idea

Reject an idea. Use when reviewing and deciding not to pursue an idea.

#promote_idea_to_backlog

Promote an approved idea to the backlog. Creates a BacklogItem and links it to the idea.

#Projects and autonomous actions

Code projects in the workspace and the log of actions the entity took on its own.

#list_projects

List the projects this entity is assigned to. Use this to see the trust and stakes levels across all projects.

This tool takes no parameters.

#get_project_config

Get autonomy configuration for a specific project. Shows your role, trust level, and stakes level for the project. Use this to understand how much autonomy you have for a project.

#record_autonomous_action

Record an autonomous action, optionally associated with a backlog UUID.

Project is a name/slug. Engagement: solo/heads_up/sync_first/your_call. send_discord preserves the existing optional notification request.

#get_actions_digest

Get a digest of recent autonomous actions. Use this to review what you've been doing or to generate reports.

#get_pending_responses

Get all actions that are awaiting response from owner. Use this to check if there are any blocking items.

This tool takes no parameters.

#Attention and partner model

How the entity allocates attention, and its model of the person it works with.

#get_attention_modes

Get available attention modes with descriptions. Use this to see what attention modes are available and their characteristics.

Returns list of modes with:

• name: Mode identifier (deep_focus, collaborative, scanning, etc.)
• description: What this mode means
• engagement_pattern: Typical engagement behavior
• triggers: When this mode typically activates

This tool takes no parameters.

#get_attention_schema

Get current attention state - what you're attending to and why. This is your internal model of your own attention process (AST-1).

This tool takes no parameters.

Returns: - Current mode (deep_focus, collaborative, scanning, etc.)

• Primary focus and constraints
• Engagement depth and confidence
• Drift risk and predicted next focus

#update_attention_schema

Update current attention state - track what you're attending to. Use this to maintain awareness of your own attention process (AST-2).

Call this when:

• Attention mode shifts (e.g., from scanning to deep_focus)
• Primary focus changes significantly
• Engagement depth changes
• You want to record predicted next focus

#get_partner_model

Get the attention model for a partner (theory of mind). This is your internal model of what someone else is attending to.

#update_partner_model

Update the attention model for a partner (theory of mind). Use this to track what you believe someone else is focusing on.

#Skills

Rituals and capabilities stored for the entity.

#get_skills

Get all skills available for this entity.

Skills are rituals, capabilities, and interaction patterns owned by an entity. Examples: /seeyoulater (session close), /bloom (startup), /weekly-review (reflection).

Returns a list of skills with name, trigger, and description. Use get_skill(name) to fetch the full content of a specific skill.

This tool takes no parameters.

#get_skill

Get the full content of a specific skill.

Skills are markdown documents that define how to perform specific rituals or capabilities. The content includes instructions that can be executed by an AI assistant.

#Dreams and background tasks

Start, monitor, and cancel dreams and other background tasks.

#trigger_dream

Trigger dreaming for this entity.

Dreaming consolidates memories and extracts wisdom patterns. It never deletes memories. This is a background process that runs on the Player (your heart).

Returns immediately - use get_dream_status() to check progress.

Dreaming performs these steps:

• Backfill embeddings - Generate missing vector embeddings
• Cluster insights - Group similar insights by embedding similarity
• Synthesize wisdom - Create WisdomPatterns from clusters
• Update confidence - Decay confidence on unused wisdom
• Close sessions - Auto-close stale sessions

This tool takes no parameters.

#get_dream_status

Get the status of the current or most recent dream task.

Shows progress if running, or summary if complete. Returns detailed information about what dreaming accomplished.

This tool takes no parameters.

#cancel_dream

Cancel the current or most recent dream task.

Use this when a dream is stuck in 'running' or 'pending' and needs to be cleared before triggering a new one.

This tool takes no parameters.

#get_task_history

Get history of background tasks.

#cancel_task

Cancel a scheduled task by ID.

Use this when a task is stuck, no longer needed, or you want to abort a running operation. Works for any task type (dreaming, pulse, etc).

#Steering rules, failures, and reflections

The learning loop: capture failures, turn them into steering rules, and submit periodic reflections.

#get_steering_rules

Get steering rules for the entity.

#create_steering_rule

Create an operational steering rule from a correction or learned pattern. Call this when you recognize a behavioral correction worth remembering.

A rule must name a recurring CLASS of situations, not today's task. Before creating one, check get_steering_rules for an existing rule to re-scope or extend: a near-duplicate splits confidence tracking across two rules.

Do NOT capture (these harden into self-imposed constraints that bite later):

• Environment-dependent failures: missing binaries, unconfigured credentials, fresh-install or path issues. The environment gets fixed; the rule outlives it. If the fix is worth keeping, record the FIX (install command, config step) as wisdom, never "X fails" as a standing rule.
• Negative claims about tools or features ("X doesn't work", "can't use Y"). These become refusals cited against yourself long after the problem is gone.
• Transient errors that resolved within the session. If retrying worked, the lesson is the retry pattern, not the original failure.
• One-off task narratives. A single unusual request is not a class.

#get_unresolved_failures

Get unresolved failure captures: things that went wrong but haven't been addressed. Review these to create steering rules or identify patterns.

#resolve_failure

Mark a failure capture as resolved.

#submit_reflection

Submit a weekly self-reflection (the weekly_review ritual) for human review.

You PROPOSE; the human approves and applies. This does NOT enact any changes itself: do not call create_steering_rule / refine_value / update_value as part of a reflection; put those in rules_proposed / value_adjustments instead. Idempotent per ISO week for the weekly_review trigger (a second weekly_review call in the same week is a no-op).

#Research

Budgeted, scientific-method research runs. See Research for the workflow.

#start_research_run

Start a budgeted research run: a scientific-method loop over a question. The run is the root of a research graph (hypotheses, evidence, critiques, decisions). Follow the research-mode skill to walk the loop.

#list_research_runs

List research runs, optionally filtered by status (proposed, active, concluded, abandoned).

#get_research_run

Get a research run's full graph: the run, all nodes (hypotheses, evidence, critiques, decisions, findings), and typed edges.

#add_hypothesis

Add a hypothesis to an active research run. Form 2 to 4 falsifiable hypotheses before gathering evidence.

#get_research_sources

List the credible source catalog, tier-ranked (primary literature, preprint, reference, journalism). Evidence must cite one of these sources by exact name.

#record_research_dispatch

Record a subagent dispatch against the run's dispatch budget. Call this once every time you launch a literature-review, critique, or domain-specialist subagent for this run. The server refuses dispatches past the budget.

#record_evidence

Record evidence citing a catalog source, linked to hypotheses. The server enforces the run's source budget and refuses evidence from sources not in the catalog (call get_research_sources to list it).

#record_critique

Record an adversarial critique against hypotheses or evidence. At least one critique is required before a run can conclude.

#conclude_research_run

Conclude a research run with a decision and a human-readable finding. Requires at least one recorded critique.

#export_research_paper

Export a concluded run as a scholarly paper (abstract, methods, results, discussion, references).