Updated July 2026. If you've never opened a REVIEW.md file, here's what's actually in one, why it's the format Walkie hands your agent instead of the recording itself, and how it compares to the alternatives you're probably using right now — pasting screenshots, or just describing the bug in a sentence and hoping.
What's inside a REVIEW.md file
A REVIEW.md is a plain markdown file built from a fixed template: a title, a short note, an instructions block written directly to Claude ("read this fully before opening anything else"), a full transcript with frame references inline at the moments they were captured, a frame index table, and a duration line. Nothing in it requires a video player.
Walk through the real template and the structure holds no surprises. Right after the title there's a section literally headed "How to read this (for Claude)" — four or five plain-English rules telling the agent the transcript is the primary signal, that frame references sit inline exactly where they happened, and that it should open only the frames relevant to what it's being asked about. That instructions block is itself part of the bundle's information-gain trick: the file doesn't just contain data, it tells the agent how to spend its budget reading that data.
Further down, a dedicated "Frame index" section lists every captured frame in one place — a lookup table an agent can scan before committing to opening any single image. That separation matters: the transcript carries the narrative and points to frames inline as they come up, while the index gives the agent a bird's-eye view to sanity-check which frames it actually needs before it spends tokens opening them. The file closes with a duration line and a plain sign-off — "recorded with Walkie" — and nowhere in that structure is there a step that requires decoding video.
Why markdown instead of video
Video optimizes for a human watching in real time; markdown optimizes for an agent that needs to locate one fact fast. A transcript can be searched, quoted, and reasoned over token-by-token. A video file can't be parsed by a language model's API at all — there's no "read this .mp4" call, so a recording that never gets transcribed is simply unusable to the thing you're trying to hand it to.
That's also why the template says, in plain language, "never open the recording video file — it's for humans only." The video still gets saved to disk, in case a person wants to watch it back. But the agent's job is done entirely inside the markdown, which is the whole point of building the bundle in the first place: the recording is scaffolding, the ~3,500-token bundle is the product.
Can any AI agent read a Walkie bundle
Yes — a REVIEW.md is standard markdown with a frame index table and inline image references, formats every current coding agent already parses as part of normal file reading. There's no Walkie-specific plugin required to open the transcript or the instructions block; an agent just needs the ability to read a .md file and, when it chooses to, open a referenced image.
That "any agent" claim is checkable rather than a slogan, because the format itself is published (more on that below). If an agent can already read a README, it can already read a REVIEW.md — the only new behavior is choosing which of the referenced frames are worth the token cost to actually open. Nothing about the file depends on Walkie's own app being installed, on a proprietary viewer, or on an MCP server being connected — the bundle works the moment it lands in a project folder, whether the agent gets there through a file read, a pasted path, or a tool call.
How big is a typical bundle
A complete Walkie bundle — transcript, referenced frames, and the frame index table — runs about 3,500 tokens, measured across real recordings on Roberto's machine. That's the number printed on Walkie's site and the one this whole format is built to hit; every other design choice, from dwell-based frame selection to keeping frames out of the main transcript flow, exists to keep that total down.
For scale, one full 1080p screenshot alone costs roughly 2,691 tokens to read, calculated from Anthropic's published high-resolution image-token formula (Source: Anthropic, 2026). A bundle that covers an entire review — narration, context, and several pointed frames — for close to the cost of one raw screenshot is the entire argument for the format.
Zoom out further and the gap gets more dramatic. Sampling the same 30-second review at one frame per second, the naive way an agent might try to "watch" a recording, comes out to roughly 80,730 tokens — calculated the same way, 30 screenshots at 2,691 tokens apiece. A REVIEW.md bundle covering that same review comes in at about 3,500 tokens: a 23× reduction, or roughly 96% fewer tokens, for a review an agent can actually act on instead of skim.
What actually makes it into a bundle
Not everything gets captured — the template is built around selectivity, not exhaustiveness:
- The full transcript — everything you said, in order, forming the primary narrative the agent reads first.
- Frame references inline — placed in the transcript exactly at the moment a frame was captured, not batched separately.
- A frame index table — a compact lookup so the agent can see what frames exist before deciding whether to open any.
- A token-budget note and duration line — metadata that tells the agent roughly what it's spending before it spends it.
What's deliberately absent is a dump of every frame from the recording. The template instructs the agent to open five or fewer of the referenced frames, at roughly 900 tokens each — a constraint baked into the file's own instructions, not left to the agent's judgment alone. Do the arithmetic and the ceiling is obvious: five frames at 900 tokens is 4,500 tokens on frames alone, which is why the instructions push toward fewer, and why a typical transcript-heavy bundle lands closer to 3,500 total — most reviews don't need all five.
How does Walkie decide which frames to include
A frame earns a spot in the bundle because you pointed at something and dwelled there, or circled it while talking — not because a timer sampled the screen at a fixed interval. That's the mechanism SELL-LOCKED calls "intent-selected frames": your voice and your cursor are the selection algorithm, and a frame that never got that attention never becomes part of the file.
This is also where Walkie's pitch gets specific about the field rather than claiming to be alone in it. Clipy, a live competitor, already ships a similar recording-to-markdown format — transcript, extracted frames, click coordinates, even an MCP server (Source: SELL-LOCKED §7, 2026). Walkie's difference isn't "nobody else does this." It's that pointing decides which frames matter by intent, not by every click logged, and that the format costs $39 once against Clipy's $9 a month.
Is the bundle format open
Yes — Walkie publishes the REVIEW.md format spec publicly rather than keeping it proprietary. The reasoning, straight from the GTM plan: open-ness earns developer trust without having to open-source the whole app, and it turns "any agent that reads markdown can open this" from a claim into something a skeptical reader can actually go check.
That matters more in this category than most, because the audience buying Walkie is exactly the audience that audits vendor claims for a living. A closed format asks for trust; a published spec asks for nothing — you can read the structure yourself before you ever install the app. It's also a deliberate contrast with treating the bundle format as a moat: the moat isn't the markdown structure, which anyone can copy — it's what decides what goes into it, which is the pointing and the voice, not the file shape.
REVIEW.md bundle vs. the alternatives
| Format | Token cost | Can an agent open it? |
|---|---|---|
| Walkie REVIEW.md bundle | ~3,500 tokens (measured) | Yes — plain markdown + inline frame refs |
| Raw screen recording (video) | N/A | No — not readable by the API at all (Source: Anthropic, 2026) |
| A pile of 4 screenshots, no narration | 10,764 tokens (calculated) | Yes, but no context for what to look at |
The video row isn't a strawman here — it's the honest baseline for "what happens if you hand an agent the raw recording," which is nothing, because there's no API call that reads a .mp4. The screenshot-pile row is the comparison that actually matters, since that's what most people paste today: four screenshots to cover one page costs more tokens than an entire narrated bundle, and still says nothing about which part you care about or why.
The takeaway
A REVIEW.md isn't a clever compression trick applied to a video — it's a different object entirely, built from the transcript outward, with frames earning their place by what you pointed at rather than by existing. That's why it reads at roughly a seventh the cost of four bare screenshots for coverage a screenshot pile can't match, and why the format is worth publishing openly rather than protecting: the value isn't the file structure, it's the pointer and the voice that decide what goes in it. For the raw token math behind why this mattered enough to build, see why a screenshot costs your coding agent 2,691 tokens to read; for why video specifically was ruled out as the fix, see why AI can't watch your screen recordings.