Skip to content

mumo MCP server

chat.mumo/mcpmumo.chatstreamable-httpv1.4.0Scanned

Multi-model deliberation over MCP: full responses plus typed cross-model reactions from other labs.

9 tools: 4 change things and 5 only read.

Tools: 0 delete, 0 irreversible, 4 write, 5 read.
  • Reads private data · 0
  • Reads text others write · 4
  • Can send data out · 0
  • 1 finding

Tools listed without sign-in. Remote posture

With Anlyon

4 tools here change things. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the mumo MCP server can do

The mumo MCP server is published by mumo.chat, a domain the MCP Registry verified. It has 9 tools. It can create or change data (4 tools: create_deliberation, ask_a_model, append_round and share_session), but cannot delete data. 5 tools only read.

4 tools bring in text other people can write (create_deliberation, ask_a_model, append_round and 1 more).

The fixed checks matched 1 finding (long-description). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 3 times since Anlyon Radar first saw them.

Last scanned Nov 21, 2026, version 1.4.0.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

9 tools

Changes things 4Claude Code: ask
  • append_roundAdd a follow-up round to an existing deliberation session.Reads text others writeNo findings

    Why it is in this group

    • The description's first verb is "add": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Add a follow-up round to an existing deliberation session. Use after you have summarized the previous round for the user and they have agreed to another round. Suggest one when a contested point could change the answer; do not append on your own. The `snippets` array carries your own reactions: specific quotes from the prior round's responses, each with a type: - KEEP: this point is strong, preserve it - EXPLORE: dig deeper on this thread - CHALLENGE: push back on this claim - CORE: this is load-bearing, build on it - SHIFT: this reframes the question Models see your reactions as curated forwards and respond with full context. Use this to resolve disagreements, test claims, or direct attention to specific passages. To bring a model's reaction forward, react to the passage it is about: put that passage in `quote`, its author in `quoted_model`, and the point in `comment`. Participants never see each other's reactions unless the reacting model works its own note into a later response. Your reactions are the one way to put a point in front of the whole panel now, without waiting to see whether that model carries it. **Returns immediately (async).** The response is a short acknowledgement. Call `wait_for_round` with this `session_id` and the `round_id` from the acknowledgement to read the finished round. Only works on a session with no round in flight. If the latest round is still in progress, call `wait_for_round` first. After a failed round you can append again. Idempotency is automatic: an identical call within 24 hours returns the first call's acknowledgement and starts nothing (no second round, no second charge). So repeating a call is safe after a transport failure. To retry a round that failed, reword the prompt, or the call returns that first acknowledgement again.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • ask_a_modelPut a question to ONE model of your choice and get its answer.Reads text others writeNo findings

    Why it is in this group

    • The description's first verb is "put": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Put a question to ONE model of your choice and get its answer. Another lab's model typically makes for a better second opinion. This is not a deliberation: there are no other models, so there are no cross-model reactions. For structured disagreement between 2–3 models, use `create_deliberation` instead. **Returns immediately (async).** The response is a short acknowledgement with the `session_id` and `round_id`, NOT the answer. Call `wait_for_round` with both IDs to read it once the model finishes (typically 10–90s). The session continues like any other: `append_round` sends a follow-up to the same model, with the conversation so far. A session's models are fixed when it is created. To put the same exchange in front of a panel, call `create_deliberation` and pass the exchange in `reference`; for a second opinion from a different model, call `ask_a_model` again with that model. Idempotency is automatic — identical arguments within 24 hours return the same session (no second session, no second charge), so repeating a call is safe after a transport failure but does not ask the model again. A round where the model fails is refunded, usually within a minute.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • create_deliberationStart a multi-model AI deliberation on a question or decision.Reads text others writeNo findings

    Why it is in this group

    • The name "create_deliberation" says "create": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Start a multi-model AI deliberation on a question or decision. Runs the prompt through multiple frontier AI models in parallel and collects each model's typed reactions (KEEP/EXPLORE/CHALLENGE/CORE/SHIFT) to the others' claims, showing where they agree and diverge. **Returns immediately (async).** The response is a short acknowledgement with the `session_id` and `round_id`, NOT the finished deliberation. Models run in the background. Call `wait_for_round` with both IDs to read the round once it completes (typically 15–120s depending on model choice). MCP deliberations are agent-moderated: one round runs, you summarize it for the user, and you call `append_round` only after they agree to another round. There is no fixed round cap and no autonomous moderator on this surface. Use when you need structured disagreement from independent models, not a single synthesized answer. Ideal for spec review, architectural decisions, or any question where model diversity is a signal. For one outside opinion from a single model, use `ask_a_model` instead. Idempotency is automatic — the adapter derives a stable key from tool arguments, so repeat tool calls with identical args resolve to the same session for 24 hours (no second session, no second charge). A catastrophically-failed round (all providers errored) auto-refunds your budget within 60s; the round won't count against your daily cap.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • share_sessionShare a deliberation session at a public URL — anyone with the link can view it in the read-only reader deck.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Share a deliberation session at a public URL — anyone with the link can view it in the read-only reader deck. Returns the public link plus two machine-readable twins: a full-transcript `.md` link (with each round's reactions — the review/audit surface) and a `.brief.md` link (synthesis-only triage tier, ~1-2k tokens). Hand the full transcript to a reviewer model, or the public link to a human — no web UI required. Semantics: idempotent — re-calling returns the same URL. The link is a point-in-time snapshot: after appending rounds, call this again to refresh the page at the same URL. Sharing never changes the session itself and never lists the page in search engines or the public library (that elevation is a separate platform-curated step). Call when the user wants a shareable link or asks to publish/share results. Requires a registered (non-anonymous) mumo account; sharing generates any missing round takeaways first, so the first share of a long session can take ~15-30s.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Only reads 5Show 5 read-only tools
  • get_creditFetch the caller's current credit wallet balance.No findings

    Why it is in this group

    • The name "get_credit" says "get": a word for reading.
    Description, as the server wrote it
    Fetch the caller's current credit wallet balance. Returns the balance left to spend. At or below zero, every new round is refused until top-up or the monthly free-credit reset. Above zero, a round is admitted when the balance also covers that round's minimum (each model's reserved output plus input and the post-round reactions/takeaway). That is a per-request check, so a low positive balance can still refuse a large panel; the refusal states the minimum needed and, on `create_deliberation`, the rosters that fit. The per-model minimums shown here and in `list_models` are for reference. They do not gate admission.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • get_sessionFetch a deliberation session: every visible round (its reacted-to claims grouped as Contested, Open, Pivotal and Kept, the takeaway when one was requested, then the responses), fol…No findings

    Why it is in this group

    • The name "get_session" says "get": a word for reading.
    Description, as the server wrote it
    Fetch a deliberation session: every visible round (its reacted-to claims grouped as Contested, Open, Pivotal and Kept, the takeaway when one was requested, then the responses), followed by the session details. Use to re-read completed session state. While a round is running, prefer `wait_for_round` so you do not repeatedly fetch the full transcript. The grouped reactions on each round are the highest-signal view: which claims drew a reaction, who originated them, and what each reacting model said (KEEP/CHALLENGE/etc + their comment). Use them to identify unresolved disagreements before sending a follow-up. Participants never see each other's reactions, and as moderator you read them first: an advance view of what each model is weighing before any of it reaches prose. Use it to steer the next round (`append_round` explains how to bring a model's reaction forward). In later rounds, compare a round's reactions with the prose that followed to spot what was dropped.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • list_modelsList the full model catalog, sorted by what your account can use: available on your plan, available on a higher plan, and unavailable right now (with the reason).No findings

    Why it is in this group

    • The name "list_models" says "list": a word for reading.
    Description, as the server wrote it
    List the full model catalog, sorted by what your account can use: available on your plan, available on a higher plan, and unavailable right now (with the reason). Each model shows its id, provider, context window, max output tokens and pricing. Nothing is filtered out. It also shows your plan, how many models a panel seats, each model's family, and which model a family name resolves to for you. Call before `create_deliberation` or `ask_a_model` when the user wants one specific model, wants to compare prices, or asks what their plan includes. A family name such as `"claude"` or `"gpt"` works as a model without calling this first.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • list_sessionsList the caller's deliberation sessions, optionally filtered by status.No findings

    Why it is in this group

    • The name "list_sessions" says "list": a word for reading.
    Description, as the server wrote it
    List the caller's deliberation sessions, optionally filtered by status. Most useful for agents managing multiple concurrent sessions — use `status: 'ready'` to find sessions awaiting your next round. Returns a lightweight list (no response bodies); call `get_session` for full content.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • wait_for_roundWait for a deliberation round to finish, then return that round (not the whole session — `get_session` reads every round).1 finding

    Why it is in this group

    • The name "wait_for_round" says "wait": a word for reading.

    Findings

    • Info

      The description is 2,523 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...op up or wait for the reset. A failed round is a normal result, not a tool error."

      What this check looks for
    Description, as the server wrote it
    Wait for a deliberation round to finish, then return that round (not the whole session — `get_session` reads every round). This is the follow-up to `create_deliberation`, `ask_a_model` and `append_round`: those tools return a fast ack; this tool polls the lightweight progress endpoint internally and reads the finished round only once terminal state is reached. Use this instead of repeatedly calling `get_session` while models are running. Reactions are each model's notes to itself, guidance for its future responses; the other models have not seen them. The grouped reactions offer you privileged insight, helping to frame the next round. **Web-created rounds** (started from the mumo web UI rather than this API) resolve when all model responses have settled — round artifacts (reactions, takeaway) may still be generating at that moment. A finished round's `Web URL` line does not imply the reactions are ready; if it matters, re-check via `get_session` shortly after. **The result is text.** Line 2 is always `Action: <value>`, one of `proceed_with_complete_result` | `proceed_with_partial_result` | `poll_again` | `retry` | `abandon`; branch on it instead of parsing the rest. Line 3 names the session and round ids. The header of a finished round you can read also carries its `Web URL`. On `poll_again` (the wait timed out), call again as the action line says: with the `round_id` it names when the round has one, or with the same arguments when it names none. On `retry`, the round failed and its cost is refunded, usually within a minute: tell the user and offer to run it again. To run it again, call `append_round` with the prompt; if the failed round itself came from `append_round`, reword the prompt, because an identical call returns the first call's acknowledgement and starts nothing. On `abandon`, do not retry; report the failure to the user. One exception: a finished round you cannot read here (a closing round) comes back with no content and no link, may be complete, and says `abandon` without it being a failure — call `get_session` for the visible rounds; it may still carry `Issue:` lines for models that errored. Under the cost line, one `Issue:` line per model that failed (with its error code), was cut off, hit a cap (with its reason), was stopped by a safety or refusal finish reason, or was cut short by another provider content stop; a model capped by `balance` was cut short by remaining credit, so top up or wait for the reset. A failed round is a normal result, not a tool error.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data or outbound.

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write4
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out0
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 18:31 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
4
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
not observed
Authorization servers
not observed
Legacy HTTP+SSE transport
no
Dynamic client registration
not observed
Client ID metadata documents
not observed
  • WarnThe whole server

    The endpoint served tools/list without credentials, and the list has 4 tools that change things (4 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://mumo.chat/api/mcp: tools/list returned 9 tools to an anonymous client, including create_deliberation (write), ask_a_model (write), append_round (write), share_session (write)

    What this check looks for

Posture changes

  1. Nov 20, 2026
    • Tools that change things, listed without credentials: 3 to 4

Findings

Matches of fixed checks, with the text they matched.

1 info
  • The description is 2,523 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...op up or wait for the reset. A failed round is a normal result, not a tool error."

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. Tools1 changed.~1 changedView diff
  2. Tools9 changed.~9 changedView diff
  3. PostureRemote posture changed. Tools that change things, listed without credentials: 3 -> 4.View diff
    • Tools that change things, listed without credentials: 3 to 4
  4. Tools1 added, 2 changed.+1 added~2 changedView diff

Install

Pinned to version 1.4.0. Values in angle brackets are yours to fill in.

claude mcp add --transport http mumo https://mumo.chat/api/mcp --header 'Authorization: <your-authorization>'
claude mcp add --transport http mumo https://mumo.chat/api/mcp --header 'Authorization: <your-authorization>'

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__mumo__wait_for_round",
      "mcp__mumo__get_session",
      "mcp__mumo__list_sessions",
      "mcp__mumo__list_models",
      "mcp__mumo__get_credit"
    ],
    "ask": [
      "mcp__mumo__create_deliberation",
      "mcp__mumo__ask_a_model",
      "mcp__mumo__append_round",
      "mcp__mumo__share_session"
    ],
    "deny": []
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as mumo. Review it before you use it.

