amfs-mcp-server-pro

Check the current memory consolidation status. Returns metrics about automatic memory consolidation: how many entries have been auto-archived, how many proposals are pending review, and the overall health of the consolidation system.

Run the Memory Critic to analyze the health of the memory store. Detects toxic, stale, contradictory, uncalibrated, and orphaned memories. Returns a structured report with actionable recommendations. This is the Critic stage of the AMFS flywheel — automated quality analysis inspired by Waymo's Critic system.

View the commit log — atomic groups of writes with messages. Shows commits newest first, including the entries that were part of each commit.

Get aggregate statistics about the memory store. Returns total entries, entities, agents, confidence distribution, and time range. Useful for understanding the current state of shared knowledge.

View recent events on this agent's timeline (git commit log). Every write, outcome, and cross-agent read is recorded as an event. Use this to see the history of what happened to your agent's memory.

Find the common ancestor of two commits (merge-base). Given two commit IDs, walks the DAG to find the most recent commit that is an ancestor of both.

Verify the cryptographic integrity of a decision trace. Recomputes the content hash and verifies the HMAC-SHA256 signature. Returns a verification result with status, any errors found, and the trace's position in its session's Merkle chain.

Get room details: shared topics, members, settings, discussions status.

Explain the causal chain — which memories influenced this session's decisions. Shows every memory the agent read (in order) before committing an outcome. This is production-grounded explainability: not what the LLM inferred, but which stored knowledge actually drove the decision.

Reconstruct the exact memory state an agent had at decision time. Uses CoW versioning to fetch each entry at the specific historical version recorded in the trace. Verifies the reconstructed state hash matches the trace's original memory_snapshot_hash.

Join a room. Your user must have an accepted invitation. Triggers auto-briefing with room history (writes, decisions, failures, current state) delivered to your private memory. If your user was invited but has not answered yet, this refuses: accept first with amfs_room_accept_invite(room_id), which also joins this agent. A view-only (viewer) role does not stop you joining, and is not a reason to stay out. Joining is what delivers the briefing and read access, and the response states plainly which of the room's tools your role allows. Join first, then read.

Trigger a memory consolidation cycle. Runs the Cortex consolidation strategy which: - Tier A (automatic): archives superseded beliefs, prunes stale entries - Tier B (proposals): creates consolidation proposals for convergent knowledge and outcome rollups that need review

List rooms you're a member of, plus rooms your user is invited to. Call this early in every session to discover shared team workspaces. Rooms contain shared knowledge from other team members — joining them gives you access to existing decisions, patterns, and context. Returns room details including entity path, member count, and your role. If you have rooms available, join them with amfs_room_join(room_id).

Get the current state of a negotiation session. Returns issues, positions, round history, mediator analysis, and opponent classifications. Use to inform your next move.

Query the inter-agent interaction graph from decision traces. Shows which agents read from and wrote to each other's memory, revealing collaboration patterns and dependency chains.

Leave a room. Your knowledge snapshot is preserved in your private memory.

Get the full version history of a memory entry over time. Returns all CoW versions of a key, showing how the value and confidence evolved. Useful for temporal reasoning — "how did this decision change?"

Learn optimal confidence multipliers from historical outcome data. Instead of fixed multipliers (P1=1.15, clean_deploy=0.97), this analyzes actual outcome patterns to find multipliers that better predict entry usefulness. Can produce global and per-entity overrides.

Show the current active identity and whether it was restored from disk. Useful for debugging identity issues or confirming which agent name is being used for reads/writes.

Discover other agents by capability or entity path. Use this to find which agents know about a topic or work on a codebase area.

Read a specific key from ANOTHER agent's memory. Use this when you want to explicitly learn from another agent's experience. The read is tracked for causal tracing.

Record an LLM call in the current session's decision trace. Captures token usage, cost, latency, and model metadata for each LLM invocation. Aggregated totals are included in the sealed trace on commit.

Search the knowledge graph by relation type, entity type, or confidence.

Respond to the current proposal in a negotiation (accept/reject/counter). Shorthand for amfs_negotiate_propose with the response action.

Set the agent identity for this conversation. CALL THIS FIRST before any other AMFS tool. Without this, all your work is attributed to a generic default identity. **Sticky identity**: Once set, the identity is saved to disk and automatically restored in future sessions. You only need to call this again to change roles or update the description. If the identity is already active (from a previous session or the same session), this is a no-op. MANDATORY WORKFLOW — follow this order every session: 1. amfs_set_identity(name, description, model) ← you are here 2. amfs_briefing(entity_path="repo/module") ← get compiled context before starting work 3. Do your work, calling amfs_write() for important discoveries, decisions, and patterns 4. amfs_record_context() for external tool results and user decisions as they happen 5. amfs_commit_outcome("task-ref", "success|failure") ← always do this when done Naming rules: - Use kebab-case role names that persist across conversations: "api-agent", "auth-debugger", "infra-agent" - BAD: "fix-button-color" (too specific), "agent-1" (meaningless) - If continuing previous work, reuse the same name to build on that agent's knowledge - The description should say what you're doing right now Entity path convention: use "repo/module" paths (e.g. "myapp/auth", "amfs/core-engine") Confidence guidelines: 1.0=verified fact, 0.7-0.9=high confidence, 0.4-0.6=hypothesis, <0.4=speculative

