Inspiration
Every hackathon pitch is three minutes and one take. We kept watching the same three things sink good projects: a judge asks the one question the team never practised, someone says "it's instant" when the screen clearly shows a spinner, and the live demo freezes on stage.
Teams rehearse alone, or in front of friends who nod along. Nobody checks the claims, and nobody plans for the demo breaking. We wanted a rehearsal room that argues back: judges built from the event's real rubric, an auditor that holds every sentence to the evidence, and a safety net for the moment the app fails.
What it does
Stage Ready is a rehearsal studio for demos and pitches.
- Calibration. It reads the event page into a cited spec (judging criteria, weights and rules, each with its source quote), turns past winners into patterns, and reads your repo into capabilities and findings with
file:linereferences. - Judge panel. Three fictional judges, built from those criteria, listen while you pitch and share your screen. They interrupt at sentence boundaries with questions grounded in your own data ("What is the measured p95 latency for 'instant'?"), and they yield when you say "let me finish".
- Claim Auditor. Every claim becomes a chip: Verified, Contradicted, Unverified or Not shown. Each one is checked against your screen, your measured step timings and your code, and comes with an honest rewrite. The latency stopwatch times every step straight from the shared screen.
- Session review and Rehearsal Memory. You get a score, the three biggest issues with what to say instead, and Coach Notes that only mark a weak spot resolved when a later rehearsal re-checks it and it passes.
- Evidence Q&A Kit. A pre-pitch brief (lean on, say, show, and what judges will catch), 20+ ranked likely questions with 20-second answers, and evidence slides whose numbers are re-read and checked after rendering.
- Best-Take Director. It scores every take per section and cuts the best ones into a captioned submission video that fits the time limit.
- DemoGuard. It watches your live demo step by step. On an error dialog, a 5xx, or two corroborating signals, it cuts to a clearly labelled recording of the same step, then goes back to live at the next step boundary:
$$ \text{fallback} \iff \big(\exists\, s \in S_{\text{critical}}\big) \;\lor\; \big|{\, s_i \in S : t_{\text{now}} - t_i \le 3\,\text{s} \,}\big| \ge 2 $$
Every model output in the app is captioned with the model that produced it and how long it took, for example Muse Spark 1.3 · 2.3 s. You can always see what the AI did.
Try it: Demo Mode opens a fictional project in about a second, with no sign-up, running on the real Meta models.
How we built it
Stage Ready runs on five Meta models, each doing the job it is best at:
| Model | Job in Stage Ready |
|---|---|
| Muse Spark 1.3 | Live, low-latency calls: extracting and verifying claims against nearby screenshots, deciding when a judge interrupts and what they say, show-or-strike checks, re-reading every number on a rendered slide |
| Muse Wonder 1.0 | Long-context reasoning: event page → cited spec, winners → patterns, repo → capabilities, and everything together → the pre-pitch brief, question bank and Coach Notes |
| SAM 3.1 | Finds spinners, error dialogs and progress bars on the shared screen for the stopwatch, the Studio overlay and DemoGuard |
| Muse Voice Transcribe | Writes the final transcript of each rehearsal from the recorded audio |
| Muse Image 1.0 | Paints evidence-slide backgrounds and video title cards. The numbers are always drawn by the renderer, so they stay exact |
All text and SAM calls go through the Meta Responses API with JSON-schema structured output, validated by zod, with one corrective retry. Each prompt is versioned and has a deterministic mock, so the app degrades honestly when there is no key or the daily demo allowance runs out, and its caption says so.
The stack is a pnpm + Turborepo monorepo:
- Web: Next.js 15, Tailwind v4, shadcn/ui, Auth.js with GitHub sign-in, and a signed guest cookie for one-click Demo Mode.
- Realtime: Fastify WebSocket server. The browser streams 16 kHz PCM audio and deduplicated JPEG screen frames in small binary packets (a 9-byte header, then the payload).
- Worker: BullMQ on Redis for long jobs (briefs, question banks, slides, renders, transcripts).
- Data: Postgres with pgvector through Drizzle, and S3-compatible storage on Backblaze B2.
- Vision service: Python FastAPI on Modal, running faster-whisper for live captions and FFmpeg for −14 LUFS captioned renders.
- Deploy: web, realtime, worker and Redis run in a single Modal container behind a small router. It redirects every request to one canonical address, so sign-in and the WebSocket origin check always agree.
- Contracts: shared zod schemas for every REST and WebSocket message, with CI covering lint, types, unit tests, Playwright end-to-end tests and the Python service.
Challenges we ran into
- Latency that feels live. A judge who interrupts ten seconds late is useless. We split the work so Muse Spark handles the per-sentence calls (about 2 s per claim verdict) and Muse Wonder handles the deep reading in the background. We also ran claim extraction and the interrupt decision in parallel.
- Slides that came out blank. In production every evidence slide rendered as an empty rectangle. The slim container had no fonts, so the SVG renderer drew every number as nothing, and the number check then failed. We now bundle the font with the worker and added a regression test that fails if a slide's title area is a single colour.
- Invisible AI art. Muse Image returns WebP by default, and our renderer can't decode WebP, so the art never appeared. We now request PNG, key the cache on the prompt, and brighten very dark images before drawing them.
- A slow first click. Seeding a guest's Demo Mode project took 53 s at first. We built every row in memory and wrote one batched insert per table, which brought it down to about 1.2–2 s.
- Production surprises. We hit a malformed storage key, inline comments in environment files that crashed the boot, a second region-specific URL that broke WebSockets and sign-in, and a cloud workspace that was suspended mid-build. Each one led to a fix: friendly storage errors with a health check, a stricter env parser with
pnpm env:check, a fail-fast boot script, and the single-address router. - Keeping it honest. It would have been easy to fake a perfect demo. We label everything instead: Demo Mode says which parts are scripted, DemoGuard's fallback carries a Recorded segment badge, and every model output says which model made it.
Accomplishments that we're proud of
- A complete loop that works live: calibrate → rehearse with interrupting judges → review → Q&A kit → best-take video → a protected live demo.
- All five Meta models in the product, each visible to the user with its name and timing.
- Measured on the live site: a full demo workspace in about 1.2 s, a claim verdict in about 2 s, a grounded judge interruption in about 4–5 s, failure detection in under half a second, and an 85-second rehearsal for about \$0.05 across 18 model calls.
- DemoGuard going Live → Fallback → Recovering → Live on a real run, and flagging steps that overran their time limit on its own.
What we learned
- Picking the right model per job matters more than using the biggest one everywhere. A fast model on the live path and a long-context model off it gave us both speed and depth.
- Structured output plus a validator plus one retry turns language models into dependable components, and versioned prompts with mocks keep the app testable offline.
- Showing which model did what builds trust: users believe a verdict more when they can see what produced it and how long it took.
- Most of the hard bugs were in deployment, not in the AI code: fonts, image formats, origins and environment files. Health checks and failing fast at boot paid for themselves many times over.
What's next for Stage Ready
- Live captions on Muse Voice's realtime endpoint, so transcription runs on Meta models end to end.
- A VR rehearsal room: pitch to the judge panel in a virtual hall on Meta Quest.
- Team mode, so co-presenters can rehearse hand-offs together with a shared claim ledger.
- More event templates (investor pitches, conference talks, thesis defences), and integrations that pull the rubric straight from Devpost and other event pages.
- The DemoGuard companion app on the presenter's machine, for network and process signals beyond the screen.
Built With
- auth.js
- blackblaze-b2
- meta-model-api
- modal
- muse-image
- muse-spark
- muse-voice-transcribe
- next.js
- pgvector
- python
- redis
- sam-3.1
- shadcn
- tailwind-css
- typescript
- websockets