Capability tags behind 4 rules
  • mcp__mumo__create_deliberation untrusted-input
  • mcp__mumo__ask_a_model untrusted-input
  • mcp__mumo__append_round untrusted-input
  • mcp__mumo__share_session untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/chat.mumo/mcp/verify?hash=9e6dd071289e51679e00d517cea2a8f92be43736e4078b3f9a7cf7072737cb89" | jq -e '.changed == false'

Pinned hash 9e6dd071289e, from Nov 21, 2026, 19:17 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/chat.mumo/mcp/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for chat.mumo/mcp
[![Anlyon Radar](https://radar.anlyon.com/badge/chat.mumo/mcp.svg)](https://radar.anlyon.com/servers/chat.mumo/mcp)

Source: MCP Registry · repository. Synced Nov 21, 2026, 19:17 UTC.

mumo MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the mumo MCP server safe?

No scan can promise that. What its definitions show: 9 tools, 4 of which can change, send or delete something, and 1 finding from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the mumo MCP server delete data?

No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.

Can the mumo MCP server do things that cannot be undone?

No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.

What tools does the mumo MCP server have?

9 tools: 4 write, 5 read. create_deliberation, ask_a_model, append_round, share_session, wait_for_round, get_session, list_sessions, list_models and 1 more.

Does the mumo MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the mumo MCP server send data to outside services?

None of its tools sends, posts or publishes, or takes a recipient, channel or URL.

Has the mumo MCP server changed its tools?

Yes, 3 times since Anlyon Radar started tracking it, most recently on Nov 21, 2026. Every change is on this page and in its Atom feed.