If your AI agent runs on a different Mac than the one you're sitting in front of, every other screenshot tool breaks. Here's why Stash is the only one that doesn't.

Key Takeaways

  • Running AI agents on headless Mac Studios — the right architecture for autonomous work — breaks every screenshot tool not built for cross-host paths.
  • Stash's ⌘⌃P hotkey copies a single text string containing the image path, source app, window title, URL, and annotation summary. One paste gives the agent everything.
  • Stash respects whatever save path you set. Point it at a cloud-synced folder marked "available offline" on every host, and the file exists on the agent's host the moment it goes to read it.
  • Hermes Agent's fleet skill handles user-home path translation automatically — /Users/alex/… on the laptop resolves to /Users/hermesagent/… on the Studio with no typing.
  • The full loop is two seconds from screenshot to agent-with-context — faster than AirDrop, SCP, or pasting raw image data, and the only one that carries source metadata.
  • No other tool was built with the headless constraint in mind. Stash got it right by building for plain-text path sharing first.

The setup most tutorials skip

The standard "AI coding assistant" tutorial assumes one computer. You sit at a Mac. You run an AI agent on that same Mac. Screenshots, clipboard, files — everything lives on one filesystem. Hotkeys feed the agent. The agent reads your clipboard. It all works because there's nothing to bridge.

That is not how I run my agents.

I run Hermes Agent on two racked Mac Studios — an M3 Ultra and an M4 Ultra. Both are headless, with HDMI dummy plugs. They sit in a rack with no monitor, keyboard, or mouse attached. I drive everything from my MacBook Pro over Tailscale: SSH for terminals, Screen Sharing when I need a UI.

This is the right architecture for autonomous AI work. The agent runs 24/7 on real hardware. It doesn't sleep when I close my laptop. It survives a power blip. It runs overnight cron jobs while I'm asleep. The MacBook stays a clean daily driver — no GPU heat, no memory pressure, no model server competing with my editor.

But the moment you go headless, every screenshot workflow built for one-machine setups breaks.

The problem with every other screenshot tool

Headless Macs introduce a problem that single-machine tutorials never confront: the path that exists on the Mac that took the screenshot doesn't exist on the Mac running the agent.

I screenshot something on my MacBook. The file lands at /Users/alex/Desktop/Screenshot 2026-05-17 at 11.45.png. I want the Hermes Agent — running on studio-m3, where the user is hermesagent, not alex — to read that screenshot.

Path doesn't resolve. The Studio has no /Users/alex/. The screenshot is on a different filesystem entirely.

Every workaround is bad:

None of these scale to dozens of screenshots a day, which is what AI-assisted coding actually looks like.

What Stash does differently

Stash solves this almost by accident of its design. It wasn't built for the headless case — it was built to copy file paths to AI agents with one hotkey. But the same design that makes single-machine sharing fast also makes cross-machine sharing work.

Three things matter:

1. Save location is configurable

Stash lets you point its auto-save at any cloud-synced folder — Dropbox, Google Drive, iCloud Drive, Box, OneDrive, Sync, Resilio Sync. The Mac that took the screenshot saves it to a cloud-backed path. The Mac running the agent has the same folder synced and marked available offline. The file shows up on both machines within seconds, at the same provider-relative location.

This is the only piece of infrastructure you need: one cloud-synced folder, available offline on every host. Stash respects whatever path you give it.

2. ⌘⌃P copies the full context string

This is the one hotkey that makes the whole workflow work. After any screenshot, press ⌘⌃P. Stash puts a string like this on your clipboard:

Screenshot from Safari | Window: "localhost:3000/checkout"
| http://localhost:3000/checkout | 2026-05-17 at 11.45
/Users/alex/Library/CloudStorage/Dropbox/Screenshots/Screenshot 2026-05-17 at 11.45.png

Source app. Window title. URL. Capture time. Full file path.

You paste that into your Hermes session. The agent reads the path. The path resolves on its host because the Dropbox folder is synced and available offline there too. The agent loads the image. It already knows the source app, the URL, and what was annotated — because all of that is in the same paste.

One hotkey. One paste. The agent sees everything.

3. The path stays stable across hosts

Stash captures the path at save time, from the host that took the screenshot. The MacBook records /Users/alex/Library/CloudStorage/Dropbox/…. That path is wrong on the Studio — the Studio uses /Users/hermesagent/… for its home directory.

