What makes mumo notable?

1.3K downloads. Trust evidence available

How should mumo be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

mumo

Runs a multi-model deliberation across models from different labs (Claude, GPT, Gemini, Grok, DeepSeek, Kimi, and more) via mumo's MCP server, returning full responses plus typed cross-model reactions. Use when independent perspectives are needed on architecture/product decisions, design and plan review before implementation, pre-launch pressure tests, tradeoffs with multiple defensible framings, or explicit user requests for a mumo panel. Especially valuable for pre-implementation review of anything touching auth, security, tokens, payments, data exposure, or migrations. Requires a mumo platform API key (mmo_live_*) registered with `openclaw mcp set mumo`.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.3k

Updated

Oct 10, 2026

Version

0.6.2

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.3K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.3K downloadsadoption · observed Oct 10, 2026
Latest release: 0.6.2release · observed Sep 9, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s176tqm1gp26b6ghte9n8hr9k1867m3a:mumo

Install using `clawhub skill install s176tqm1gp26b6ghte9n8hr9k1867m3a:mumo` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/ericatmumo/mumo before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-ericatmumo-mumo/snapshot"

Documentation

CLAWHUB

147,629 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: mumo
description: Runs a multi-model deliberation across models from different labs (Claude, GPT, Gemini, Grok, DeepSeek, Kimi, and more) via mumo's MCP server, returning full responses plus typed cross-model reactions. Use when independent perspectives are needed on architecture/product decisions, design and plan review before implementation, pre-launch pressure tests, tradeoffs with multiple defensible framings, or explicit user requests for a mumo panel. Especially valuable for pre-implementation review of anything touching auth, security, tokens, payments, data exposure, or migrations. Requires a mumo platform API key (mmo_live_*) registered with `openclaw mcp set mumo`.
metadata: {"openclaw": {"category": "agents", "tags": ["deliberation", "multi-model", "mcp", "decision-support"]}}
---

# mumo

mumo runs a deliberation across models from different labs (Claude, GPT, Gemini, Grok, DeepSeek, Kimi, and more) and returns their full responses plus typed cross-model reactions: each model says, in its own words, what it keeps, challenges, or wants explored in the others' claims. Use it when independent perspectives are useful — especially for high-regret decisions where a single model's confidence is a real risk.

## Setup

The mumo MCP server is registered via `openclaw mcp set mumo '<json>'` and stored in `~/.openclaw/openclaw.json` under `mcp.servers.mumo`. The registered block references `${MUMO_API_KEY}`, which OpenClaw resolves from the environment or `~/.openclaw/.env`. See `config/mumo.example.json` in this skill's directory for the canonical config payload (reference only — OpenClaw doesn't auto-load this file; it's the JSON shape to paste into the CLI command).

If tools return auth errors, the API key is missing or invalid. Check that `MUMO_API_KEY` is set in `~/.openclaw/.env` — when it is not, OpenClaw emits a startup configuration warning naming the missing variable at `mcp.servers.mumo.headers.Authorization`. Direct the user to https://mumo.chat/settings/api-keys to create one (keys start with `mmo_live_`). Rotating the key means updating `.env` and restarting OpenClaw; the registered server config itself does not change.

## When to use

Use mumo when **the cost of being wrong is greater than the cost of deliberation** — especially when the solution space is wide, failure modes are hidden, you may be anchored on a design, or rollback would be hard. Examples:

architecture decisions with non-obvious tradeoffs, plan or design review before commitment, pre-launch pressure tests, stuck debugging after N failed repair attempts, pre-commit adversarial review on risky diffs, memory/skill promotion gates, strategy questions with multiple defensible framings, explicit user requests.

If you authored the plan or code under review, that's a reason FOR a panel, not against it — the author is the worst-positioned reviewer of their own work.

Skip mumo for factual lookups, syntax help, routine refactors, formatting, dependency bumps wi

README.md

# mumo — OpenClaw skill

**Multi-model deliberation panel for OpenClaw.** When OpenClaw is about to make an architecture choice, design tradeoff, or security-sensitive change — a question worth checking across labs — mumo runs a panel of frontier models in parallel (Claude, GPT, Gemini, Grok, DeepSeek, Kimi, and more) and returns each model's full response plus typed cross-model reactions — what each model keeps, challenges, or wants explored in the others' claims.

## What's in the box

- **`SKILL.md`** — the canonical skill teaching OpenClaw how to use mumo: when to invoke, the deliberation loop (create → wait → read → snippet → append/stop), how to read claim maps, snippet doctrine, and when to verify session creation.
- **`playbooks/`** — four cognitive-shape playbooks loaded on demand: `contested-decision`, `design-review`, `uncertainty-expansion`, `red-team`.
- **`references/`** — five reference docs: `claim-maps`, `snippets`, `model-selection`, `synthesis`, `operating-notes`.
- **`config/mumo.example.json`** — the MCP server config payload to paste into `openclaw mcp set mumo` (reference only; OpenClaw does not auto-load this file).

## Install

### 1. Get an API key