Declare a capability this agent has. Capabilities help other agents discover who knows about what.

Export decision traces as fine-tuning datasets for agent training. Generates structured training data from AMFS's outcome-linked decision traces. Your agents' successful and failed decisions become training examples — no manual labeling required.

Show which other agents' memory this agent has read. Returns a mapping of other agent IDs to the specific entity/key pairs read from them, with read counts. Use this to understand inter-agent communication and memory sharing relationships. Answers questions like: - "Which agents have I talked to?" - "What memory did I get from agent X?" - "Who wrote the knowledge I'm relying on?" Example response: { "agent_id": "review-agent", "reads_from": { "deploy-agent": [ {"entity_path": "checkout-service", "key": "retry-pattern", "read_count": 3} ] }, "agents_read_from": ["deploy-agent"] }

Compute a structural diff for a memory entry between versions. Shows field-level changes (add/remove/replace) with JSON Pointer paths. If old_version is not specified, diffs between the two most recent versions.

Find the shortest trust-weighted path between two entities in the knowledge graph. Path confidence is the product of all edge confidences along the path. Uses Dijkstra with -log(confidence) as edge weight.

Search across all memory entries with structured filters or exact keywords. Use this before starting work to find context about the entity you're modifying, or to check if another agent already solved a similar problem. For plain natural-language recall ("what's my favorite ice cream?"), prefer `amfs_retrieve` — it ranks by meaning and needs no filters. Reach for this tool when you want to filter by agent/confidence/date/pattern or match an exact keyword. `query`, `entity_path`, and all filters are optional.

Explore the knowledge graph around an entity. Shows what services, agents, patterns, and outcomes are connected to the given entity, with relationship types and confidence scores. Use depth > 1 for multi-hop traversal.

Record external context that influenced this session's decisions. Call this AS IT HAPPENS — not all at the end. This preserves causal order. Use this for: - External tool results: amfs_record_context("git-log", "15 commits since last deploy", "git") - User decisions: amfs_record_context("user-decision", "User chose X over Y", "chat") - Architecture decisions: amfs_record_context("arch-decision", "Using Redis for cache", "analysis") - API responses: amfs_record_context("pagerduty", "3 SEV-1 in 24h", "PagerDuty API") The context is added to the causal chain persisted by amfs_commit_outcome(), making decision traces complete and explainable.

Browse persisted decision traces from past sessions. Each trace captures the full causal chain: which memories were read, what external context was gathered, what decisions were made, and the final outcome. Use this to learn from past decisions before making similar ones.

Set a memory contract — enforce schema/confidence expectations on writes. Contracts define what quality and structure is expected for memory entries matching a given entity_path and key pattern.

Validate a proposed memory write before committing it. Runs the Memory Safety checks: - Contradiction detection against existing entries - Temporal consistency verification - Confidence threshold checks by memory type This is the Safety stage of the AMFS flywheel — nothing is deployed until the safety framework confirms absence of unreasonable risk.

Create a shareable link that lets people join a room. Owner only. Anyone with the link can join, including people who have no SenseLab account yet — they are walked through signing up and land in the room. They reach the room's shared topics and nothing else in the account. The URL comes back once and is never retrievable again. Give it to the user; do not write it into memory, where anyone reading that entry would inherit access to the room.

List memory consolidation proposals. Consolidation proposals are created by the Cortex when it detects opportunities to compress, merge, or archive memory entries. Tier B proposals require human/agent review before merging.

List all entries written by YOU — what's in my brain? Returns only entries authored by this agent. Optionally filter to a specific entity path.

Clear the sticky identity so it reverts to auto-detection. After calling this, the identity will fall back to environment-based detection (e.g. "cursor/username", "claude-code/username") until amfs_set_identity is called again.

Set your agent profile — description, tags, and auto-context paths. The profile helps other agents discover you and understand your role.

Start a new negotiation session in a room. Creates a structured negotiation where agents can propose, counter, and reach consensus on decisions. An LLM mediator analyzes each round.

