---
name: morrow
description: Plan and source anything a person wants to buy or build — a gaming PC, car mods, furnishing or decorating a room, a home gym, camping kit, a radio telescope. Morrow asks the few questions that matter, designs it, finds every piece in real shops near them, checks it all fits, and returns one list with links, photos, a total, a share page and a PDF. Use when someone wants several things that must work together, or wants the right product found and checked for them.
---

# Morrow

Morrow turns "what I want" into "exactly what to buy", with every piece found in a real shop and checked to fit. You hand it the ask; it asks you its questions; then it works for 5–12 minutes and returns the list.

- No account or key. A run's `run_id` is its key, so keep it private.
- Free and anonymous, open for now. A per-address limit (one new run a day) may be switched on later. Over a limit you'd get HTTP 429 with `Retry-After`, or an MCP error saying when to try again.
- Home: https://getmorrow.io · this file: https://getmorrow.io/skill.md

## When to use it

- Several things that have to fit together: a PC build, a room, car mods, a home gym, a DIY build, a garden, a setup.
- One thing that has to be right: "a rug for a 3×4 m room", "coilovers for a 2019 Golf GTI".
- When the person wants real shops, real prices and links, not a list of ideas.

Skip it for general advice, for single items where any product would do, and for people outside places with online shops.

## Connect

**MCP (recommended).** It's a Streamable HTTP server: `https://getmorrow.io/mcp/build`. To add it:

- Claude Code: `claude mcp add --transport http morrow https://getmorrow.io/mcp/build`
- Other clients: add an HTTP MCP server with that URL; no auth.

**REST + SSE.** Use this if you can't use MCP. The base URL is `https://getmorrow.io/v1/runs` (examples below).

## The flow

1. **Start** with everything you know: `morrow_start`, or `POST /v1/runs`.
   - `ask`: their words plus details: sizes, budget, style, what they already have, constraints.
   - `country` (ISO code, e.g. US, GB, DE, RO). It decides the shops and the currency, so always pass it when you know it. Optionally add `city`, `currency` and `store` (a shop to start with, e.g. ikea.com or newegg.com).
   - `images`: up to 4 photos of the space, the car, a sketch or an inspiration picture. Send `{ "url": "https://…" }` or `{ "data": "<base64>", "media_type": "image/jpeg" }`. Morrow looks at them closely (sizes, style, what's already there).
2. **Questions.** Morrow usually asks 2–4. Each one has an `id`, `options`, a `default` and a `why` (what it changes in the list).
   - If your human is around, show them the questions, with the options and defaults, in one message. Let them answer only the ones they care about.
   - If you already know the answers, answer them yourself.
   - If no one's there, use `use_defaults: true`. You can also pass `use_defaults` at the start to skip the questions entirely.
   - Then send the answers: `morrow_answer` / `POST /v1/runs/{run_id}/answers` with `{"answers": {"budget": "$1,500", "room_size": "4 x 5 m"}}`. Unanswered questions take their default.
3. **Build** (5–12 minutes). Morrow designs it first, with drawings and an engineering-style review. It then finds each piece in real shops by reading their pages for price and stock, and checks that everything fits together.
   - Follow along with `morrow_wait` (each call waits up to about 50 s and returns what happened since `after`), or with the SSE stream.
   - You don't have to watch. Tell your human it's being built, do other things, and call `morrow_wait` or `morrow_result` (or `GET /v1/runs/{run_id}`) later.
4. **Result.** Use `result.markdown` to show the list. Always give the **share link** (`result.share_url`): a page with every part, photo, link, drawing and the steps, plus a **PDF** (`result.pdf_url`).
   - Mention `result.missing`: parts Morrow couldn't find a fitting product for.
   - Prices and stock are as checked during the run.

## Events

Every event has an increasing number. Resume from any point with it: `Last-Event-ID` on the SSE stream, `?after=N` on the JSON form, or `after` in `morrow_wait`.

- **SSE**: `id: <n>`, `event: <type>`, `data: <json>`
- **JSON long-poll**: `GET /v1/runs/{run_id}/events?after=N&wait=50` (wait up to 55 s) returns `{events: [{seq, type, data, at}], last_event, run}`

| event | what it carries |
|---|---|
| `run` | `run_id` and links |
| `questions` | `questions[]`: `{id, question, why, options[], default}` and how to answer |
| `status` | `stage` (designing → reviewing → sourcing → checking → done; after a fit check it can go back to sourcing to replace parts), message, parts found/total |
| `design` | `overview`, `steps`, `assumptions`, `parts_total` (and `drawings[]` if they're already made) |
| `drawings` | `drawings[]`: `{title, url}`, image URLs of the concept drawing and technical views (they're made while parts are found) |
| `step` | what an agent is doing right now (`agent`, `text`) |
| `part` | a piece found: `part`, `quantity`, `product`, `shop`, `price`, `url`, `image`, `note` |
| `done` | `result` (see below); the stream ends |
| `error` | `message` and any partial `result`; the stream ends |

`result` contains:

- `title`, `outcome`
- `total`, `total_note`, `currency`
- `parts[]`: `group`, `part`, `quantity`, `product`, `brand`, `shop`, `price`, `url`, `image`, `note`
- `missing[]`: parts with no fitting product, each with its own `why`
- `included[]`: parts not needed because another product already comes with them (`{part, with}`)
- `budget` (`{amount, currency}`, when one was given) and `over_budget_by` (null when within budget)
- `from_photos`: what Morrow took from the photos, when there were any
- `steps[]`, `assumptions[]`
- `design`: `overview`, `drawings[]`, `review`
- `share_url`, `pdf_url`, `markdown`

## REST examples

```bash
# Start: returns once the questions are ready
curl -s https://getmorrow.io/v1/runs -H 'content-type: application/json' \
  -d '{"ask":"Build my gaming PC: quiet, 1440p high settings, about $1,600, white case","country":"US"}'

# Or start and stream everything from the first event (questions arrive on the stream)
curl -N https://getmorrow.io/v1/runs -H 'accept: text/event-stream' -H 'content-type: application/json' \
  -d '{"ask":"Furnish my 4x5 m living room, Scandinavian, renting","country":"GB"}'

# Answer (or {"use_defaults": true})
curl -s https://getmorrow.io/v1/runs/RUN_ID/answers -H 'content-type: application/json' \
  -d '{"answers":{"budget":"£2,000"}}'

# Follow live (resumable), or long-poll as JSON, or just check the state
curl -N https://getmorrow.io/v1/runs/RUN_ID/events -H 'accept: text/event-stream' -H 'Last-Event-ID: 12'
curl -s "https://getmorrow.io/v1/runs/RUN_ID/events?after=12&wait=50"
curl -s https://getmorrow.io/v1/runs/RUN_ID
```

## Doing it well

- Put everything you know in `ask`. A good ask cuts the questions to one or none.
- Ask the questions in one friendly message, never one at a time.
- While it builds, tell your human what's happening in a line or two at the milestones: "Design done: 14 parts", "Found the GPU and case", "Checking it all fits". Don't paste every step.
- If `over_budget_by` is set, say so up front, and offer a new run with a tighter ask (for example "no upgrades, cheapest that fits").
- Present the result as Morrow gives it. Don't swap in products, prices or links of your own. If something's missing, say so and suggest a new run with more detail.
- Share links stay up. They follow the project, and anyone can open them without an account.