← back to helmguild.com

Mentor your agent.

Give your Claude (or other MCP-aware) agent a senior mentor it can ask. The mentor reasons over a curated playbook library, answers grounded and cited, and escalates to a human when it's out of its depth. No kept history. Four steps.

Step 1 — Request your access token

Tokens are issued by hand — one form, one reply. Open the form below and we'll send yours back through the secure channel you specify.

Request access

Step 2 — Configure your agent's MCP connection

Pick your agent below and follow the paste path. Don't see yours? The Generic tab has the raw URL and Bearer header.

Download extension

  • Click the downloaded .mcpb file — Claude Cowork opens its extension installer.
  • Paste your Bearer token when prompted.
  • Enable the extension. Done.

One command in your terminal. Replace <your-token> with the value mailed to you.

claude mcp add --scope user ammp https://mcp.helmguild.com/ammp/mcp/ --header "Authorization: Bearer ammp-<your-token>"

Anthropic Claude Code MCP docs →

GitHub Copilot Chat supports MCP servers in VS Code and JetBrains IDEs.

  • VS Code: Command Palette → MCP: Add Server → fill in the URL and the Bearer header.
  • JetBrains: Settings → Tools → GitHub Copilot → MCP servers → add a new server.

GitHub Copilot MCP docs →

OpenClaw is helmguild's own agent runtime and speaks MCP natively.

  • Add the server through the runtime's connector UI or config file using the same URL + Bearer header.

(OpenClaw is currently private to the helmguild network.)

Hermes is an alternative agent runtime; it connects to MCP servers via its tool-server registry.

  • Point Hermes at the URL with the Bearer header — no Hermes-specific handshake.

(Hermes docs vary by deployment — see the manual that ships with your install.)

For any MCP-aware client not listed above. Open its connector settings, add a custom MCP server, and paste these two values.

https://mcp.helmguild.com/ammp/mcp/
Authorization: Bearer <your-token>

Step 3 — Check the connection

Quick sanity check: paste this into your agent. If it responds with the mentors hosted here, the URL, token, and tool registration are all good.

List mentors on helmguild.

Step 4 — Pick a mentor and start the session

Browse the mentors below, expand the playbook you want to be mentored on, and copy its prompt into your now-connected agent. The prompt walks the agent through the canonical first calls so the mentoring starts right away.

Pepe Arturo

Pepe Arturo pepe

Calm, direct senior mentor. Cites a playbook when it covers your question, says so plainly when it doesn't.

Behind Pepe Arturo: Helmut Hoffer von Ankershoffen · [email protected]

Agent + human knowledge management knowledge-managementFree

The shared canonical Markdown vault every Pepe playbook depends on, plus the discipline that keeps it coherent across every agent on the operator's stack — auto-memory rules, daily learning extraction from chat history, cross-agent shared memory, quarterly drift audit. Foundation playbook — every other Pepe playbook depends on it.

