Mystery Night

Party games are one fixed game. Mystery Night is a murder-mystery marketplace: Fire TV hosts, every phone hides a secret, and every player can turn one sentence into a new case with AI.

Comment

Mystery Night turns any living room into a murder-mystery party: Fire TV hosts it, every phone holds a secret, and any player can create the next case with AI.

  • The problem: murder-mystery role-play is one of the most social games in the world, but every case plays once, and every night needs a venue and a human host. TV party games, meanwhile, ship as one fixed game.
  • The product: the TV narrates, keeps the clock, shows the shared clues and stages the reveal. Each phone is one player's secret script: scan a QR code, no app, no account. Nobody has to prepare or host.
  • The engine: type one sentence, and Amazon Bedrock writes a complete case (the truth, characters, clues, art and narration) in about 100 seconds for about $0.70. An AI detective must solve it from the players' clues before it ships.
  • The moat: a marketplace that grows with its players, ranked by real play data, on the platform that already has the living room, the voice assistant, the cloud AI and the audience.
  • Live today: the Vega OS TV app, the phone web app and the game server on AWS; eight Original cases; our flagship Dead Air, which 16 playtesters said feels like a real murder-mystery night; and an installable TV build for judges.

Built for three of the Fire TV track's priority categories: family entertainment, AI-enhanced viewing and multi-modal UX (a shared TV, a private phone and the remote, with Alexa voice next).

Inspiration

In China, one of the most popular nights out is jubensha (劇本殺): a group of friends, a room, a host and a script. Everyone gets a character booklet with a secret only they can read. The group talks, searches for clues and argues for a few hours, then votes on who did it. It grew to about 45,000 venues and nearly 10 million players, a market of about US$3 billion, with most players under 30 (Dicebreaker, 2023; Liu, 2023).

It never made it into the living room, for three reasons: every case can be played only once, every night needs a venue, and it needs a human host who knows the answer. So we asked: what if the TV were the host, the phones were the secret booklets, and AI made sure you never ran out of cases?

What it does

A night of Mystery Night

  1. Join. The TV shows a QR code. Each player scans it in their phone's browser and picks a character. No app, no account, no typing on the TV.
  2. Read. Your phone is your script: who you are, your secret (hold to read), your goal and side mission, and the clues only you hold.
  3. Talk. The TV runs speaking turns on a clock. Your phone gives you talking points and tells you what to keep hidden. Don't buy someone's story? Say so, or challenge them.
  4. Act. Now and then the game asks one thing of you: move a flashlight in the dark, hold a finger down with a partner to open a safe, race your team to spot what changed. The culprit has secret moves, and their phone looks exactly like everyone else's while they make them.
  5. Reveal. Everyone answers who, how and why. The TV stages the truth, then the scores, three awards and a personal ending on every phone.

Nobody runs the game. Each step moves on when every phone taps Ready, or when its timer or narration ends; the remote is only an override. Every phone screen is one of four states, built around three verbs: read (your script), act (one thing to do), talk (the question on the table), or wait ("Look at the TV"). The TV has three modes: the stage for story moments, the table for shared clues and the clock, and the moment for big reveals. Counts on the TV (Ready, doubts, votes) never show names.

Dead Air, our flagship (designed by Rox; 4 players, about 50 minutes), is a haunted livestream: a séance that spells a name, two blackouts, and a streamer who won't wake up. It has a character pick, a memory check that names nobody, speaking turns with challenges, a flashlight hunt, searches whose order the spirit board spells, a safe two players must open together, a two-against-two race and a who/how/why accusation. Our 16 playtesters told us it feels like a real murder-mystery night, and that they'd play it if it launched on Fire TV.

For every household: adult, family and kids modes. Kids mode has no death, weapons, injury or romance, and an 8-minute kids tutorial teaches the game.

Every player is a creator

Press Create on the TV, scan the QR code, and type one sentence, like "a mystery in our campus library during finals week." Choose adult, family or kids, and 3 to 6 players. The TV shows each step as it happens:

  1. Amazon Bedrock Guardrails screen the idea, and a Nova classifier turns away ideas that name real people.
  2. Amazon Nova 2 Lite writes the hidden truth first, then the characters and clues built from it.
  3. Our validator checks the schema and the game logic. Anything that fails goes back to the model as a numbered list to repair.
  4. An AI detective (Nova 2 Lite, nine runs across three views of the case, reading only what players will see) must solve it with every clue, but not too easily from round 1 alone. Its results set the difficulty. A case it can't solve never ships.
  5. Image models on Bedrock paint the cover, scenes and portraits, and Amazon Polly records the narrator.

