MARIONETTE'S HAND [LA09B]

• 

  Here is the event chronicle tool that leverage the AOHK FACET JSON bundle that has structured events with location, characters and actions.

• 

  The event editor-- adjust prompts, add triggers to make changes in the image rendering.

• 

  Video Player

Inspiration

Building LATTICE, we noticed a gap in our own system: of the three generative classes in a FACET storyworld — Locations, Characters/Objects, and Events — two had a render target. Locations became Marble worlds. Characters and objects became rigged TRIPO bodies. Events had nowhere to go; they only drove triggers and scripts inside a world someone else was already walking. We wanted events to have their own surface too — for the bundle's timeline itself to become something you could watch and move through, not just logic that fires when a player happens to walk near it.

What it does

Chronicle takes every event in a FACET bundle's timeline and turns it into a walkable vision. For each event: a seed comes from the event's own location (the Marble world's own thumbnail or pano, a derived reference image, or a scene staged and captured live in 3D); a prompt is compiled from the event's canon fields into a layered contract — a base description, a consistent camera/movement template, and beat fragments expanded from the event's own keyActions, each one traceable back to its exact source in the bundle; and the result streams live — not a rendered clip, but a real-time, WASD-navigable world model you can walk through and film from inside.

Run a single event, or run the whole Chronicle — all 11 events from the bundle's timeline, in order, concatenated into one reel where every clip still carries its entityRef and full recipe back to canon.

Chronicle is the deliberate other half of a pair. Its sibling submission, LATTICE (LA09A), uses Reactor's Helios model to let you inhabit and steer a distant body live, in the present tense, on a camera locked to a device feed — that's Connection. Chronicle uses Reactor's LingBot World 2 model to let you step outside the fiction entirely and freely walk through what canon says already happened — the past tense, on an omniscient, unlocked camera. Two Reactor models, two tenses, one shared manifest.

How we built it

• FACET authored and exported the cosmology bundle shared with our sibling submission.
• Chronicle reuses LATTICE's existing pipeline end to end rather than standing up a second product: Marble worlds seed each vision with the same world the player already walks in Playtest; TRIPO bodies cast the event's participants, composited into the seed for real likeness; Playtest's 3D staging lets us place real embodied GLBs in the Marble world, orbit to frame the cast, and capture the canvas itself as a seed — correct scale, grounded placement, real likeness, not a flat 2D paste.
• A layered prompt compiler turns canon into a generation contract: a base description (≤600 characters, from the location's and cast's own canon fields, no motion or camera language), a camera/movement template (reused verbatim across all 11 scenes, so consistency is structural, not incidental), and beat fragments (≤500 characters each) expanded from an event's keyActions — split by code, expanded by the model, each one stamped with a sourceRef back to its exact canon origin.
• A canon-drift gate (verify_chronicle_scene, a no-spend check) verifies every fragment depicts only what its keyActions/effect actually contain, before any generation budget is spent.
• Reactor's LingBot World 2 streamed each vision as a genuinely steerable space — WASD and axis control, a 0.25-second steering chunk (roughly four commands a second), set_prompt hot-swaps for lighting, weather, or content mid-stream with no restart, and native MP4 capture through the same recorder Helios uses.
• Server-side ffmpeg concatenated the timeline's events into one reel — 10 of 11 events streamed as fully live vision, with a single styled title card as fallback for the one event with no bakeable location, so the reel never breaks.
• Tech stack: World Labs Marble, TRIPO 2D and TRIPO 3D, Reactor (LingBot World 2), Anthropic Claude, Vite + React + Three.js, Vercel (hosting and our Eve agent framework), Google Cloud infrastructure.

Challenges we ran into

• LingBot World 2 anchors an entire steered stream on one reference image and one composed prompt — and the image wins when the two disagree, so a mismatched seed shows up as a visual artifact, not an error. Picking a seed became a casting decision as much as a technical one.
• Building three fallback tiers for seeding a vision — a baked Marble world's own imagery, a derived reference, or a title card — so a Chronicle run never breaks on an event whose location wasn't fully generated.
• Keeping the prompt compiler disciplined: the split between canon and generation had to stay code, not model work, so the compiler transforms authored text into a prompt rather than inventing content the bundle never specified.
• Getting real, correctly-scaled likeness into a seed meant staging bodies in the actual 3D world and capturing the canvas, not compositing a flat reference image after the fact.
• Running two different Reactor models — Helios for live, present-tense steering in our sibling submission, LingBot World 2 for free, past-tense navigation here — off one shared manifest and Reactor surface, without either one stepping on the other.

Accomplishments that we're proud of

• Giving Events — the one canon class with no generation surface in our original build — a render target of its own, so every class in a FACET bundle now has somewhere to go.
• Every clip in the reel is auditable: entityRef and full recipe (model, seed, prompt) traceable back to the exact canon that produced it.
• Building Chronicle almost entirely out of infrastructure LATTICE already had — Marble worlds, TRIPO bodies, the transpose manifest, the Reactor surface — rather than a second product from scratch. One manifest renders both the present and the past.
• 10 of the bundle's 11 events streamed as fully live, navigable vision — only one event needed the fallback.
• Proving the Connection/Chronicle contrast itself: the same canon, the same manifest, and two genuinely different tenses of experience.

What we learned

• The same reference-capture and manifest infrastructure generalizes further than we expected — real-time interactive steering in the present tense, and free navigation of the past, without touching how the underlying story was authored.
• Reusing infrastructure across two hackathon submissions paid off more than building each in isolation would have — neither project had to reinvent world generation, embodiment, or the Reactor connection surface.
• A tight, disciplined prompt-compilation contract — strict character limits, code-driven splitting, model-only expansion — did more for visual consistency across many generated shots than manual prompt tuning ever could have in the time we had.

What's next for [LA09B] MARIONETTE'S HAND

• Extend the canon-drift gate into a full pre-flight report across an entire Chronicle run, not just per fragment.
• Let an operator branch the Chronicle — choosing between valid interpretations of a beat — leaning further into the Branched Narrative category itself.
• Fold Chronicle's three-tier seeding (baked world → derived reference → title card) back into LATTICE as a general-purpose fallback for any generation surface, not just events.
• Publish a hosted cut of the full reel, watchable without opening the workbench at all.

Built With

• anthropic
• claude
• facet
• lattice
• lingbot
• marble
• reactor
• tripo
• wordlabs