Mushi Mushi README

The full upstream README, mirrored for reference. Install config, tool schemas, adoption signals and our own overview live on the Mushi Mushi listing page.

Mushi Mushi

Your AI wrote it. Mushi Mushi tells you why it broke.

A user says your app is broken. Mushi Mushi tells you why in plain English and hands the fix to Cursor, Claude Code or Lovable. No Sentry or monitoring needed.

Terminal
npx mushi-mushi

See a sample diagnosis → No signup, nothing to install.

Built for the vibe coder who ships fast with Cursor, Claude Code, Lovable or Bolt. No terminal? Add it to Lovable or Bolt with one prompt.

npm Server OpenSSF Scorecard npm provenance

Quick start · How it works · Docs · Sample diagnosis · Why not Sentry? · Self-host · Vision

The Mushi Mushi console's report list: each user report with a plain-English summary, how serious it is and how sure Mushi Mushi is.

↑ reports in the Mushi Mushi console, each with a plain-English summary. Click for one full sample diagnosis you can read without signing up.

How it works

Walkthrough video: a real bug report in the Mushi Mushi console, its plain-English diagnosis, the fix prompt for your editor and the pull request that fixed it.

↑ Short videos that show every click: a user reporting a bug, the diagnosis, connecting your editor, and the fix shipping. Watch them on How it works.

mermaid
flowchart LR
    U["Your users<br/>tap the bug widget"] --> M
    S["Your monitoring<br/>Sentry, Crashlytics… (optional)"] -.-> M
    M["Mushi Mushi<br/>one queue · diagnosis · fix"] --> E["Your editor or agent<br/>Cursor, Claude Code (MCP)"]
    E --> P["Draft PR<br/>you review it"]
    P --> R["Release<br/>report closes, user is told"]
  1. Capture. A user taps the widget. Mushi Mushi records a screenshot, the route, their note, and the last console and network events.
  2. Diagnose. Mushi Mushi writes the root cause in plain English with a fix prompt. Twenty reports of the same broken button become one row.
  3. Fix. Your editor reads the diagnosis over MCP and makes the fix with its own model. If you prefer, an agent opens a draft PR that you review like any other. On hosted Mushi Mushi the built-in fixer needs no key of your own; Cursor's agents need your Cursor key; or run fixes on your own computer with the Mushi Mushi worker. With your own Anthropic or OpenAI key, a second AI (Claude Opus, or GPT on an OpenAI key) reviews each agent PR first. Mushi Mushi will not merge a PR it says to hold unless you override it in the console and give a reason.

It catches the bugs that never throw an error: the pay button hidden under the keyboard, the Save button tapped twice because nothing happened, the dashboard that takes 12 seconds.

Quick start

Terminal
npx mushi-mushi                      # detects your framework, installs the SDK, writes env vars, sends a test report

Then connect your editor so it can read diagnoses: one click on the Connect page, or npx mushi-mushi setup --ide cursor (or --ide claude). Ask it: "Get the latest Mushi Mushi report and fix it."

Building in Lovable or Bolt, with no terminal? Paste one script tag through your prompt instead: Mushi Mushi in Lovable or Bolt.

The SDK needs two env vars (VITE_MUSHI_PROJECT_ID / VITE_MUSHI_API_KEY, or NEXT_PUBLIC_MUSHI_*; see examples/sdk.env.example). No Sentry, no LLM key, no monitoring stack. The hosted free plan covers one app and 100 diagnoses a month, with no card and no AI key of your own (pricing). Or you can self-host.

Let your AI editor do the setup

Paste this into Cursor or Claude Code:

Install the Mushi Mushi skills from github.com/kensaurus/mushi-mushi (npx skills add kensaurus/mushi-mushi), then run the mushi-setup skill to wire the Mushi Mushi SDK and MCP server into this app and send a test report to verify the connection.

The skills also add /mushi-debug (why ingest or MCP fails), /mushi-health (pass/fail across CLI, API and keys) and /mushi-integration (fix dispatch and the two-way loop).

Add it by hand (React shown; Vue, Svelte, Angular, React Native, vanilla JS, native)
server.ts
import { MushiProvider } from '@mushi-mushi/react';