Built like a real case, not free-written. The pipeline never just asks a model for "a mystery." It fills a structure we designed from how jubensha cases work: the hidden truth comes first, every character gets their own secret, and clues are dealt across rounds before a vote and a reveal. The validator then enforces the rules of a fair case: at least two real clues point to the culprit, at least one of them arrives after round 1, and the culprit never holds them all. The AI detective checks the result from the players' side. Every idea gets its own cast, setting and solution. Today an AI-written case plays in about 25 minutes with three rounds of clues; giving it Dead Air's full set of mechanics is next.

Our recorded run took about 100 seconds and about $0.70 (15 Nova 2 Lite calls, 12 images, 1,088 Polly characters, 3 Guardrails checks). In our last batch run, 15 of 15 test ideas became playable, checked cases.

The new case lands on that TV's shelf. Once a group has finished it, it can be published to the marketplace, where cases are ranked by real play: plays, completion and solve rate. Three of our Originals were written by this pipeline, and the app labels each one "Written by AI from one sentence, then edited."

Why Fire TV, and why Amazon

  • The demand already exists; it's stuck in venues. The living room is where groups already gather, and Fire TV is already there.
  • Every piece is already at Amazon: Fire TV for the shared screen, Alexa for a voice host, Bedrock to write and check cases, the Appstore to distribute it, and Prime, where Luna's GameNight already brings phone-controlled party games to members.
  • A catalog that grows itself. A studio makes its catalog one title at a time, and a party game ships as one fixed game. Mystery Night's shelf grows with its players: AI and creators write, and play data decides what rises. Content, engagement data and a creator economy that compound on Fire TV.
  • How it earns: a free starter shelf, premium Originals and a weekly case, and creators paid by plays.
  • Cheap to run at scale: no AI runs during a game, so a night of play costs almost nothing; a brand-new case costs under $1, once.

Don't take our word for it

We built without a physical Vega Fire TV and recorded the video with scripted players, so here is what's real and how you can check it yourself.

  • It runs on Vega OS. Built with the Vega SDK and React Native for Vega, and tested daily on the Vega Virtual Device, which the rules accept for the demo. Our release ships the same app package format a Vega device installs: for the VVD on Apple silicon (tested), the VVD on x86_64, and the Vega Fire TV Stick (armv7; built, untested without a stick). Check it: install from our GitHub release submission-1023; the marketplace opens in about 6 seconds.
  • It's a real, complete game. Every gameplay shot in the video comes from one continuous 12-minute game of Dead Air, recorded on the first try on our deployed build. A test harness drove the four phones so every screen could be recorded in sync, and sped-up parts are labeled. Check it: press Play solo, you plus three bots, each deciding only from its own phone's view; 7 to 15 minutes, end to end.
  • People want more. 16 playtesters played Dead Air at game nights Ryan hosted at home. Their verdict: it feels like a real murder-mystery night, and every night ended with the same question: can we play another one? Ryan's own playtest led to the read/talk/act redesign, which cut the words on the phone by 42%. Check it: play it with three friends and four phones.
  • AI creation works. One real run took about 100 seconds and about $0.70, from one sentence to a checked, playable case, and every paid call is logged. We've played the AI-written cases ourselves, not just Dead Air. Check it: the video's "Every player is a creator" chapter, and three AI-written cases to play on the marketplace.
  • Secrets stay secret. Leak tests play whole games and scan every message to every screen, down to the raw WebSocket frames. Check it: npm test in the repo.

How we built it

Phones (browser) ──┐
                   ├── HTTPS ── Caddy on Amazon EC2 (us-east-2) ──┬── game server (Node.js, Socket.IO)
TV (Vega OS app) ──┘                                              └── phone app (Next.js)

game server ── Amazon DynamoDB + private Amazon S3 (scripts, images, narration)
create job  ── Amazon Bedrock: Nova 2 Lite · image models · Guardrails ── Amazon Polly

Every Amazon tool, and what it does

  • Vega OS, React Native for Vega, Vega SDK: the TV app: marketplace, lobby with an on-device QR code, narration with subtitles, staged moments and D-pad focus. Started from Amazon's multi-TV sample.
  • Vega Virtual Device: our TV for every test, run-through and the demo video, driven by scripts for an 83-frame design audit.
  • Amazon Bedrock, Nova 2 Lite: writes every case with forced tool calls that return schema-shaped JSON, repairs it, and runs the AI detective.
  • Amazon Bedrock, Stable Image Core and SD3.5 Large: covers, scenes and portraits, with reveal faces kept consistent image-to-image.
  • Amazon Bedrock Guardrails: one guardrail per mode, on ideas, every player-facing line and every image prompt.
  • Amazon Polly: the narrator, with speech marks timing the TV's subtitles, and the demo video's voice-over.
  • Amazon EC2: the real-time game server and the phone app.
  • Amazon DynamoDB and Amazon S3: case metadata and play stats; scripts, art and audio behind presigned URLs.
  • AWS IAM and AWS Systems Manager: a least-privilege instance role, so no keys sit on the server; releases go out via Run Command, with no SSH.

