Create · Workshop

The machine proves it works.
You direct whether it's fun.

Solvers prove winnable; hashes prove deterministic. The one channel no headless gate can close is fun — so Hayao ships an instrument for it: every human playtest becomes a bit-exactly replayable artifact your agent can read, inspect, and act on.

Workshop — small-flamesession 07 · recording

the game, live — playable here or on your phone via QR

frame 1 843 / 2 970“felt-bad” @ 1 121scrub = time travel

Tuning knobs — live

gravity1400

coyoteMs90

fuelBurn0.84

Playtest report

hesitation 4.2s @ gap-3

deaths cluster: room 2 (5×)

futile verb: jump ×11 vs ceiling

A faithful staging of the pane — the real one runs on the dev server, records every session, and hot-swaps the game under your hands as the agent edits it.

The loop

Taste in, code out

A human plays

In the browser, on a phone via QR — every run is recorded as (seed, tuning, inputs, knob events).

Taste happens

Knobs move mid-play. Feels-bad moments get annotated. The session forks when you scrub back and try again.

The agent reads it

Via MCP verbs — list_sessions, inspect_moment, get_knob_state — the exact frame where a player hesitated, re-simulated in Node.

Values become code

Accepted knob values get written back into the game's declared defaults. Text stays the source of truth.

A session is re-executable

Not a video — (seed, tuning, inputLog, knob events). Any metric is computable after the fact; any tick can be re-inspected in Node, bit for bit.

Scrubbing forks time

Drag the timeline to any recorded frame, resume, and the discarded future is truncated — the artifact always replays as exactly what the player kept.

A/B is a URL

Variants build side by side and carry your run across; tape mode replays any past session read-only with ?session=<id>.

The agent's verbs — an MCP sidecar, in the box

list_gameslist_sessionsget_playtest_reportinspect_momentget_knob_stateget_annotationsbuild_variantrun_verify

Registered in .mcp.json — Claude Code, Cursor, or any MCP client reads your playtests the moment the dev server runs. Bring your own agent.

Hand it to your agent

Paste this into your agent, play one session, and watch it turn what you felt into a reasoned tuning diff.

Run a Hayao Workshop playtest loop with me.

1. Clone and start the dev server:
   git clone https://github.com/hellojanpacan/hayao-js && cd hayao-js
   npm install && npm run dev    # then I'll open /workshop/
2. Read docs/WORKSHOP.md — sessions are re-executable artifacts,
   knobs are taste, text is the source of truth.
3. I'll play. Afterwards, use the MCP sidecar (.mcp.json registers it)
   to read my session: where I hesitated, where I died, what I annotated.
4. Propose ONE tuning change, explain it from the data, and write the
   accepted value back into the game's tuning defaults.
5. Re-run npm run verify so the proofs still hold.

Wait for my first session, then start with the report.

The full doctrine — sessions, scrub semantics, tape mode, invited playtesters —docs/WORKSHOP.md.

The machine proves it works.You direct whether it's fun.