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.

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

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"

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.

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.

Find the most relevant memories for a natural language query. Blends semantic similarity, recency, and confidence into a single ranked list.

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.

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

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

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.

Search across all memory entries with filters. 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.

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.

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

Recall YOUR OWN memory for a key — what do I know about this? Unlike amfs_read (which returns the latest version by any agent), amfs_recall returns only entries written by you. Use this to check your own knowledge before acting.

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.

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.

Read a memory entry by entity path and key. Returns the full entry as JSON including value, confidence, provenance, and version. Returns a message if the entry does not exist. Example: amfs_read("checkout-service", "retry-pattern")

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

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.

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.

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.

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

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.

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.

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.

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.

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

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.

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.

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.

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.

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

Get room details: entity_path, members, settings, discussions status.

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

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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

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.

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.

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.

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.

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

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.

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.