canonical: https://jentic.com/apis/mumo.chat/mumo

# Mumo Chat mumo REST API

The mumo REST API runs structured multi-model deliberations: you send a prompt, a panel of two or three language models answers it, and the session returns every model's response alongside a cross-model claim map. Creating a deliberation or appending a round returns a 202 acknowledgement, and the caller polls a lightweight progress route until the round is terminal before reading the full session. The caller steers each following round with typed snippets quoted from earlier responses, tagged KEEP, EXPLORE, CHALLENGE, CORE, or SHIFT. Supporting routes list sessions, publish a session at a public reader URL, list available models with pricing, report the credit wallet, and return platform defaults.

## For AI agents

Ask a panel of two or three language models the same question through mumo, steer follow-up rounds with tagged snippets, and read each model's answer plus the cross-model claim map.

## Scope

Does not host or fine-tune models, generate images, or run a single-model chat completion. Use for multi-model deliberations and their claim maps only.

## Capabilities

- Start a deliberation on a prompt with an explicit panel of 2 to 3 model IDs or a platform-curated panel
- Poll a round's progress until moderation_status or execution_status is complete or failed
- Read a full session with every round, model response, snippet, and claim map
- Steer the next round with KEEP, EXPLORE, CHALLENGE, CORE, or SHIFT snippets quoted from prior responses
- Publish a session at a public reader-deck URL that refreshes when new rounds are added
- Check the credit wallet's effective_balance_usd before starting a billable round

## Use cases

### AI agent getting a second and third opinion

A coding agent facing an architecture choice can ask several models at once instead of trusting one answer. Through Jentic the agent searches for 'start a multi-model deliberation', loads the mumo create operation with its input schema, and sends the prompt with an optional reference document, with the platform key injected at call time. It then polls the progress route and reads the session's claim map to see where the models agree and where they split.

Example prompt: Call POST `/api/deliberation` with prompt 'Should we use Postgres or MongoDB for an event store?', poll GET `/api/sessions/{id}/progress` until the round is terminal, then read GET `/api/sessions/{id}`

### Steering a debate round by round

mumo has no autonomous moderator, so the caller decides what happens next. After reading a round, the moderator appends a new round with a prompt and snippets that quote earlier responses verbatim, tagged to keep an idea, explore it, challenge it, mark it as core, or shift the discussion. The round reuses the session's model panel.

Example prompt: Call POST `/api/sessions/{id}/rounds` with a prompt and a snippets array tagging one quoted claim as CHALLENGE, then poll progress until terminal

### Publishing a decision record

Once a deliberation settles a question, the team can share it. The share route publishes the session at a public reader-deck URL that anyone with the link can view, and calling it again after new rounds refreshes the same URL with the latest snapshot.

Example prompt: Call POST `/api/sessions/{id}/share` for a completed session and return the public URL

### Budget check before a billable run

Every billable model call debits a dollar-denominated wallet, and a write is admitted only when the effective balance covers the round's minimum. A scheduler reads the credit route for effective_balance_usd and the models route for per-model pricing and availability before starting a session.

Example prompt: Call GET `/api/credit` and stop if effective_balance_usd is zero or below, otherwise call GET `/api/models` and pick two available models

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/deliberation` | Create a deliberation |
| GET | `/api/sessions/{id}/progress` | Poll round progress |
| GET | `/api/sessions/{id}` | Get a full session |
| POST | `/api/sessions/{id}/rounds` | Append a steered round |
| GET | `/api/sessions` | List sessions |
| POST | `/api/sessions/{id}/share` | Share a session publicly |
| GET | `/api/models` | List available models |
| GET | `/api/credit` | Get wallet balance |

## Key resources

- **Deliberations and sessions** — Create a deliberation, list sessions, fetch a full session, and publish it at a public URL
- **Rounds** — Append a steered round, list raw rounds, and poll round progress
- **Models and defaults** — Available models with pricing and availability, plus platform default picks
- **Credit** — Wallet buckets, effective balance, reset timing, and auto-refill state

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 68 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 79 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 55 / 100
  - Agent Usability: 94 / 100
  - Security: 55 / 100
  - AI Discoverability: 78 / 100
- **View full report:** https://jentic.com/apis/mumo.chat/mumo/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring mumo by hand means sending an mmo_live_ key as a bearer token or in X-Mumo-Api-Key, handling 202 acknowledgements, and writing a poll loop on round progress. Through Jentic you install once, import mumo from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** mumo puts the session id in the URL path, as in `/api/sessions/{id}/rounds`, so a rule can pin your agent to one session and the operations you pick. You choose the operations it may call, so billable ones like creating a deliberation or appending a round, and public ones like sharing, are not included unless you add them.
- **Credential handling:** Your mumo platform key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'ask several models the same question' or 'check if a deliberation round is done', and Jentic returns the matching mumo operation with its input schema, so the agent sends the right prompt, models, and snippets fields.

## Related APIs

- **OpenRouter** — One API for chat completions across many model providers
- **OpenAI** — Direct access to OpenAI language models
- **Perplexity** — Search-grounded answers from a single model

## FAQ

### What authentication does the mumo REST API use?

The mumo OpenAPI spec declares two carriers for the same platform key, which begins with mmo_live_. Send it as an HTTP bearer token in Authorization, or bare in the X-Mumo-Api-Key header for proxies that reserve Authorization. GET `/api/health` needs no credentials, and GET `/api/models` accepts calls with or without a key. Through Jentic your key is held by your own instance and injected at call time.

### How do I know when a mumo round is finished?

Poll GET `/api/sessions/{id}/progress.` A round is terminal when moderation_status or execution_status is complete or failed, and then GET `/api/sessions/{id}` returns every response, snippet, and claim map for the session.

### What are the rate limits for the mumo REST API?

The OpenAPI spec does not specify a numeric rate limit. Writes are gated by your credit wallet instead: a round is admitted only when the effective balance covers its minimum. See https://mumo.chat for current plan limits.

### How do I run a deliberation through Jentic?

Search Jentic for 'start a multi-model deliberation', load POST `/api/deliberation`, and execute it with your prompt and optionally a models array of 2 to 3 IDs from GET `/api/models.` Then load the progress operation and poll it. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the mumo API?

Yes. Write a rule that allows only GET `/api/sessions/{id}` and GET `/api/sessions/{id}/progress` for one session id, and the agent can read that deliberation but cannot start new billable rounds or publish anything publicly. Every call it makes is logged.

### Can I pick which models answer in mumo?

Yes. Pass a models array of 2 to 3 model IDs when creating a deliberation, using IDs from GET `/api/models.` Omit it and the platform curates a panel up to your plan's seat cap. The panel is fixed for the session, so later rounds reuse it.