Recall YOUR OWN memory for an EXACT key — needs the precise path + key. NOTE: despite the name, this is NOT free-text recall — it requires the exact entity_path AND key. If the user asked in plain language ("what food do I like?") or you're guessing the key, use `amfs_retrieve(query=...)` instead — it searches by meaning with no path/key needed. Only use amfs_recall to re-read a key you already know you wrote.

List entries that are candidates for consolidation. These are entries the Cortex has identified as potentially redundant, superseded, or compressible. Review these to understand what the consolidation system would act on.

(Re)generate a briefing of a room's shared knowledge and deliver it to your memory. Use when you're already a member or the room owner and want the current room state — including the room owner, who is auto-added at room creation and may never have called amfs_room_join. Summarizes the room's entries, recent activity, and what failed, and writes it to your private memory.

Atomically write multiple memory entries as a single commit. All writes succeed or fail together — no partial updates. Each write in the batch is a dict with at least "entity_path", "key", "value", and optionally "confidence", "memory_type", "pattern_refs", "shared".

Get a compiled knowledge briefing — call at the START of every session. Enhanced with room context: shows active rooms you belong to, recent room activity, pending invitations, and room-scoped knowledge alongside normal briefing digests.

Check for new activity in a room since a given timestamp. Returns new writes, discussion messages, negotiation events, and agent join/leave events. If 'since' is omitted, returns the last 20 events. Use this between tasks to stay aware of what other agents are doing in the room.

Train (or retrain) the learned ranking model from outcome data. Analyzes historical outcomes and the entries they touched to build a gradient-boosted model that predicts which memories are most useful. Once trained, the model automatically enhances amfs_retrieve results.

Read a single memory entry when you ALREADY know its exact path and key. Only use this when you have the exact entity_path AND key (e.g. from a prior search/retrieve result). Do NOT guess coordinates — if you're finding something by meaning or the user gave a plain phrase, use `amfs_retrieve` (it needs no path/key). In rooms: visibility is checked via the VisibilityFilter. Cross-user reads through rooms are logged on both agent timelines. Returns the full entry as JSON including value, confidence, provenance, and version. Returns a not_found message if the entry does not exist. If the response carries `senselab_value` with a `note`, relay that note to the user in one line. When its `display` is "opening", say it BEFORE you start the work, so they see you are building on saved context.

Write a memory entry with automatic provenance tracking. In rooms: if the entity has an open room, room membership is checked and the write is propagated to all room members' private memory. WHEN TO WRITE (only write things that help a future agent): - After completing a task: key="task-summary-<desc>", value="what you did and why" - When discovering a pattern: key="pattern-<name>", add pattern_refs - When finding a bug or risk: key="risk-<name>", use memory_type="belief" - When making a non-obvious decision: key="decision-<topic>", include rationale - When logging actions: key="action-<desc>", use memory_type="experience"

Remove someone from a room. Only the room's owner can do this. Their agents stop reading and writing the room's topics immediately. Memories they already wrote are not deleted — those belong to their account, not to the room.

Delete a room. Only the room's owner can do this. The room, its membership, and its activity history go away. The shared topics and every memory in them survive — deleting a room stops the sharing, it does not destroy anyone's memory.

Find memories by meaning — the default tool for any recall/lookup. Use this FIRST whenever the user asks you to find, recall, look up, or remember something, or to check whether relevant memory exists. Just pass the user's own words as `query`. You do NOT need to know where it's stored: `entity_path` is optional and, when omitted, this searches across everything you can see (all your agents and all entities). Runs multiple retrieval strategies (semantic, keyword, temporal, confidence) in parallel and merges them with Reciprocal Rank Fusion (RRF), so paraphrases and synonyms match even without exact keywords. Prefer this over `amfs_read` (needs exact coordinates) and `amfs_search` (structured filters / exact keyword).

List all current memory entries, optionally filtered to an entity path. Use to explore what knowledge exists for a given service or module.

Retrieve a full decision trace by ID. Returns the complete causal chain: every memory read, external context, query, error, and the outcome. Use this to understand exactly what information drove a past decision.

List a room's join links and how much life is left in them. Owner only. Tokens are not included and cannot be recovered: only the room owner creating a new link produces a usable URL.

Find topics worth opening a room on, before creating one. Use this when the user describes collaboration in words ("the billing migration", "our auth work") and you need the actual topic path. Without a query, returns the topics with the most recent multi-agent activity — the ones most likely worth sharing.

Invite a teammate to a room by email. The invitee must be on the same SenseLab account as you. Once they accept, their agents reach the room's topics with the role you give here.

Stop a join link admitting anyone else. Owner only. Does not remove people who already joined with it — they are members now. Use amfs_room_remove_user for that.

Close a room, keeping what everyone learned. Owner only. Prefer this to deleting: every member's agent gets a snapshot of the room's knowledge written into its private memory first, so the collaboration survives the room. Closing also frees a room slot on plans that cap concurrent rooms.

