Examples

Concrete workflows that chain multiple MCPs together. Each scenario lists the MCPs involved, the prompt or command sequence, and what to expect — copy them as starting points for your own setups.

Triage + fix an issue

MCPs: dev.mcpwidget.git, dev.mcpwidget.fs, dev.mcpwidget.claude_code

Scenario. You've got a flaky test in your repo. Studio reads the test file, screenshots the failing CI run for context, asks Claude Code to write a fix, then commits.

/workspace ~/code/myapp
/install https://github.com/RPieterse/mcp-studio-git-mcp     # if not already
# Type a natural-language prompt:
The test in tests/auth.spec.ts is flaky on the third run.
Look at the test, then look at the related production code in
src/auth/*, propose a fix, and commit it with a message starting
"fix(auth):". Run the test once before committing to confirm it
passes.

What happens. The agent walks the directory, reads files via Filesystem, asks Claude Code to draft the fix, applies it (Filesystem write), runs the test (Claude Code's run tool), and commits via Git on success. Every tool call streams as its own card in the transcript — you watch the chain unfold.

Daily morning brief

MCPs: dev.mcpwidget.chrome, dev.mcpwidget.fs + a schedule

Scenario. Every weekday at 07:00, Studio pulls the top 5 Hacker News stories, summarises them, and saves the result to a daily Markdown file in your notes directory. The next day's run sees yesterday's summary as memory and can compare.

1. Settings → Schedules → Add. Name: Morning brief. Trigger: every 24h starting tomorrow 07:00.
2. Prompt:

   Open news.ycombinator.com in Chrome and read the top 5 story
   titles + links. For each, write a one-sentence summary. Write
   the whole thing to ~/Notes/briefs/${context.now}.md as a
   markdown bullet list with the date in the H1.

3. Save + enable.

What happens. Rust's timer fires the prompt at the configured cadence. The agent uses Chrome to navigate + read, then Filesystem to write the file. Each fire sees prior fires as context, so it can reference yesterday's brief ("two of yesterday's stories are still on the front page").

Sheet-driven status report

MCPs: com.rohanpieterse.gsheets_oauth, dev.mcpwidget.fs

Scenario. A Google Sheet tracks your weekly OKR progress. Studio reads each row, marks any goal that hasn't moved in two weeks, and writes a "needs attention" report to disk.

/install https://github.com/RPieterse/mcp-studio-google-sheets-oauth-mcp
# After OAuth completes from desktop Settings → MCP Servers:
Read the sheet named "Q3 OKRs" — every row is a goal with
columns Name, Owner, % complete (current), % complete (last week).
Find goals where the current % equals the last-week %. Group
them by Owner, sorted by smallest % first. Write the result to
~/reports/okrs-needing-attention.md.

What happens. Sheets MCP fetches the rows; the agent reasons about deltas; Filesystem writes the report. Each tool call is visible. If you re-run weekly, save the agent's output in a project so memory threads across runs.

Author + publish an MCP

MCPs: Builder + dev.mcpwidget.git

Scenario. You want a new MCP that proxies wttr.in for weather lookups. Studio scaffolds it, you edit a couple of fields, then publish to GitHub — done in one panel.

/build-mcp new "a weather MCP that proxies wttr.in?format=j1 — exposes
  a current(city: string) tool returning JSON with temperature + condition"
# Builder opens, shows the scaffold under ~/.mcp-widget/built/<id>/.
# Edit the manifest description, save.
# In Builder: Publish → choose repo name + visibility.

What happens. The Builder writes a complete project (manifest + index.ts + package.json + README) under your data dir. The Publish flow uses gh repo create to push it to GitHub. Anyone can /install <your-new-url> from there. Add an entry to gallery.json via PR and it shows up in everyone's Gallery tab.

Drive Studio from your phone while AFK

MCPs: any installed; mobile companion app

Scenario. You're at the coffee shop. A long-running agent task should kick off on your desktop. From the phone, fire it, get back to your coffee, return to the panel later for the result.

1. Desktop: Settings → Mobile → Enable. Generate pair QR.
2. Mobile: scan, pair. (Once.)
3. From phone: switch to your research tab, type your prompt, Send.
4. The desktop runs the full agent loop. Mobile streams the tool-call cards in real time — same view as desktop.
5. Close your phone. Come back hours later, mobile still shows the final response in the transcript.

The phone is a thin client. All processing stays on the desktop. Your prompts travel over your tunnel (Tailscale, Cloudflare Tunnel, etc) — Studio runs no cloud infra.

Tool chains via store_result

MCPs: any two that need to share output → input

Scenario. A quick command grabs the current temperature for a stored city, writes it back to storage, and a second command uses it.

In the weather MCP's manifest:

"quick_commands": [
  {
    "trigger": "weather",
    "description": "Look up current weather for the saved city",
    "tool": "current",
    "args": { "city": "${storage.city}" },
    "store_result": { "key": "last_temp_c", "path": "current.temp_c" }
  }
]

In a sibling MCP that drafts emails:

"quick_commands": [
  {
    "trigger": "email_weather",
    "description": "Draft an email mentioning today's temperature",
    "tool": "draft",
    "arg_key": "subject",
    "args": {
      "body": "Heads up — it's ${storage.weather.last_temp_c}°C outside."
    }
  }
]

Result. Typing /weather looks up the value and stores it. Typing /email_weather Today's plan picks up the stored temperature via cross-MCP interpolation (${storage.<mcp_id>.<key>}). Composable pipelines, declared in JSON, no glue code.

Have an interesting workflow you'd like to share? Open a PR against RPieterse/mcp-studio-releases with an addition.