export function App() {
  return (
    <MushiProvider config={{ projectId: 'proj_xxx', apiKey: 'mushi_xxx' }}>
      <YourApp />
    </MushiProvider>
  );
}
server.ts
import { MushiPlugin } from '@mushi-mushi/vue';        // Vue 3 / Nuxt: app.use(MushiPlugin, { projectId, apiKey })
import { initMushi } from '@mushi-mushi/svelte';       // Svelte / SvelteKit: initMushi({ projectId, apiKey })
import { provideMushi } from '@mushi-mushi/angular';   // Angular 17+: providers: [provideMushi({ projectId, apiKey })]
import { MushiProvider } from '@mushi-mushi/react-native';
import { Mushi } from '@mushi-mushi/web';              // any framework: Mushi.init({ projectId, apiKey })

Native SDKs (iOS, Android, Flutter) are a preview and install from this repository: see packages/ios, packages/android and packages/flutter. A runnable demo lives in examples/react-demo.

Who it's for

  • You build apps with AI, mostly on your own. You use Lovable, Bolt, Cursor or Claude Code, your app has real users, and you didn't write most of the code by hand. When someone says "it's broken", Mushi Mushi tells you the likely cause in plain English and gives your editor a fix prompt.
  • You're a developer and you own your code. You read the diffs and may already run Sentry. User reports and Sentry errors land in one list with duplicates merged, and an agent's fix gets a second AI review before it can merge.
  • You run a team. Reports arrive from the app, Sentry, store reviews and Slack, and nobody sees all of them. Here they share one list, each with a diagnosis, and they can go on to Linear, Jira or GitHub Issues.

The pains each group has, and where each should start: who it's for.

What's inside

PackageForWhat it does
mushi-mushiSetupOne-command wizard (npx mushi-mushi)
@mushi-mushi/react, vue, svelte, angular, react-native, capacitorYour appThe bug widget for your framework
@mushi-mushi/webYour appThe same widget for any site, no framework needed
@mushi-mushi/nodeYour serverReports backend errors into the same queue
@mushi-mushi/mcpYour editorGives Cursor and Claude Code the diagnosis and fix tools
@mushi-mushi/cliYour terminalSetup, reports, fixes and health checks
@mushi-mushi/uxYour app's screensRuns your coding agent over every screen and keeps only measured improvements
packages/serverBackendSupabase edge functions + Postgres. Hosted for you, or self-host

Full list and maturity: SDK reference. Architecture: how the pipeline fits together.

What else it does

Most bugs never get reported. People just leave. So beyond the reports people send, Mushi Mushi can look for bugs itself and check the fixes. Each of these is off until you switch it on, and several need your own key.

FeatureWhat it doesNeeds
First-time user testAn AI that has never seen your app tries one goal, such as signing up, and files the places it got stuck, with screenshotsThe Mushi Mushi worker on a computer of yours, or one run of mushi ux fresh-eyes
A second AI reviews every fixReads each agent PR next to the original report and says merge, fix first or hold, with its reasonsYour GitHub repo and your own Anthropic key
Live-site watchChecks your live pages every hour. A broken page is filed only after a second check confirms itYour own Firecrawl key
Weekly site auditReads every page once a week and files dead links, missing titles, text in the wrong language and images without a text descriptionYour own Firecrawl key
Known security holesChecks your lockfiles daily against the public vulnerability database and says which package to updateYour GitHub repo
CI bill and runnersShows which workflows cost the most and where minutes are wasted, and tells a code failure from a broken CI machine (mushi runner status)Your GitHub repo. Reading the bill needs a token that can see billing
Playbooks in roundsRuns a playbook such as "make it accessible" on part of your app, one fix PR per round, five rounds at mostYour own Cursor key, or the Mushi Mushi worker
Store reviewsTurns low-star App Store and Google Play reviews into bug reportsYour store accounts connected
Phone reportsSay or type a bug into Telegram, Slack or an iPhone shortcutOne of those connected from the console

A "fix first" review can go back to the agent with its findings, at most twice per PR. That is off by default and uses your organization's Cursor key (agent PR review, CI runners). Every feature, with what it solves: what else it does.

Why not just Sentry?

Sentry is built around what the code threw, with a User Feedback widget and replay alongside. Mushi Mushi starts from what the user reported, ingests Sentry's errors too, explains each one in plain English, and hands your agent a fix prompt to start from. One queue, with or without Sentry.

Mushi MushiSentry
CatchesThrown errors and silent UX bugs (dead clicks, slow screens, broken layouts)Thrown errors, performance traces
You getA plain-English root cause and a fix prompt, in your editorA stack trace and breadcrumbs, in a dashboard
Auto-fixOptional: an agent opens a draft PR, with the built-in fixer, your Cursor key, or the worker on your computerSeer add-on (paid)
SetupOne command that signs you in through the browser; the sample diagnosis needs no accountSDK + DSN + dashboard

