See it work

Reading about an agent tells you what it claims. Below is every screen koda has, recorded from the real binary: its own rendering, its own diff, its own approval prompt, its own status bar.

These are not videos. Each one is a terminal recording played back in the page — the text is real text, so you can pause it, scrub it, and select and copy any line out of it.

Start here

• Fixing a bug, start to finish0:23
• Pointing it at a model0:13
• Pointing koda at your server0:13
• First run, from the shell0:21

Using koda

• /help0:09
• Keyboard shortcuts0:06
• Eleven palettes, switched live0:15
• Plan, execute, vibe0:13
• Nothing is written without you0:16
• Putting a file back0:15
• Watching it think0:15
• When it needs a decision0:16
• Stopping a run0:12
• Every tool it can call0:06
• The command palette0:10
• Attaching a file with @0:10
• Running a command yourself0:11
• What it has been doing0:23
• Compacting the context0:37
• Headless: koda -p, in any mode0:47
• Everything, editable in place0:11
• How much it may do unasked0:10
• How hard it thinks0:11

Capabilities

• Delegating to a subagent0:16
• Finding a symbol without grepping0:18
• Remembering how your project works0:20
• Project rules, loaded only when they apply0:20
• Your own commands as tools0:20
• Reading a spreadsheet with @0:20
• Acting on an AI! comment0:24
• Every past conversation0:17
• A real debugger, driven by the agent0:47
• Searching the web0:29
• Driving a real browser0:50
• Serving the web control center0:19

How it works

• When the server refuses native tool calls0:18

Fixing a bug, start to finish100×30 · 0:23

One prompt: koda writes a plan, reads the file, shows the edit as a diff before it lands, marks the plan done, and reports what changed.

How these are made

Every recording is produced by demos/scripts/record.py from a manifest, so the list above and the recordings behind it cannot drift apart:

demos/scripts/record.py            # all of them
demos/scripts/record.py watch      # just one
demos/scripts/record.py --check    # re-verify what is already recorded
demos/scripts/record.py --list     # what is in the manifest

Each demo gets a throwaway git workspace, its own config, and a scripted model (tests/mock_server.py) that speaks the same OpenAI-shaped SSE a real server does. koda is driven through a pty by a script that types like a person, and asciinema records the terminal.

That matters for honesty, so here is the exact line: everything you see is koda. Its markdown renderer, its diff, its approval path, its tool dispatch, its status bar, its code graph, its debugger — all real, and the tools really wrote to a real directory. Where a demo needs the outside world it gets the outside world: the web search demo really queries DuckDuckGo, the browser demo really drives Chromium, and the debugger demo is a real debugpy session reporting real values out of a stopped frame.

The only thing scripted is what the model replies. A local model on a laptop emits around 33 tokens a second, which makes an honest recording of one both very long and different every time. Scripting the model is what lets these be short, and lets CI regenerate them when the UI changes.

A recording that ran but painted the wrong screen looks exactly like a good one on disk, so nothing is published until it has been checked: every demo declares strings it must show, and record.py replays its own recording through a terminal emulator to find them before copying it to the site.