Mostly no. Paste a Loom link into Claude Code or Cursor and the agent receives your narration as text — never the screen you were pointing at. Loom's built-in AI layer works on the transcript of what you said, not on the video's pixels, so the visual half of your review, the part that actually shows the bug, never reaches the agent.
Updated August 2026: that's still true for both agents, and it isn't a bug either company is racing to fix — it's a structural mismatch. Loom was built to carry video to a human who watches it later; a coding agent reads text and still images. It's one instance of a pattern that runs through the whole vibe coding workflow: the tool you use to build something and the tool you use to review it were rarely designed by the same people, for the same reader.
This isn't Loom being bad at its job. It's an excellent tool for what it was built for — asynchronous video review between people. The mismatch is entirely about the reader changing from a human to a coding agent.
A five-minute Loom of a broken checkout flow makes complete sense to a teammate watching it once. Handed to an agent as a link, it's closer to a locked door: the transcript describes the walkthrough in general terms, but the exact layout shift you were circling with your cursor lived in three seconds nobody transcribed, because there was nothing to transcribe — it was never speech.
| Metric | Tokens |
|---|---|
| A typical spoken review transcript | ~150 (measured, typical) |
| Frame-dumping the same 30-second review at 1 fps | 80,730 (calculated) |
| A narrated bundle keeping the words and the frames | ~3,500 (measured, typical) |
What happens if you try?
Coding agents work in text, not video. Drop a Loom link into Claude Code or Cursor and nothing plays — there's no video player in the chat. At best, the agent sees the page's title and any transcript text you paste alongside it. The pixels themselves never arrive, no matter how the link is shared.
If your setup includes a browser or computer-use tool, the agent might go further and open the page itself — but that gets it a paused video player, not a timeline. Screenshotting that gives you one frame, at whatever timestamp the player happened to load on, not the moments you actually narrated. Cursor accepts pasted images directly in chat, and Claude Code can read images you attach, but neither turns a hosted video into a sequence of frames on its own. That conversion step doesn't happen unless a human, or a separate tool, does it.
The two agents differ slightly in mechanics but land in the same place. Claude Code builds its context from what you paste directly or from what its own tools explicitly fetch — a bare URL, without a fetch step behind it, may not resolve into anything readable at all. Cursor treats a pasted link and a pasted image as different operations; only the image gives the model pixels to look at. In both cases, sharing a link is a text action, not a visual one.
What does Loom's AI actually read?
Loom's AI features — auto-generated summaries, chapters, action items — are built on speech-to-text transcription of your narration. That's a real, useful product for a person skimming a recording later. But it means the AI layer only ever processes what you said out loud, never what was on screen while you said it.
That's not a limitation Loom is hiding. The product's own positioning is video for people, and a transcript is what makes a five-minute recording skimmable in thirty seconds. It's a genuinely good tool for that job. The mismatch only shows up once the reader stops being a human and becomes a coding agent, which has no way to sit through a timeline the way a colleague would.
There's a real edge case worth naming honestly: sometimes the transcript alone is enough. If your narration names the exact component, file, and behavior — "the submit button on the checkout form stays disabled after a successful validation" — an agent can act on that sentence without ever seeing a frame. What a transcript can't carry is anything you only showed and never fully put into words: a color that's subtly off, a hover state, a layout that shifts by a few pixels. Precise language and a screen are different bandwidths, and pointing exists for the moments language runs out first.
Why can't the agent see the frames?
Turning video into something an LLM can reason about takes an explicit step: extracting individual frames and running each one through a vision model's tokenizer. Loom's AI stack doesn't do that — it was built to summarize speech, not pixels. A generic link fetch skips that step too. Without it, the frames simply don't exist anywhere the agent can reach.
This is the same reason a paragraph describing a chart isn't the chart. The information a screen holds — layout, spacing, color, what moved and when — has to be captured as an image and priced in image tokens before an agent can reason about it at all. Claude processes images through a fixed patch-based formula (Source: Anthropic, 2026): tokens = min(4784, ceil(width/28) × ceil(height/28)). Nothing about that formula runs automatically over a hosted video. Someone has to hand the agent individual frames before it applies.
What about downloading and frame-dumping it?
You can pull this off yourself: download the raw Loom recording, then extract frames at a fixed interval — say, one per second — and paste each one in as an image. This genuinely gets pixels to the agent. It's just expensive and mostly redundant with what your narration already said.
Loom lets you export your own recordings, so nothing about this is hypothetical or blocked. The procedure is straightforward:
- Download the original recording from Loom's export option, or pull the raw file if you're self-hosting.
- Extract frames at a fixed interval with a tool like
ffmpeg— one frame per second is the common default for a short walkthrough. - Resize the frames before feeding them in. Full-resolution frames blow past the per-image token cap and cost more, not less.
- Paste or attach each frame to the agent in order.
- Add written notes for what happens at each timestamp — the frames alone carry no narration, so skipping this trades the transcript's meaning for pixels and keeps neither.
This is a real workaround, not a strawman. For the broader rundown of what actually works with Claude Code specifically, see screen recording for Claude Code. But the moment you add up what step 2 costs, the tradeoff gets obvious fast.
What does that cost?
Thirty frames at one per second, each a 1080p screenshot costing 2,691 tokens on Claude 4.7 and later, comes to 80,730 tokens before narration. At $10 per million input tokens, that's about $0.81 for thirty seconds, and roughly 40% of a 200k context window is gone before the fix starts.
Put next to the alternatives, the frame-dump is the expensive way to get pixels across:
| What you send the agent | What arrives | Includes the pixels | Tokens for a 30-second review |
|---|---|---|---|
| A pasted Loom link | Page text/metadata only — the video itself can't be opened | No | Nothing to read |
| Loom's AI summary or transcript, copied in | Your narration, as text | No | ~150 (measured, typical) |
| The recording, downloaded and frame-dumped at 1fps | 30 still frames | Yes | 80,730 (calculated) |
| A narrated review bundle (transcript + chosen frames) | Narration and a handful of intent-selected frames | Yes | ~3,500 (measured, typical) |
The frame-dump row and the bundle row both include the pixels. The difference is that a bundle doesn't pay for every unwatched second — it pays for the seconds you actually pointed at something.
What works instead?
A format built for narration, not playback: your spoken review as a short transcript, paired with a handful of frames chosen by what you pointed at rather than a fixed frame rate. That combination runs to roughly 3,500 tokens for a typical review — pixels and words together, without paying for every unwatched second.
That shape — transcript plus intent-selected frames, packaged as something an agent can read in one pass — is what a REVIEW.md-style bundle actually contains, and it isn't a one-vendor idea. Clipy takes a version of this approach, extracting frames and a transcript into an agent-readable file. Walkie is another, built around narration and pointer intent choosing the frames rather than a clock. Which one fits depends on your stack and your budget — the fuller field, compared at real prices, is in tools for giving feedback to Claude Code, Cursor and Codex, compared.
Where to go from here
- If you're already narrating Loom walkthroughs for a coding agent, stop pasting the link. Export the clip yourself and hand-pick three to five frames at the moments you're actually talking about — that alone beats a full frame-dump on tokens, for free, with any tool you already have.
- If you're doing this often enough that hand-picking frames is the bottleneck, look at a tool built around that shape from the start rather than assembling it manually each session.
- Either way, keep the narration. The words are cheap, and they're carrying more of the review than most people assume.