This is where the agent's translation logic earns its keep. Hermes Agent's fleet skill documents the rule: when a path is referenced with one user's home, translate to the current host's home before reading. The cloud-folder-relative segment is the same on every host; only the user changes. The agent resolves it automatically.

So you don't think about translation. You don't run scp. You paste the string Stash gave you and move on.

A real Hermes workflow

Here's what an actual session looks like. I'm on my MacBook. Hermes Agent is running on studio-m3 via SSH. I want the agent to fix a UI bug.

  1. I take a screenshot on the MacBook with ⌘⌃S — Stash's region capture. I draw an arrow at the broken button.
  2. I press ⌘⌃P. Stash puts the context string on my clipboard.
  3. I paste into the Hermes terminal.
  4. The agent reads the path. The image is already on studio-m3's cloud-synced folder, fully materialized because the folder is set to available offline. No streaming, no waiting.
  5. The agent sees the source app (Safari), the URL (localhost:3000/checkout), and the annotation. It knows which file maps to that route in my codebase. It opens the right component. Its first response is the fix.

Three to five seconds from screenshot to agent-with-full-context. No path typing. No SCP. No "which file is this?" follow-up.

That's the loop. It works because Stash gave me the context the agent needed, the file system gave me the path that resolves on both machines, and Hermes Agent translated the home directory.

What this replaces

For anyone running AI agents on a separate Mac — and that's the right way to run autonomous coding agents — here's the comparison:

Workflow Time per screenshot Context the agent gets What you do
AirDrop file to Studio 8–12 seconds Pixels only Click target, click accept, type path
SCP over Tailscale 5–8 seconds Pixels only Switch terminal, run command, type path
pbcopy raw image data 2 seconds Pixels only, no path Loses metadata; agent has to ask
macOS native screenshot to cloud folder 4–6 seconds Pixels + path You type the path manually
Stash ⌘⌃P to cloud folder 2 seconds Image + app + window + URL + annotations + path Press one hotkey, paste once

The "macOS native to cloud folder" row is the closest competitor. It works — but you still have to find and type the path. And you lose the source app, window title, URL, and annotation summary that Stash captures automatically.

Once you do this a dozen times a day, the difference is the difference between AI agents being useful and AI agents being annoying.

Why this wasn't built anywhere else

Every other screenshot tool — CleanShot X, Shottr, Xnapper, the built-in macOS tools — assumes the screenshot stays on the machine that took it. Their workflows are "annotate, then drag into a chat app." That chat app is presumed to be on the same Mac. The path doesn't leave the machine.

That assumption is wrong for headless AI workflows. The whole point of running Hermes Agent on a Studio is that the Studio runs the agent, not the laptop. The capture has to leave the capture machine.

Stash got this right by accident. The ⌘⌃P hotkey was built so vibe coders could paste paths into Claude Code running in the terminal. The terminal is local. But the same string also works when the agent is remote, because the string is plain text and the path is real on both ends.

This isn't a feature anyone else competes on, because no one else is building for headless AI agents. CleanShot is built for marketing teams. Shottr is built for designers. Xnapper is built for podcasters and writers. Stash is built for the developer running an agent on a Mac Studio in a rack, controlling it from a laptop.

That's a small audience right now. It won't stay small.

Setup: what you need

To make this workflow real, three pieces:

  1. Stash on every Mac that takes screenshots. That's typically your laptop. Set the auto-save path to a Dropbox-synced folder and enable ⌘⌃P (Copy Path with Context) in Preferences.
  2. The same cloud-synced folder available offline on every Mac running an agent. This is the cross-host bridge. Any provider works — Dropbox, Google Drive, iCloud Drive, Box, OneDrive. The setting is in the provider's menu-bar app (Dropbox: Preferences → Sync → "Local"; Google Drive: "Available offline"; iCloud: "Keep Downloaded"; Box Drive: "Mark for offline access"; OneDrive: "Always keep on this device"). Files materialize fully to disk, with no streaming delay when the agent reads them.
  3. Hermes Agent on the agent host. With the hermes-fleet skill loaded, it handles the path translation automatically. If you're running a different agent framework, teach it the rule: when reading a path with /Users/<other-user>/, translate to $HOME/Library/CloudStorage/… on the current host.

That's it. No SSH file sync. No shared filesystem mount. No daemon. Just one cloud folder and one app that knows how to copy the right string.

Stash is a Mac screenshot and screen-recording tool built for AI agents — local, fast, and metadata-rich. Download Stash or learn more about the vibe coding workflow.