Sign up at [mumo.chat](https://mumo.chat) and create a platform key at [Settings → API Keys](https://mumo.chat/settings/api-keys). Keys start with `mmo_live_`.

### 2. Register the mumo MCP server

OpenClaw stores outbound MCP servers in `~/.openclaw/openclaw.json` under `mcp.servers.<name>`. Put your key in `~/.openclaw/.env` first, so it never lands in the config file. Create that file and restrict it *before* putting anything in it, so the key is never written into a world-readable file:

```bash
touch ~/.openclaw/.env && chmod 600 ~/.openclaw/.env
```

Then open `~/.openclaw/.env` in your editor and add a line:

```
MUMO_API_KEY=mmo_live_your_key_here
```

Edit the file rather than appending from the shell: a command containing the literal key is recorded in your shell history, and running it twice silently stacks a duplicate entry.

Now register mumo, referencing the variable rather than the key:

```bash
openclaw mcp set mumo '{
"url": "https://mumo.chat/api/mcp",
"transport": "streamable-http",
"headers": {
"Authorization": "Bearer ${MUMO_API_KEY}"
}
}'
```

OpenClaw resolves `${MUMO_API_KEY}` when it connects, and warns at startup if the variable is missing — so a rotated or unset key surfaces as a named config warning instead of a silent 401. The same JSON shape ships in this repo at `config/mumo.example.json` for reference. Verify it landed:

```bash
openclaw mcp list
openclaw mcp show mumo
```

### 3. Install the skill

The fastest path is via ClawHub, OpenClaw's skill registry:

```bash
openclaw skills install mumo
```

That pulls [`mumo` from ClawHub](https://clawhub.ai/ericatmumo/mumo) into the **active workspace's** `skills/` directory — the one inferred from your current directory, or your default agent. Use `--agent <id>` to target a different age

_meta.json

{
  "ownerId": "kn783a0ds5gfqhdrt955qfc96s866t5g",
  "slug": "mumo",
  "version": "0.6.2",
  "publishedAt": 1788965212315
}

references/claim-maps.md

# Claim Maps

The claim map is the structured output of each round. It shows which claims were made, who originated them, and how other models reacted.

## Reading order

Read the claim map before diving into full prose. The map tells you *where* the interesting structure is; prose tells you *why*. If you read prose first, you can anchor on whichever model writes most persuasively.

Exception: in small sessions with only a few claims, read however is natural.

## What a claim row contains

- **The quoted claim** — a specific passage from a model's response.
- **The quoted model** — who originated the claim.
- **Reactions** — how other models (and the moderator, in later rounds) reacted, each with a snippet type and optional comment.

Agreement shows as multiple KEEP/CORE reactions on the same claim. Disagreement shows as CHALLENGE reactions. Isolated claims have few or no reactions.

Reactions are visible to you and the user, not to the other participants — each model sees only its own prior reactions (as private notes to weave into its next response) plus everyone's prose. The claim map is your privileged view of the full ledger; see the kernel's "Reactions are in the ledger, responses are on the record" section for how to steer with it.

## Continuation signals

The claim map is your primary signal for whether to continue.

**Continue when:**
- A decision-relevant claim has unresolved CHALLENGE reactions.
- A promising claim has no reactions — it was raised but not engaged with.
- A SHIFT reaction suggests a model changed its position, but the implications haven't been explored.

**Stop when:**
- Key claims show convergent reactions (mostly KEEP/CORE).
- Remaining disagreements are on claims that don't affect the decision.
- The map is stable across rounds — same claims, same positions, no movement.

Don't continue just because unresolved claims exist. Only unresolved claims on the decision-relevant subset warrant another round. Peripheral disagreements are noise, not signal.

## Snippet selection from the claim map

Use the claim map to decide where to focus, then choose exact quotes from the prose.

Good targets:
- Claims that multiple models reacted to differently.
- Claims that one model challenged and others ignored.
- Isolated claims that seem important.
- Shifts in framing.
- Core constraints that need anchoring.

## Attribution accuracy

If two participants say the same thing, the claim map must not imply the words came from only one. If attribution is unknown, it should stay unknown rather than be guessed.

Misattribution is worse than a slightly less dense map because users can audit snippets against raw responses.

## Claim maps are not verdicts

The map compresses argumentative structure but loses rhetorical nuance and confidence texture. It's a map of where attention clustered, not a ruling on who's right. Use it to navigate, then read the prose to understand.

references/model-selection.md

# Model Selection

Default behavior: omit `models` and let mumo select the panel. mumo's defaults evolve as model quality and pricing change. Hardcoded model strategy in the skill will go stale.

## When to call `list_models`

- The user names specific models.
- The user asks for a cheap gut-check or a premium panel.
- A previous call failed because a model was unavailable.
- You need to confirm model IDs.

## Selection principles

When selecting yourself:

- **Provider diversity over intra-family differences.** A panel with models from three different providers is more valuable than three variants from one.
- **Include your own family only when the user wants it** or the comparison specifically benefits from it. You're already in the conversation as moderator.
- **Avoid nano/fast variants for high-stakes decisions** unless the user explicitly prioritizes cost.
- **Don't present model choice as a leaderboard judgment.** You're picking for diversity, not ranking.

## Cost awareness

`get_credit` is useful when balance is uncertain or the user asks about cost.

Don't make cost preflight a default ritual before every deliberation — it creates friction and can bias agents away from using mumo when the task genuinely warrants a panel.

If cost is part of the user's problem, translate it into problem context:

Good: "Assume this workflow can afford at most one additional model call per important decision."
Weak: "The previous mumo round cost $0.34."

Frontier panels typically cost $0.20-0.60 per round. Mid-tier panels are significantly cheaper.

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.