• 

• 

• 

• 

What if the next scene was your idea?

One Small Twist turns the living-room mystery into a shared investigation: watch the story, follow the clues, and ask what would happen if one decision changed.

At a glance

One television. One remote. A room full of theories.

One Small Twist is a native Fire TV game built for Vega OS. It combines twelve authored mysteries, evidence-based investigation and optional AWS-powered storytelling. Players can explore a prepared change, ask Amazon Nova to write a new alternate timeline, or describe a mystery of their own.

The project brings together:

• Multiple authored cases across Drama, Suspense, Comedy and Heist, with Easy, Medium and Difficult entries in each genre.
• New playable what-if timelines: eight scenes with new dialogue, supported actions and consequences.
• A private mystery creator: a premise becomes a cast, script, artwork, prepared voices and a playable investigation within our supported story engine.
• An evidence engine: original clues remain the basis of the solution, even after the player explores an alternate story.
• A repeatable submission: pinned source, target-specific VPKG builds, an official-simulator route and a free rehearsal that needs no AWS credentials.

Inspiration

A good mystery rarely stays inside the television. Someone notices a glance. Someone distrusts an alibi. Someone says, “If he had just asked her first, none of this would have happened.”

That conversation was our starting point. We wanted the family on the couch to have a way to test its ideas inside the story.

The Last Message captures the idea in a wedding interrupted by a disputed text. Nina, Sam, Iris and Leo each know different pieces of what happened. Finding the responsible person matters, but understanding the chain of decisions is what makes the investigation interesting.

Fire TV felt like the right home: a shared screen, familiar remote controls and a story people can discuss together without everyone opening a separate app.

What it does

Watch, investigate and earn the explanation

The opening introduces the situation and cast. Players question characters, inspect clues and build an account of the original events. Short prompts make the next action visible. Captions, reduced motion, saved progress, leaving and replaying support different ways of playing.

The catalogue presents mysteries as stories to explore, with distinct genre artwork and a preview before Play. The TV remote is enough to navigate the authored investigation.

Change one event and follow the consequences

Prepared experiments make cause and effect easy to try. The AI path goes further: the player writes a what-if, Nova develops an alternate story, and the player reviews the proposed premise before watching it.

For example, a player can ask what changes if Leo is in the dressing room when Iris uses Nina's phone. The writing task has to connect what Leo witnesses, who he tells and how that knowledge changes the wedding. New scenes use the existing cast, locations and supported visual actions.

The alternate story stays separate from the original investigation. Something discovered only in a what-if cannot become proof of what originally happened.

Create a mystery of your own

Players describe a missing object, setting, relationships and tone. The backend develops the story, compiles its investigation, prepares artwork and voices, and saves the completed case to that detective's private library.

The current creator supports four speaking adults, two sets and a bounded missing-object framework. Extra relatives or pets can appear in narration. These limits give the generation pipeline a concrete visual and logical canvas.

Production shows its actual stages and completed asset counts. Released scenes play continuously with prepared speech, captions and supported camera/movement cues. Replaying a saved case reuses its content.

How we built it

1. A native television experience

The client uses React Native for Vega, TypeScript and Amazon's native adapters. It handles remote focus, native text input, detective persistence, captions and scene playback. W3C media and the filesystem adapter support local playback of approved speech. Some authored presentations use WebView and Three.js.

The package is a Vega VPKG: aarch64 for our Apple Silicon simulator and armv7 for the tested Fire TV Stick 4K Select.

2. Rules that keep the mystery fair

A Node.js backend owns saved actions, private assets and case rules. Original truth, clue visibility and proof are explicit application state.

For custom mysteries, a typed compiler checks four suspects, two possible methods and eleven original/changed configurations: 88 worlds. It verifies the supported mechanics before release. The prepared Midnight Recipe train provides a no-AWS rehearsal of the same investigation engine.

3. AWS services with specific jobs

Amazon Nova 2 Lite on Amazon Bedrock develops character motives, causal beats and a shared story plan before focused scene writing and dialogue editing. Branch storyboards bind the location, visible cast and speaker together. Grounded question interpretation maps requests to allowed testimony during play.

Stable Image Core on Bedrock creates room and character masters. Stable Image Remove Background prepares character layers. Images pass bounded format, transparency and content checks before use.

Bedrock Guardrails applies the configured text/image policy. Model review and application checks support consistency; neither is treated as a guarantee of good storytelling.

Amazon Polly prepares approved generated lines before playback. Cached speech and private saved assets allow replay without another generation request.

4. State outside the prompt

Typed schemas, ownership checks, idempotent requests and a persistent reservation ledger surround the model calls. Credentials stay on the backend. Failed or uncertain paid requests remain recorded, even when a creation credit is returned.

