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.
- 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.
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
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.
What this check looks forMatched text
description ends: "...op up or wait for the reset. A failed round is a normal result, not a tool error."
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.
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.
What this check looks forMatched 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)
Posture changes
- Nov 20, 2026
- Tools that change things, listed without credentials: 3 to 4
Findings
Matches of fixed checks, with the text they matched.
- Infowait_for_round
The description is 2,523 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...op up or wait for the reset. A failed round is a normal result, not a tool error."
History
Changes to its tool definitions and to its remote endpoint, newest first.
Tools1 changed.~1 changedView diff
- Changed:wait_for_roundOnly readsdescriptioninputSchema
Tools9 changed.~9 changedView diff
- Changed:append_roundChanges thingsdescriptioninputSchema
- Changed:ask_a_modelChanges thingsdescriptioninputSchema
- Changed:create_deliberationChanges thingsdescriptioninputSchema
- Changed:get_creditOnly readsdescriptionannotations
- Changed:get_sessionOnly readsdescriptioninputSchemaannotations
- Changed:list_modelsOnly readstitledescriptionannotations
- Changed:list_sessionsOnly readsannotations
- Changed:share_sessionChanges thingsdescriptioninputSchemaannotations
- Changed:wait_for_roundOnly readsdescriptioninputSchemaannotations
PostureRemote posture changed. Tools that change things, listed without credentials: 3 -> 4.View diff
- Tools that change things, listed without credentials: 3 to 4
Tools1 added, 2 changed.+1 added~2 changedView diff
- Added:ask_a_modelChanges things
- Changed:create_deliberationChanges thingsdescription
- Changed:wait_for_roundOnly readsdescription
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.
{
"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.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](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.