Stash vs Loom: Screen Recording Your AI Agent Can Query

The Short Answer

Record the bug once, and serve both audiences from that one recording. That is what Stash does. You press ⌘⌃V, do the thing that breaks, and stop. A public share link lands on your clipboard for your teammate. In the same folder on disk, Stash writes a markdown timeline of the session that Claude Code reads directly over MCP.

Loom does the human half of that better than anyone, and as of July 2026 it does a version of the machine half too. Video prompts parse a narrated Chrome recording into an Action Plan you can paste into Claude. That is a good feature and it validates the whole premise here: video is not something an agent can watch, so somebody has to parse it first.

The question is who parses it, where, and what the agent gets back. Stash parses on your Mac, covers every app, has no time limit, and answers by capture ID so the agent can pull the same session up again next week. Loom parses in Atlassian's cloud, covers Chrome tabs, stops at five minutes, and hands you text on the clipboard.

If you spend your day in Claude Code or Cursor, that is the entire decision.

Stash vs Loom at a Glance

What Loom Is Good At

Loom won async video for a reason. Record, stop, paste a link, and the person on the other end watches in a browser with no account and no meeting on the calendar. "Async video is the next evolution of team collaboration," Mike Cannon-Brookes said when Atlassian announced the $975 million deal. Atlassian's own numbers at the time: nearly 5 million Loom videos a month, across about 200,000 customers.

The parts Loom does better than almost anyone:

• Viewer experience. Comment threads on the timeline, emoji reactions, calls to action, and view analytics that tell you who actually watched.
• Loom AI. Auto titles, auto summaries and auto chapters generated from the transcript. Most of it sits on the Business + AI and Enterprise plans; auto titles are on every plan.
• Atlassian plumbing. Rovo maps decisions and action items out of a transcript onto Jira work items, and a video prompt can become Jira work items in one step if you have create permission.
• Reach. Everyone in sales, support and design already knows what a Loom is. That matters more than any feature when you are sending a video outside engineering.

That is a strong product for people. The agent question is a different one, and it has a different answer.

Handing a Loom Video to an Agent

Loom ships a path for this now, and it is worth knowing exactly what it covers. Video prompts went into open beta on July 22, 2026. You start a separate recording mode in the Loom Chrome extension, narrate what you want done, and Loom parses the result into an Action Plan: discrete steps, each with a title, a bulleted description, a transcript quote, the clicks and visited URLs behind it, a keyframe and a timestamp. Copy it into Claude, or turn it into Jira work items.

Video is not an agent input at the API layer, so Loom wrote a parser. Anthropic reached the same conclusion and shipped one first-party: Record a Skill, in Claude Cowork since July 21, 2026, analyzes a screen recording plus clicks, keystrokes and narration and produces a reusable Skill. Three parsers, one premise. The difference is what comes out: a Skill, pasted text, or in Stash's case a live capture with an ID an MCP client can re-fetch.

The shipped version has hard edges, and they matter if you are a developer. Video prompts need Business + AI at $20 per seat per month billed annually, $24 month to month, or Enterprise. They run in Chrome and nowhere else, which puts your simulator, your terminal and every native app out of frame. Five minutes is the ceiling, with a countdown on screen. The recording travels to Atlassian's servers to be parsed. And the output is text on your clipboard, so nothing persists that an agent can call tomorrow.

Then there is the ordinary Loom, which is what most of the 25 videos on your free plan are.

Ask Claude Code to look at the MP4 and nothing happens. Anthropic's vision documentation lists the supported image inputs as JPEG, PNG, GIF and WebP, and adds that "animations are unsupported, and only the first frame is used." Video is not on the list at any model tier.

The transcript gets you closer. Loom generates a good one. But you saying "and then it breaks right here" tells the agent nothing about which button you clicked, which window had focus, or what was on your clipboard when it broke.

Screenshotting the video and pasting frames runs into the other line in that same doc: "Claude does not parse or receive any metadata from images passed to it." Your frame arrives as pixels. No app name, no window title, no URL, no timestamp, nothing that would let the model tell Warp from Terminal or your staging tab from production.

Frames are also expensive. Claude reads images in 28 by 28 pixel patches. A 3840x2160 capture is downsized to 2576x1449 and costs roughly 5,000 visual tokens. Thirty of those is roughly 150,000 tokens before the model has reasoned about anything at all.

Anthropic, on image inputs: "Claude does not parse or receive any metadata from images passed to it."

With an ordinary Loom you watch your own video and retype what you saw. Video prompts remove that step for five-minute Chrome recordings on a Business + AI seat. Stash removes it for everything else.

What Stash Hands Over Instead

Every Stash recording writes a self-contained folder next to the MP4. The agent opens one file and has the session:

• report.md is the timeline. Every click with pixel coordinates, every drag with both endpoints, every keyboard shortcut with modifiers, every clipboard copy with the literal text you copied, every app and window focus change, the voice transcript inline with timestamps, plus detected toasts and spinners flagged when they hang past 3 seconds.
• frame_tags.json pairs each frame image with its exact timestamp, app and window title, so the agent aligns "23.8s, focus moved to Terminal" with the frame that shows Terminal. No guessing, no decoding.
• Up to 30 key frames, each labeled start, interaction or end, anchored to real events rather than sampled on a timer.
• llms.txt tells the model what to read, in what order, and to ignore video.mp4.

