What Conch Actually Is: A Game Engine for Streamable Audio Adventures
Most tools that "make adventures with AI" generate a story you read once. Conch generates something you play: a structured adventure with real state, rules, and a win condition, then runs it as a game. Two halves, one engine, which we call Concoct. A no-code authoring pipeline that compiles a plain description into a playable adventure, and a runtime that streams it back turn by turn. Neither half is a product alone. This is roughly how each works.
An adventure is data, not prose
The thing Concoct builds isn't a block of text. It's a set of typed entities, stored as database rows in four tables: scenes (places), beings (characters), possessions (items), and a separate table for information (facts you can learn). Each has relationships: this item sits in that scene, this character holds that letter, this fact is known or not. On top of the entities sits the part that makes it a game rather than a story: a graph of gates.
A gate graph is a directed graph. Nodes are consequential actions ("unlock this scene", "reveal this item", "learn this fact"), and edges are prerequisites, combined with AND / OR logic. You can't enter the warehouse until you hold the key; you can't get the truth from the smuggler until you've earned it. That graph is the difference between a narrative that just happens and a puzzle that resists you in the right order.
You author by describing, in a text chat
Building an adventure is a written conversation. You describe what you want, and Concoct extracts entity "seeds" from it, then immediately materializes them into real database rows. One detail that matters: each seed keeps its id when it becomes a row, so an entity's identity is stable from the first mention through to gameplay, which is what keeps the gate references resolvable later. Separately, it derives the gate graph by running several focused AI passes (win condition, plus blockers for scenes, items, and each character), then compiles all of it into a structured skeleton. A later pass fills in the writing (descriptions, prologue, narrator guidance). Media is a distinct phase: images, ambient sound, a rendered map, and narration audio, generated and stored as files. Voice is never part of authoring.
Concoct proves the adventure is winnable before anyone plays it
Because the whole thing is structured, it can be checked automatically, in two layers.
First, static reachability. Starting from the opening scene, the engine expands everything you can reach (scenes you can enter, items you can pick up, characters you can defeat, facts you can learn) and repeats until nothing new opens, then asserts the win condition is inside that reachable set. This catches the classic dead end where a key is locked behind the very door it opens. Publishing is gated on this reachability check passing.
Second, an automated playtester: an AI plays the adventure through the real engine, turn by turn, up to a turn limit, and reports back where a player might get stuck and how hard it plays -- a diagnostic that helps the creator tune pitfalls and difficulty before release. Most AI story tools can't do either check, because they never had a structured world to check, only text.
The runtime is where the real work is, and it's mostly text logic
A turn is a short pipeline. Your speech becomes text at the edge (a thin transcription step). The engine assembles context and asks the model what you meant. The model replies in plain text, not JSON: a line of private reasoning, the narration to speak, and a list of events like PICKUP, GIVE, RELOCATE, FIGHT, TALK_TO_NPC.
Then two things happen that are the actual substance of the system.
Reference resolution. You said "the letter." The model tags it with a short code; the engine maps that code to one specific database row and refuses if that thing isn't in your current scene. Vague words in, one exact entity out, or a clean rejection.
The state handler. This is the core. About two dozen action types, each with a dedicated handler that mutates real state: your location, your inventory, a character's health, what you know. State changes are made on a copy and saved with a version check, so two turns can't clobber each other. Only the last step, turning narration into audio, is the "voice" part, and like transcription it's a thin adapter at the edge. By volume, the engine is context assembly, the plain-text protocol, reference resolution, the event dispatch, and the gate logic. The audio brackets it.
The engine holds authority, not the model
This is the design decision that keeps a generated world honest: the model proposes, the engine disposes. The consequential unlocks (open a scene, reveal an item, grant a fact) are engine-only; the model literally cannot emit them. Every action the model does propose is checked against the gate graph before it takes effect, and a failed action is logged as failed, never quietly counted as success. So the model can narrate flavor, but it can't cheat a locked door open or hand you a reward you didn't earn.
Nothing is downloaded. It's streamed from a catalog
You browse a catalog of published adventures, which loads only lightweight metadata (title, cover, description), not the adventure itself. There's no package to download. Play happens turn by turn over a live stream: each turn sends your input and a state id, the server loads your saved state and the adventure from the database, runs the turn, and streams back narration and the new state as it's produced. A useful side effect of streaming: narration sentences start turning into audio while the engine is still processing the turn's events in parallel, so you hear the reply quickly instead of after everything settles. Gameplay audio is ephemeral, delivered inline in the stream; authored assets like the cover and scene narration are stored files served by URL.
So, plainly
Conch is a platform. Concoct is its engine: it compiles a written description into a typed, gated, verifiably winnable adventure, and runs it as a streamed game with real state and rules. The voice is the surface. The engine is text, state, and rules.