Engineering highlights

  • Built for the TV. Large type and a few large targets, readable from about 3 metres; D-pad focus; all typing happens on phones; the remote is optional because the phones move the game.
  • Secrets never leave the server. It builds a separate view for each screen: a phone gets only its own secret and the clues it was dealt, found or shown; the TV gets public information only, and the truth stays on the server until the reveal.
  • A game is data. A case lists its phases, and each mechanic (whisper, search, speaking turns, flashlight, the two-player safe) is one server module plus one component per screen. A new mechanic is a module; a new case is a JSON file.
  • Resilient by design. A phone that drops rejoins its seat with a stored token and gets its current view back; the TV takes every timer from the server's clock.
  • Cost guard in code. Every paid AI call needs one PAID_AI switch and is logged; tests never reach AWS.
  • 1,750 automated tests: 1,710 unit tests across the server, pipeline, phone, validator and TV, plus 40 Playwright end-to-end tests on Pixel and iPhone profiles that play whole games with the leak check.
  • An agentic development workflow. Ryan directed up to three Claude Code agents working in parallel, each owning one area (server and content, TV and deploys, phone and test harness), with one agent merging only fully tested batches.

Challenges we ran into

  • WebSocket on the Vega Virtual Device. A frame split across TCP reads arrived as several broken messages (one 3,650-byte frame became 37). We isolated it with a test server that cuts frames on purpose, and the TV now runs Socket.IO over long-polling.
  • A virtual TV whose clock stops while the Mac sleeps (we measured lags of almost four days). It once broke HTTPS and surfaced only as HTTP 400. Timers now come from the server, and a preflight check refuses to start when the clock is off.
  • A $29 spend limit that pauses the whole project. Every AI call sits behind one switch, and hand-made cases get free checks (a validator and a solver) instead of AI ones.
  • Guardrails versus invented names. A "real people" denied topic also blocked made-up characters, so we built a small Nova classifier that passed all 103 calibration cases, three runs each.
  • Polly was available to our account in only one region, with standard voices, so the narrator is a standard voice tuned with SSML.

Every one of these is in our friction log: 39 entries with versions, steps, errors, workarounds and suggestions.

Accomplishments that we're proud of

  • A complete TV-plus-phones party game, from the marketplace to the results, live on AWS, with a TV build judges can install.
  • Dead Air has three independent solving routes, and a solver checks the culprit is still findable with any two clues lost.
  • 15 of 15 test ideas became playable, checked cases.
  • Privacy by design, enforced by tests on every message.
  • 16 playtesters, and a playtest-driven redesign that cut the phone's words by 42%.

What we learned

  • Write the truth first. With the answer key written before the clues, every clue can be checked against it.
  • Never ship AI output raw. A validator plus an AI detective that sees only the players' view catches what a schema can't.
  • Ask "who may see this?" for every message, from day one.
  • Test on the device early. Our hardest bugs only appeared on the Vega Virtual Device, never in a browser.
  • Play it yourself. Our first build had too much text. A real murder-mystery night is three things: read, talk, act. We rebuilt the phone around them, and the same steps now use 42% fewer words.

What's next

  1. Alexa as the host: "Alexa, I accuse Sam."
  2. Question the AI detective after the reveal.
  3. Creator accounts and payouts by plays.
  4. A new case every week, and Dead Air-style mechanics in AI-written cases.
  5. Launch on Fire TV hardware, with more seats for bigger groups and more languages.
  6. Measured playtests of AI-written cases: solve rate, completion, whether players find the clues fair, and how many go on to play another case.

Who made what

  • Code: Ryan Zhang, with Claude Code (Anthropic's AI coding assistant) writing most of the code, tests and docs at his direction.
  • Dead Air: story and game design by Roxanne.
  • AI in the product: cases created in the app are written by Nova 2 Lite. All case art, Dead Air's included, is made with image models on Bedrock, and all in-game narration is Amazon Polly. AI-written cases are labeled in the app. Sounds are CC0 or public domain; fonts are under the SIL Open Font License.
  • The video: shown on the Vega Virtual Device; players scripted for the recording. Its voice-over is Amazon Polly on purpose: the same service that narrates every case in the game, so what you hear is what the product sounds like.
  • Full credits: docs/submission/CREDITS.md.

Built With

Share this project:

Updates

Submission history