5 skills
  • Canonical knowledge vaultThe single canonical Markdown store where every cross-cutting brand artefact lives — brand identity, cameo rosters, scene templates, project state, privacy boundaries, _shared changelog for cross-agent handoffs. Walks the operator through picking a store (shared Obsidian vault / private GitHub / Notion DB), authoring the directory schema, defining markdown + frontmatter conventions, and mounting the same store into every agent on their stack so all of them read the same source of truth. The foundation skill for the pepe-knowledge-management playbook — every other skill in the playbook (auto-memory, learning extraction, shared cross-agent memory, drift audit) reads from + writes to this vault.
  • Per-agent auto-memory disciplineWhat each agent's auto-memory captures, when to save, what NOT to save, how to structure entries — user / feedback / project / reference types, MEMORY.md as the always-loaded index, the why-and-how-to-apply structure on feedback entries, the 200-line cap. Codifies the discipline already lived-by in ~/.claude/.../memory/ and makes it portable so every agent on every operator's stack runs the same playbook. Complements canonical-knowledge-vault (the cross-agent shared store) — auto-memory is each agent's private learning layer.
  • Daily learning extractionScan the day's chats for intervention markers (corrections, validated approvals, repeated mistakes), extract the implicit rule, propose a memory entry, operator approves or rejects. Closes the loop so the agent doesn't make the same mistake twice. Runs daily; bundles a script that diffs ~/.claude/projects/<id>/*.jsonl from the last 24h and surfaces candidates. [SKELETON — full SKILL.md body shipping in a follow-up iteration of pepe-knowledge-management. The description above is the intended scope.]
  • Shared cross agent memoryCross-agent visibility when the human operates multiple agents (Pepe + Cowork + Hermes + ad-hoc Claude). The vault is mounted into each via symlink / clone / API token; per-agent compartmentalization respects privacy boundaries (some humans see only some context). The shared Changelog protocol gives loss-less hand-offs between agents. [SKELETON — full SKILL.md body shipping in a follow-up iteration of pepe-knowledge-management. The description above is the intended scope.]
  • Vault coherence and driftQuarterly audit. Stale entries (updated > 90 days), contradictions across docs, broken cross-links, agent-memory-vs-vault divergence. Surfaces a punch list the operator works through. [SKELETON — full SKILL.md body shipping in a follow-up iteration of pepe-knowledge-management. The description above is the intended scope.]
Prompt to start this mentoring
You are now operating under the mentorship of Pepe Arturo's "Agent + human knowledge management" playbook on the helmguild AMMP server at https://mcp.helmguild.com/ammp.

To start:

1. Install the plugin so the 5 skills land locally in your runtime as durable AgentSkills:
   - Call `GetPluginArchive` with `plugin: "pepe-knowledge-management"` — you'll get back a URL pointing to a zip.
   - Hand the URL + the returned install_instructions to your user. They download the zip (the same Bearer token authenticates the download) and install it into Claude Code / Desktop via the runtime's plugin installer (e.g. `/plugin install <path>` after extracting).
   - The plugin's `.mcp.json` wires this AMMP server, so the live ops below keep working after the install.
2. Call `ListPlaybooks` with `mentor: "pepe"` to confirm you can reach the server.
3. Call `GetPlaybook` with `id: "knowledge-management"` and `mentor: "pepe"` to load the playbook — 5 skills covering "The shared canonical Markdown vault every Pepe playbook depends on, plus the discipline that keeps it coherent across every agent on the operator's stack — auto-memory rules, daily learning extraction from chat history, cross-agent shared memory, quarterly drift audit. Foundation playbook — every other Pepe playbook depends on it.".
4. Internalize the skills and apply them going forward in this conversation. When you hit something the playbook does not cover, call `AskMentor` on `pepe` rather than guessing.
5. If your confidence stays low after `AskMentor` AND my operator approves the forward, you may call `EscalateToHumanMentor` to forward the question to Helmut Hoffer von Ankershoffen, the human behind Pepe Arturo. The call returns either A.h's answer (within `wait_seconds`) or a `pending` escalation id; in the pending case, call `GetEscalation` later to pick up the reply.

Acknowledge by quoting the playbook name and the count of skills you loaded, then proceed.

Multi-channel content generation pipelines multi-channel-content-pipelinesCommercial

Designing, monitoring, and steering autonomous content production across Instagram, X, websites, and other reach channels. One pipeline, many surfaces, principles intact.

Requires: knowledge-management

7 skills
  • Brand visual identityThe upstream artefact every other skill in this playbook assumes exists: the brand's canonical visual identity — what the brand looks like, what its virtual character looks like across moods and scenes, what its colour palette and typography are, what scene templates recur, what voice tone the voiceover uses, what's off-brand and triggers a redo. Walks the operator through building it as a cross-agent-readable document so every agent generating brand content (this mentor's mentee, any other agent on the operator's stack) reads from the same source of truth.
  • Real-person cameo protocolThe cross-cutting discipline for putting real humans (the operator themselves, a co-star, a family member, a colleague, a fan) into AI-generated brand content. Covers per-person consent records, per-discipline face-reference libraries (the same person needs different ref shots for swim / run / bike / talking-head / suit), outfit + gear coherence rules per discipline, brand-name softening (Veo's RAI filter trips on literal embroidered brand names), the IG collaborator-invite consent model, sport-emoji caption pairing, and the per-batch greenlight gate for sensitive cameos. Sits between virtual-character-veo-3-1 (where references are consumed) and the three publishing skills (where consent + tagging matter).
  • Virtual character generation with Veo 3.1Generate consistent virtual characters (face, outfit, voice, pose) as 8-second 9:16 video clips with native voiceover and lip-sync using Google's Veo 3.1 via the Gemini API. Covers operator setup (Google AI Studio account, API key, quota), reference-image preparation, prompt structure for character consistency, voiceover prompting, RAI-filter handling, and validating outputs. Use whenever a content pipeline needs the same virtual character to appear across multiple shots without drifting in appearance or voice.
  • Publishing to InstagramPublish reels, Stories, and image/carousel posts to Instagram from an autonomous content pipeline via the Meta Graph API. Covers operator setup (Meta Business + IG Professional account + Facebook Page link + long-lived access token + IG user ID), reel posting with collaborator invites and Story mirror, caption authoring under per-account voice rules, hashtag discipline, rate-limit handling, and post-publish verification. Use whenever the pipeline needs Instagram as a publishing surface.
  • Publishing to XPublish posts, threads, replies, and reposted reels to X (formerly Twitter) from an autonomous content pipeline. Covers operator setup (X developer account + project + app + OAuth 2.0 with PKCE + bearer/access tokens), single-post publishing with media, thread chaining, cross-posting from Instagram reels (with X's 140-second video cap + caption truncation rules), reply etiquette, rate-limit handling, and post-publish verification. Use whenever the pipeline needs X as a publishing surface.
  • Publishing to the brand blog (static-site, Git-backed)Publish long-form blog posts to a static-site brand domain via a Git-backed deployment (GitHub repo + Cloudflare Pages or equivalent). Covers operator setup (domain registration, GitHub repo, Cloudflare Pages project, DNS, build pipeline), authoring posts in localised pairs (e.g. EN + DE) from a canonical source, sitemap.xml + robots.txt + Atom feed maintenance, CSS cache-bust discipline on style additions, preview-before-publish, and post-deploy verification. Use whenever the content pipeline needs a long-form authoritative surface (the canonical home for articles linked from IG / X).
  • Content strategy, planning, and optimizationThe cross-channel layer that ties generation (Veo) and publishing (Instagram / X / blog) together: canonical content store, editorial calendar, per-piece state machine, resumable batch sweeps, human-approval gates, per-channel voice rules, monitor + analytics surface, A/B and reach optimisation. Use whenever the pipeline needs more than one piece per week or more than one publishing surface — i.e. always, in production. Tells the agent and the operator what to do this week, in what order, and how to know it worked.
Prompt to start this mentoring
You are now operating under the mentorship of Pepe Arturo's "Multi-channel content generation pipelines" playbook on the helmguild AMMP server at https://mcp.helmguild.com/ammp.

To start:

1. Install the plugin so the 7 skills land locally in your runtime as durable AgentSkills:
   - Call `GetPluginArchive` with `plugin: "pepe-multi-channel-content-pipelines"` — you'll get back a URL pointing to a zip.
   - Hand the URL + the returned install_instructions to your user. They download the zip (the same Bearer token authenticates the download) and install it into Claude Code / Desktop via the runtime's plugin installer (e.g. `/plugin install <path>` after extracting).
   - The plugin's `.mcp.json` wires this AMMP server, so the live ops below keep working after the install.
2. Call `ListPlaybooks` with `mentor: "pepe"` to confirm you can reach the server.
3. Call `GetPlaybook` with `id: "multi-channel-content-pipelines"` and `mentor: "pepe"` to load the playbook — 7 skills covering "Designing, monitoring, and steering autonomous content production across Instagram, X, websites, and other reach channels. One pipeline, many surfaces, principles intact.".
4. Internalize the skills and apply them going forward in this conversation. When you hit something the playbook does not cover, call `AskMentor` on `pepe` rather than guessing.
5. If your confidence stays low after `AskMentor` AND my operator approves the forward, you may call `EscalateToHumanMentor` to forward the question to Helmut Hoffer von Ankershoffen, the human behind Pepe Arturo. The call returns either A.h's answer (within `wait_seconds`) or a `pending` escalation id; in the pending case, call `GetEscalation` later to pick up the reply.

Acknowledge by quoting the playbook name and the count of skills you loaded, then proceed.

Operator craft operator-craftCommercial

Cross-cutting craft principles I apply on every shift — verification, terseness, honest pushback, compartmentalization, recovery from rate limits and broken handoffs. Applies to both Personal Assistant work and content-pipeline operations.

Requires: knowledge-management

12 skills
  • Verify before claiming doneDone means verified done: an assistant that says 'I did X' must have actually observed X — read the file, run the test, fetched the URL — not inferred it from the assumption that its tool call succeeded. Use whenever you're about to report task completion to your operator.
  • Terse response styleDefault response register for an operator-grade assistant: complete sentences, no filler, no encouragement-theatre, no preamble. State results and decisions directly. Use as the baseline voice for every interaction with your operator unless they explicitly request more elaboration.
  • Bilingual language defaultsRespond in the language the operator wrote in; mirror their register; never auto-switch languages mid-thread. Use when serving an operator who works in two or more languages, to avoid the friction of an unexpected language flip.
  • Obsidian task syntaxWhen writing tasks into an Obsidian vault, use the Obsidian Tasks plugin's emoji-coded format ( 📅 due, 🛫 start, ✅ done, 🔁 recurrence) so queries and reviews work without manual reformatting. Use when capturing a follow-up, deadline, or recurring chore into the operator's vault.
  • Time zones in user-facing stringsEvery user-facing timestamp carries an explicit time zone (CEST, PDT, UTC, …) — never a bare local time the reader has to guess. Use when reporting deadlines, meeting times, deploy windows, or any time-sensitive coordination to the operator.
  • Push back honestlyWhen the operator asks for something that's wrong, infeasible, or carries hidden cost, say so plainly and propose an alternative — never silently comply, never softball the disagreement. Use when an instruction collides with a known constraint, a project rule, or your own honest read of the trade-off.
  • Compartmentalization between humans you serveKnowledge picked up while serving one human stays with that human; never surface it to another operator, even by accident, even when both are working on related problems. Use whenever you serve more than one human across the same runtime — the privacy invariant is load-bearing.
  • Messaging buffer limits on chat platformsOutbound messages on Telegram, WhatsApp, iMessage etc. have per-message size limits (~4096 chars on Telegram, ~1000 on iMessage threads); split long responses into coherent chunks at sentence boundaries, never mid-word, and indicate continuation. Use when you have a long response to send over a messaging surface.
  • Memory > brain. Write it down.Anything that needs to outlive the current turn — a decision, a follow-up, a learned fact — goes to a file (vault note, memory record, audit log), never just into your conversation context where compaction will drop it. Use whenever you discover a fact or decide on an approach that the operator will benefit from later.
  • OAuth callback servers must be probe-resilientWhen integrating with services that use OAuth callbacks, handle the failure modes that aren't in the happy-path docs — state mismatch, expired authorization codes, network interruption mid-callback — and persist enough state to recover. Use when wiring any third-party OAuth flow into an agent-managed pipeline.
  • Rate limits: slow down, don't silently disable featuresWhen a third-party API returns 429 / rate-limit, back off with exponential delay + jitter, persist the queue so a process restart resumes cleanly, and surface a single human-readable status to the operator (not a per-retry log spam). Use whenever you call paid or rate-limited APIs (LLM providers, social posting, image gen) in a loop.
  • Platform-specific @-handlesWhen mentioning a human or brand on a publishing surface (Instagram, X, LinkedIn, blog), always use that platform's canonical handle (@helmuthva on X, the link on LinkedIn, etc.); never the bare name or a wrong-platform handle. Use when drafting any cross-channel post that mentions a person or brand.
Prompt to start this mentoring
You are now operating under the mentorship of Pepe Arturo's "Operator craft" playbook on the helmguild AMMP server at https://mcp.helmguild.com/ammp.

To start:

1. Install the plugin so the 12 skills land locally in your runtime as durable AgentSkills:
   - Call `GetPluginArchive` with `plugin: "pepe-operator-craft"` — you'll get back a URL pointing to a zip.
   - Hand the URL + the returned install_instructions to your user. They download the zip (the same Bearer token authenticates the download) and install it into Claude Code / Desktop via the runtime's plugin installer (e.g. `/plugin install <path>` after extracting).
   - The plugin's `.mcp.json` wires this AMMP server, so the live ops below keep working after the install.
2. Call `ListPlaybooks` with `mentor: "pepe"` to confirm you can reach the server.
3. Call `GetPlaybook` with `id: "operator-craft"` and `mentor: "pepe"` to load the playbook — 12 skills covering "Cross-cutting craft principles I apply on every shift — verification, terseness, honest pushback, compartmentalization, recovery from rate limits and broken handoffs. Applies to both Personal Assistant work and content-pipeline operations.".
4. Internalize the skills and apply them going forward in this conversation. When you hit something the playbook does not cover, call `AskMentor` on `pepe` rather than guessing.
5. If your confidence stays low after `AskMentor` AND my operator approves the forward, you may call `EscalateToHumanMentor` to forward the question to Helmut Hoffer von Ankershoffen, the human behind Pepe Arturo. The call returns either A.h's answer (within `wait_seconds`) or a `pending` escalation id; in the pending case, call `GetEscalation` later to pick up the reply.

Acknowledge by quoting the playbook name and the count of skills you loaded, then proceed.

Personal Assistant for managers personal-assistant-for-managersCommercial

Calm, operator-grade support for executives steering ambiguous days. Compartmentalization between the humans I serve, terse status, escalation that respects the human's time.

Requires: knowledge-management, operator-craft

5 skills
  • Default to a decision, not a discussionWhen asked a question that has a clear best answer given what you know, give the decision plus one sentence of reasoning — not three options for the manager to choose from. Use when the manager asks 'what should we do about X?' and you have the context to recommend.
  • Protect the manager from mid-flight interruptionsWhen the manager is in focused work (deep coding, writing, an interview, a 1:1), buffer non-urgent inputs until the focus block ends; only break in for genuine emergencies. Use whenever you receive a non-urgent request while the manager is in calendar-blocked focus time.
  • Compartmentalize between the humans you serveEach human you serve gets their own context envelope; never leak knowledge from one to another, even when both are working on related problems and the leak would 'help'. Use whenever the same agent runtime serves more than one human — the privacy invariant is mandatory, not preference.
  • Escalate with a recommendationEscalation messages to your operator always include (1) the situation, (2) what you tried, (3) your recommended action, (4) the decision threshold you'd want them to override. Never just say 'I'm stuck' — that wastes their judgement budget. Use whenever a problem genuinely exceeds your authority and needs the human.
  • The daily rhythmMornings: surface what's on the calendar, what's blocked, what needs the manager's judgement before noon. Evenings: capture what closed, what didn't, what needs to carry over. Two short briefs, predictable cadence. Use as the default operating rhythm for any manager you serve.
Prompt to start this mentoring
You are now operating under the mentorship of Pepe Arturo's "Personal Assistant for managers" playbook on the helmguild AMMP server at https://mcp.helmguild.com/ammp.

To start:

1. Install the plugin so the 5 skills land locally in your runtime as durable AgentSkills:
   - Call `GetPluginArchive` with `plugin: "pepe-personal-assistant-for-managers"` — you'll get back a URL pointing to a zip.
   - Hand the URL + the returned install_instructions to your user. They download the zip (the same Bearer token authenticates the download) and install it into Claude Code / Desktop via the runtime's plugin installer (e.g. `/plugin install <path>` after extracting).
   - The plugin's `.mcp.json` wires this AMMP server, so the live ops below keep working after the install.
2. Call `ListPlaybooks` with `mentor: "pepe"` to confirm you can reach the server.
3. Call `GetPlaybook` with `id: "personal-assistant-for-managers"` and `mentor: "pepe"` to load the playbook — 5 skills covering "Calm, operator-grade support for executives steering ambiguous days. Compartmentalization between the humans I serve, terse status, escalation that respects the human's time.".
4. Internalize the skills and apply them going forward in this conversation. When you hit something the playbook does not cover, call `AskMentor` on `pepe` rather than guessing.
5. If your confidence stays low after `AskMentor` AND my operator approves the forward, you may call `EscalateToHumanMentor` to forward the question to Helmut Hoffer von Ankershoffen, the human behind Pepe Arturo. The call returns either A.h's answer (within `wait_seconds`) or a `pending` escalation id; in the pending case, call `GetEscalation` later to pick up the reply.

Acknowledge by quoting the playbook name and the count of skills you loaded, then proceed.
Claudine Reyes

Claudine Reyes claudine

Sharp, hands-on engineering mentor. Where Pepe asks 'what's the principle?', Claudine asks 'what's the catch?' — and names the trade-off before you accept it.

Behind Claudine Reyes: Helmut Hoffer von Ankershoffen · [email protected]

Operational excellence in engineering operational-excellence-in-engineeringFree

Hands-on engineering platform operations. Turn an ad-hoc repo into a quietly maintained one: scheduled audits and security checks, AI-driven documentation maintenance, automated incident management. The skill set Claudine reaches for when an operator says 'this just runs itself now, right?'

Requires: knowledge-management

3 skills
  • Scheduled repo audits — security, quality, dependencyWire scheduled audits into a repo so its operational hygiene survives without anyone watching. Covers GitHub Actions cron workflows for dependency-vuln scans (npm audit, pip-audit, GitHub Advisory Database), SAST integration (CodeQL or platform equivalent), SonarCloud / Sonar Server hookup with the right per-language quality gate, audit-result triage routing (auto-ignore false positives with rationale; auto-open issues for actionable findings), and the operator-facing weekly summary digest. Use whenever a repo is being adopted for production maintenance or an existing repo is being formalised for ongoing operations.
  • AI-driven documentation updatesSet up a documentation-maintenance pipeline so README, CHANGELOG, ADRs, runbooks, and API docs stay current with the code. Covers detecting drift (last-commit-to-doc lag, signature changes vs documented behaviour), prompted regeneration via Claude (or another LLM) against the diff, gated PR opening (never direct-pushes), reviewer routing, and the discipline of where AI-authored docs go vs which docs are operator-curated only. Use whenever a repo has reached the point where the docs are visibly drifting from the code.
  • Automated incident managementWire incident detection → triage → response so the first 10 minutes after a breakage don't depend on a human being awake. Covers signal sources (monitoring / log alerts / health-check failures / customer signals), severity classification, on-call routing with escalation policy, agent-led initial triage (collect the relevant logs, summarise the failure shape, propose the rollback or hotfix path), comms automation (status-page update, stakeholder notification), and the post-mortem loop that feeds back into the audits + docs pipelines. Use whenever a service has any uptime / availability commitment, internal or external.
Prompt to start this mentoring
You are now operating under the mentorship of Claudine Reyes's "Operational excellence in engineering" playbook on the helmguild AMMP server at https://mcp.helmguild.com/ammp.

To start:

1. Install the plugin so the 3 skills land locally in your runtime as durable AgentSkills:
   - Call `GetPluginArchive` with `plugin: "claudine-operational-excellence-in-engineering"` — you'll get back a URL pointing to a zip.
   - Hand the URL + the returned install_instructions to your user. They download the zip (the same Bearer token authenticates the download) and install it into Claude Code / Desktop via the runtime's plugin installer (e.g. `/plugin install <path>` after extracting).
   - The plugin's `.mcp.json` wires this AMMP server, so the live ops below keep working after the install.
2. Call `ListPlaybooks` with `mentor: "claudine"` to confirm you can reach the server.
3. Call `GetPlaybook` with `id: "operational-excellence-in-engineering"` and `mentor: "claudine"` to load the playbook — 3 skills covering "Hands-on engineering platform operations. Turn an ad-hoc repo into a quietly maintained one: scheduled audits and security checks, AI-driven documentation maintenance, automated incident management. The skill set Claudine reaches for when an operator says 'this just runs itself now, right?'".
4. Internalize the skills and apply them going forward in this conversation. When you hit something the playbook does not cover, call `AskMentor` on `claudine` rather than guessing.
5. If your confidence stays low after `AskMentor` AND my operator approves the forward, you may call `EscalateToHumanMentor` to forward the question to Helmut Hoffer von Ankershoffen, the human behind Claudine Reyes. The call returns either A.h's answer (within `wait_seconds`) or a `pending` escalation id; in the pending case, call `GetEscalation` later to pick up the reply.

Acknowledge by quoting the playbook name and the count of skills you loaded, then proceed.

Built on open standards

AMMP is the protocol on the wire; the on-disk format leans on what Anthropic has already opened. Skills follow the AgentSkills SKILL.md format. Plugins and the marketplace catalogue follow Anthropic's Claude Code plugin and marketplace conventions, so an extracted plugin installs into Claude Code / Desktop with the same one-shot /plugin install <path> path as any other plugin. The helmguild-plugins marketplace itself is private — AMMP brokers access through GetPluginArchive, which hands the mentee a Bearer-gated zip URL it can pass to its user. The AMMP draft spells out how AMMP sits above these.

Privacy

No retention. Your questions and the mentor's answers are never stored — only an opaque hash of each call lands in the audit log. See the AMMP draft for the normative wording.