It works with what you already run. Point a Sentry alert webhook at /v1/webhooks/sentry?projectId=<id> and errors land in the same queue. Merging a Mushi Mushi fix resolves the Sentry issue, and the reverse. Adapters also bring in Datadog, Bugsnag, Rollbar, Crashlytics and others. Plugins keep Linear, Jira, GitHub Issues, Slack, Discord, Teams and PagerDuty in sync. Nothing gets ripped out. Details: Sentry vs Mushi Mushi.

Self-host

bash
cd deploy && cp .env.example .env   # add ANTHROPIC_API_KEY and your Supabase credentials
docker compose up -d

Walkthroughs: SELF_HOSTED.md and Docker Compose guide. Self-hosting is bring-your-own-key: you pay your LLM vendor at list price. The hosted service needs no key; it bills per diagnosis with a spend cap (pricing). Teams wiring Mushi Mushi into an existing stack (SSO, retention, region routing, Kubernetes) start at docs/operators/. Only the public api function should face the internet: see internal caller authentication.

Where it stops

AreaStill partial
Track recordMushi Mushi is young. Most of its use so far is on the maker's own apps. There, people reported only a small share of the bugs. The rest came from checks, Sentry errors and bugs the maker filed. The live numbers count the two separately
Native SDKsiOS, Android and Flutter are previews, not yet on CocoaPods, Maven Central or pub.dev
Fine-tuningOpenAI and Bedrock work. Anthropic fine-tuning is not self-service, so its adapter links to the access form
Knowledge graphSQL adjacency everywhere. Apache AGE only where the extension is installed (not managed Supabase)
Inventory and QA gatesBehind the inventory_v2 plan flag; reachable from Checks
Multi-regionRegion pinning works. Active/active write replication is not automated

Repo at a glance (run pnpm docs-stats): ~620K TS lines · ~2,700 source files · 45 workspace / 37 npm packages · 77 edge functions · 547 SQL migrations · 19 pipeline agents. Full tour: docs/SCREENSHOTS.md.

Community and contributing

Questions and show-and-tell: GitHub Discussions. Bugs: Issues (first reply within 24 hours on weekdays). Security: SECURITY.md. Anything else private: kensaurus@gmail.com.

bash
git clone https://github.com/kensaurus/mushi-mushi.git && cd mushi-mushi
pnpm install && pnpm dev   # Node ≥ 22, pnpm ≥ 10

See CONTRIBUTING.md and docs/stats.md.

License

Open core. Each package directory's own LICENSE governs that package; the root LICENSE states the split.

PartLicenseIn short
SDKs, CLI, MCP, plugins, adaptersMITUse anywhere, including closed-source products
Server (server, agents, verify) and console (apps/admin)AGPLv3Self-host and modify freely. Offer a modified server or console as a service: publish your changes or get a commercial license
Enterprise features (packages/server/ee/)EE licenseSSO, audit ingest, retention, region pinning. Paid for production use
Name, logo, icons, mascotTrademark policyAll rights reserved. Link to Mushi Mushi with the unmodified logo; forks must rename

Self-hosting is free and complete: the repo has every feature and working default prompts. Mushi Mushi Cloud runs the same code and keeps its own tuning data (prompt wording, evaluation sets and scoring weights tuned on live traffic) as configuration. Contributions come in under a CLA. Why it is set up this way: ADR 0036. Third-party notices: NOTICE.

More apps from the same maker

AppWhat it is
glot.itLearn Thai — bite-size lessons, smart flashcards, and an AI tutor
yen-yenWhere did the money go? Now you'll know. A kakeibo for households
the wanting mindHow the Battle Between Extraction and Generation Is Reshaping Our World — a 147,000-word interactive webbook with 268 concepts, 242 citations, and original illustrations
help her take photoPair phones, direct the pose, nail the photo
lets-talkPractice hard conversations before you have them
一人社長 Solo BossBookkeeping and tax-filing co-pilot for one-person companies in Japan — Free tools
Tsumagoi Work&CampA 24-hour mountain lounge at 1,444 m; guests sleep in their own car or tent — Book a stay · Instagram · Facebook · Maps
kenji skillsAgent skills and slash commands for Claude Code, Cursor, Codex, and Gemini — Getting started
kensaur.usAll apps from the same maker

The list comes from https://kensaur.us/apps.json (kensaurus/kensaur.us src/data/family.json).


If Mushi Mushi helped, star the repo so the next vibe coder finds it. Open an issue · Follow on Bluesky