The compression is the point. A real 5 minute 30 second session produced 2,222 raw interactions. Most were scroll events, and Stash folds them into roughly 20 burst lines like "29.7s to 30.1s, 74 scroll events." The finished report is about 22 KB, near 6,000 tokens, for a session that would be 9,000 raw frames at 30fps.

Frames come back as absolute file paths, not inlined images. The agent reads the timeline first, decides which 5 or 10 frames matter, and pulls only those. That is why a 30-minute recording costs roughly what a 5-minute recording costs.

The part you do not have to do

You never export, attach, copy or paste anything. Stash runs a local MCP server with five tools: list_recent, search, get_capture, get_bundle and render_plain. You type "look at my last recording" and the agent calls list_recent, finds it, and calls get_bundle. Every capture also carries an 8-character ID and a stash://bundle/<uuid> URI, so the agent can re-fetch the same session tomorrow, in a different conversation, after a restart.

No MCP server serves Loom video by ID. Atlassian's Rovo MCP server exposes Jira, Confluence, Compass, Bitbucket and Jira Service Management to AI clients, and video recordings are not among the tools it serves. A video prompt's Action Plan reaches your agent as text you pasted into one conversation. Close that conversation and it is gone unless you filed it somewhere yourself.

Instant Replay and the Bug You Did Not Record

Stash keeps a rolling 60-second buffer of your screen running in the background. The bug flashes, you press ⌘⌃R, and you pick 15, 30 or 60 seconds to save, with the full capture report generated for it. You did not have to predict the bug.

This is the single feature that changes how often video gets used at all. Nobody starts a recording before every build, so intermittent visual bugs go undocumented and get described in prose instead. A rolling buffer catches them after the fact, and a video prompt cannot, because you have to decide to start one.

Where the Recording Lives

Stash keeps your data on your machine by default and makes the one exception obvious. Clipboard history, screenshots and bookmarks live in a local SQLite database and are never uploaded. Copied text is scanned before it is persisted, so OpenAI sk- keys, AWS AKIA keys, JWTs, GitHub ghp_ tokens, Bearer headers and PEM blocks are replaced with [redacted] before they touch disk.

Video is the exception. Auto-upload is on so the share link is ready the second you stop recording. Turn it off in Settings then Recording and nothing leaves your Mac until you explicitly share it.

Loom is cloud-first by design, and video prompts are more so. The recording goes to Atlassian's servers, and in video prompt mode so do the clicks you made and every URL you visited during it. That is exactly what makes the sharing so smooth, and exactly what some teams cannot do with a screen recording of a customer account.

Pricing and Limits

Stash is $4.99 a month for the whole app, and that is not a per-seat number. Loom's free tier is where most developers start, and the 25-recording ceiling is what bites first. Archived videos count against it, so you hit the wall and start deleting bug repros to make room. Screenshots do not count toward it.

The seat math got worse this year. Atlassian is retiring the free Creator Lite role: no net-new Creator Lite users after February 2026, and existing ones are auto-upgraded to full paid Creator seats on their integration date. You get a grace period until your next billing date to review usage and deactivate anyone you do not want to pay for.

Run that on a 100-person workspace where 10 people actually record. Ten Creator seats at $15 billed annually is $1,800 a year, and the other 90 were free. After the conversion, 100 paid seats is $18,000 a year for the same ten people recording. Want video prompts on that workspace and every seat has to be Business + AI at $20, which is $24,000 a year. The tool that reads your recordings is now billed per person on your team.

Which One Should You Use

Use Loom if:

• Your videos are mostly for people outside engineering
• Comment threads, reactions and viewer analytics drive real follow-up
• Your team runs on Jira and Confluence and you want recordings wired into that
• The work you hand to an agent lives in a Chrome tab and fits in five minutes
• You need a seat-based plan with admin controls across a large org

Use Stash if:

• You use Claude Code, Cursor or another MCP client every day
• You want the agent to query the recording, not receive a pasted summary of it
• The bug is in a simulator, a terminal or a native app rather than a browser tab
• Your repros run longer than five minutes
• You want the bug you did not plan for, caught by a rolling 60-second buffer
• Screen recordings of internal systems should not sit on a vendor's servers by default
• You want clipboard history, screen recording and screenshots in one app rather than three

Plenty of people run both. Loom for the demo that goes to the whole company, Stash for the twelve recordings a week that go to your agent and to the two engineers who are going to fix it.

The Bottom Line

Stash is built so a coding agent can query what happened on your Mac. Loom is built so a person can watch it, and now so an agent can be handed a five-minute Chrome summary of it. Both tools parse the recording, because no coding agent you are using reads an MP4 you hand it. The difference is where the parsing runs, how much of your machine it can see, and whether what comes out is a live capture your agent calls by ID or text you paste once and lose.

One sentence in Anthropic's own docs sets the rules for all of this. Claude does not receive image metadata, and it cannot read video. Any capture tool that ignores that is handing your agent pixels and hoping.

Download Stash for free and record one bug. Then ask your agent what happened in it.