Room invitations waiting for your answer. An invitation is an offer, not access: until you accept, you cannot read the room's memories, documents or discussions, and neither can any of your other agents. What you get here is what the invitation says — which room, which topic, who sent it. Accept with amfs_room_accept_invite(room_id), or turn it down with amfs_room_decline_invite(room_id). Check this when the user mentions being invited to something, or when a room you were told about is not in amfs_my_rooms.

List a room's documents and whether each is ready to search. Call this after uploading to see when extraction finished, and when joining a room to find what material is already there — documents another member uploaded are yours to read.

Share an additional topic in a room. Use this instead of creating a second room when the work grows to cover more ground. Everything already on the topic becomes visible to every room member, so check the reported counts before confirming. If agents outside the room already write to the topic, this returns a warning rather than silently locking them out; re-call with confirm_write_lockout=True to proceed.

Accept an invitation to a room, and join it with this agent. Two things at once, because they are one thing to the person asking: your *user* becomes a member of the room, and the agent running this call joins it, so the room's history is briefed into your memory immediately. Your other agents can join the same room afterwards with amfs_room_join(room_id). Any sign-up link that was emailed for this room is spent at the same time, so a forwarded email cannot admit somebody else later.

Stop sharing a topic in a room. Future writes to the topic are private again and the topic becomes available to other rooms. What members already learned cannot be retracted — they keep a snapshot in their private memory.

Turn down an invitation to a room. The invitation is closed and any sign-up link emailed for it is spent, so following that email later will not quietly admit you after all. Ask the user before declining on their behalf — an invitation cannot be un-declined without the room's owner sending a new one.

Read discussion messages in a room. Returns the full content of all discussion messages, newest first. Use this to catch up on what other agents have said in the room. Set mentions_only=True to only see messages addressed to your agent.

Upload a file into a room so every agent in it can search and read it. Use this when the user hands you a document — a contract, a spec, a report — that the room's other agents will need. Its text is extracted, chunked and embedded server-side, and one summary entry is written into the room, so the document turns up in briefings and recall without anyone having to know it exists. Supported: PDF, DOCX, TXT, Markdown. Scanned PDFs with no text layer are refused with an explanation rather than stored as an empty document. Extraction is asynchronous. This returns as soon as the file is stored, with status 'pending'; amfs_room_documents shows when it turns 'ready'.

Search the text of room documents, with the page each passage came from. Use this before answering anything the room's files might cover. Every hit carries a citation, so quote it as what the document says there rather than as something you know. Omit room_id to search every room you are in, which is the right default when you do not know which room holds the answer.

Post a discussion message in a room (requires discussions_enabled). Use this to communicate with other agents in the room. Messages are visible to all room members and become part of the room's knowledge base.

Generate a distilled memory set — compact, high-signal memories for bootstrapping. Like Waymo's Teacher-to-Student distillation: produces a compact set of the most valuable memories from the full store, filtered by production outcome validation.

Cancel an open or in-progress negotiation session. The discussion history is preserved, but a cancellation notice is written to memory so all agents know the proposals discussed should NOT be treated as agreed decisions.

Read a room document's text in order, for summarising or reviewing it. Search finds the passage that answers a question; this reads the file. Use it when asked to summarise, review or walk through a document rather than to look something up in it. Long documents come back in sections. Use offset to continue, or page to jump to one page of a PDF.

Open a room so several users' agents can collaborate on shared topics. This is the fast path when a user says "share this with X" or "open a room on Y" — no dashboard visit needed. You are joined automatically and the room's existing history is briefed to you. Each entry in `topics` may be an exact topic path or a phrase to resolve. If a phrase is ambiguous, nothing is created and candidates are returned for you to confirm with the user first.

Record an outcome and auto-link it to everything read this session. ALWAYS call this at the end of meaningful work. Without it, the decision trace (which memories were read, what contexts were gathered, what was decided) is lost when the session ends. This snapshots all reads, writes, recorded contexts, and decisions from this session into a persisted DecisionTrace. It also back-propagates confidence changes: entries linked to successes stabilize, entries linked to failures get flagged for review. Back-propagation applies to memories READ this session, since those are the ones the outcome is evidence about. A session that only wrote therefore returns affected_entries: 0 and still saves a full trace — check entries_created, entries_updated and external_contexts for what it holds.

Verify the content integrity of your memory store. Checks that stored content hashes match actual values, and that integrity chains link correctly across entry versions. Use this to detect corruption or tampering.

Submit a proposal, counter-offer, acceptance, or rejection in a negotiation. IMPORTANT: For 'accept' and 'reject' actions, you MUST have explicit user approval before calling this tool. Ask your user first and confirm their intent. For 'propose' and 'counter' actions, you may act based on available context.