The day ctx7 made a film about itself

We needed a video for the home page. The brief was one line: make something that explains where an AI actually lives. We handed it to the agent, gave it a fal.ai key, and went to do something else.

It came back with a film.

Not a slideshow, not a screen recording. An 80-second animated short called HOME, narrated in the first person by a small cream-white robot named Claude, giving a gentle, golden-hour tour of a cottage in a gated little town. And the twist writes itself: every room turns out to be a piece of the ctx7 dev-server stack the agent is running inside. It made a film about its own house.

The conceit

The whole script hangs on one metaphor — an AI's environment as a home — and it holds up room by room, because each room maps onto something real:

• The street. A cul-de-sac of cottages, each with its own lit nameplate. "Every house has its own address, so anyone can just drive up." That is the public wildcard DNS: every project gets its own subdomain, reachable the moment it exists.
• The front gate. A calm doorman in teal livery checks a glowing ID card and walks each visitor to the right door. That is Traefik — TLS termination and routing, nobody wandering in unannounced.
• Claude's flat. A cozy apartment with a workbench and a door out to the courtyard. The operator container: where the agent actually lives.
• The workshop out back. Half-built cottages on the grass. "When I leave, they're still standing." Bind-mounted project directories — the work persists on your disk, not inside a disposable layer.
• The locked utility room. A friendly attendant hands tools through a hatch but keeps you out of the landlord's mechanical room. That is the Docker broker: scoped access to build and run your own containers, and a hard wall around the core infrastructure.
• The garage. A real car you can take out on the road while the family watches from the window. The headful Chromium the agent drives — and the shared browser view you watch it through.
• The kitchen. A brass mail slot where every letter in and out is read (mitmproxy), a notebook of house rules that never gets thrown out in a renovation (~/knowledge), and an old wall phone for the few chores that need the landlord — the host commands only you can run.

It is a genuinely good explainer, and nobody wrote a storyboard for it but the agent.

How it actually got made

The interesting part is not the concept, it is that the whole production ran inside the sandbox, as an ordinary git-versioned project, driven by a handful of small scripts the agent wrote for itself.

1. A locked look. It fixed a single style block and a character reference sheet, then passed that sheet into every shot so the same robot showed up in every scene instead of nine different robots. Consistency by construction, not by luck.
2. Keyframes. Each scene was drawn as a still with fal-ai/nano-banana/edit, the reference image pinned so the character and palette stayed put.
3. Motion. Every still was animated into a 5–10 second clip with image-to-video models (kling-video for most shots, veo3 for the hero shots that needed ambient sound).
4. Voice and score. The narration was generated with ElevenLabs in one calm first-person take; a music bed came from a stable-audio model.
5. The cut. A little ffmpeg script stretched each clip to match its voiceover, added lead-in and tail, freeze-padded the remainder, built the title and end cards, and concatenated the whole thing. A later pass composited animated ctx7 UI panels — packets, a moving cursor, a pulsing step-dot — drawn programmatically with PIL.

Keyframe, animate, narrate, score, assemble — a real production pipeline, stood up from nothing and run end to end in one box.

The honest part

It did not go perfectly, and that is the part we like most.

Partway through re-shooting two scenes at higher quality, the fal.ai balance ran out. The agent did not paper over it, invent a workaround, or quietly ship a broken cut. It rendered the best complete version it had, wrote down exactly where it stopped — "animated panels done; blocked on fal balance" — and left one instruction: top up the account and it would auto-harvest the two missing keyframes, reshoot the two clips, and rebuild.

That is the same loop the rest of ctx7 is built around. An agent with a real place to work builds the thing, runs it, looks at the result, and when it hits a wall it cannot pass on its own, it tells you precisely what it needs instead of guessing. The blast radius of the whole adventure was one project folder and a metered API bill — nothing on your machine, nothing you had to supervise keystroke by keystroke.

We set out to get a video. What we got was a small demonstration of the whole pitch: give an agent a sealed workshop with real tools, and it will not just write code — it will produce a finished thing and hand it back to you, running.

New here? Start with Give your AI a real dev environment, or read why the box matters in Why isolated containers.