The submitted setup runs locally. AWS generation is opt-in; ordinary setup and tests make no paid calls. We have not deployed a public consumer backend or published an Appstore listing.

Challenges we ran into

Making one changed decision reshape the story

The central promise of One Small Twist is that a player’s idea should have consequences. If someone witnesses a message being written, that knowledge should affect whom they trust, what they say and what happens next.

Delivering that requires more than generating dialogue. We moved character motives, event order and knowledge into a shared story plan before writing scenes. We also connected each scene’s location, visible characters and speaker. Our goal is for players to recognize their idea in the events they watch.

Designing for everyone on the couch

A shared television creates a different design challenge: one person holds the remote, while everyone needs to understand the story and contribute a theory.

Early feedback showed that our next steps were unclear. We redesigned the experience around story previews, recognizable character introductions, focused investigation prompts and explicit play, leave and replay actions. D-pad navigation and native text entry needed their own testing. Every screen had to make the next decision understandable from the sofa.

Giving players creative freedom while keeping the mystery fair

A surprising alternate timeline can change what happens. The original investigation still needs a dependable answer.

We separated original evidence from alternate fiction. Players can explore a different decision and follow its consequences, while their final explanation remains grounded in clues from the original story. That boundary gives the experience room for imagination and a clear basis for solving the case.

Keeping the experience feeling like a show

Pauses for speech generation, repeated Continue buttons and lost scene position could pull attention away from the characters.

We moved approved voice preparation into production, cached speech for replay and added continuous playback and saved scene recovery. We also worked through native media delivery and device reconnection. The product challenge was preserving the thread of the story across the practical realities of television use.

Accomplishments that we're proud of

We made “what if?” the heart of a living-room game

One Small Twist gives a familiar mystery-night conversation a playable form: watch together, question the characters, compare theories and explore a changed decision.

The catalogue includes twelve authored mysteries across Drama, Suspense, Comedy and Heist, with three difficulty levels in each genre. Previews help players choose a story, while saved investigations let them leave and return. We built and ran the game in the official Vega simulator and installed it on a physical Fire TV Stick 4K Select.

We connected player imagination to new playable content

We implemented genuine Nova-written alternate timelines with eight voiced scenes, new dialogue, supported actions and saved consequences.

Create your own mystery extends that creative loop: a player’s premise feeds a pipeline that develops characters, a script, artwork, prepared speech and an evidence-based investigation. We completed production and recovery of a custom case through that pipeline. Released cases and branches can be saved and replayed without generating the story again.

We built a foundation judges can inspect and try

The creative features sit on explicit rules for evidence, ownership, saved progress and proof. Our latest verification passed 1,301 host tests, TypeScript and a real-HTTP rehearsal with zero paid calls.

We also prepared downloadable simulator and physical-TV packages, pinned setup instructions and dedicated private access for live AWS testing. That makes the project available for evaluation as both a television experience and a working implementation.

What we learned

Cause and effect should come before dialogue

The most useful story context is who wants what, what happens, who witnesses it and what changes because of it. Once that is clear, dialogue has a job to do.

Continuity is part of intelligence

An intelligent story feature must remember its cast, location, saved state and evidence boundaries. A clever paragraph loses its value when the next scene contradicts it.

The television changes the design

Focus, readable captions, a clear next action, continuous playback and recovery after sleep are central to the experience. Testing those on the target platform changes decisions a desktop preview cannot settle.

Quality needs more than a passing validator

Rules can check ownership, schema, custody and proof. People still need to judge whether an exchange feels natural, an ending satisfies the premise and the result is enjoyable to watch.

What's next for One Small Twist

Make the creative output more consistently satisfying

Expand scenario-based evaluations for character presence, knowledge transfer, consequences and emotional payoff. Use human read-through and target-device playthroughs alongside automated checks.

Deepen the visual performance

Improve shared staging, character scale, reactions and transitions within the current renderer, then evaluate richer animation against real Fire TV performance limits.

Learn from households

Test unaided first play, comprehension, accessibility and whether the what-if mechanic makes people discuss the story together. We are not claiming measured household adoption or retention yet.

Grow from a reproducible prototype to a release

After the hackathon, prepare controlled hosted access, privacy/support materials and Amazon Live App Testing before a public Appstore launch. Broader casts, more story mechanics and additional languages should follow validated production quality and cost.

Our aim is simple: make the question everyone asks during a mystery—“what if?”—something the whole room can play.

Built With

• amazon-bedrock
• amazon-fire-tv
• amazon-nova
• amazon-polly
• amazon-web-services
• asyncstorage
• aws-sdk
• bedrock-guardrails
• github
• github-actions
• node.js
• react
• react-native
• stable-image-core
• stable-image-remove-background
• three.js
• typescript
• vega-os
• webview