Show the agent
what you see.

It fires once on the rising edge, the moment both keys are down, and then disarms until you physically break the chord. Hold the keys and nothing repeats. That single rule is what keeps a gesture built from keys you also type with from machine-gunning twenty screenshots into a prompt. Continuum also ignores the chord when it is already frontmost, because the gesture exists to capture other apps.

The hotkey is off until you turn it on. Enabling it installs a keyboard event tap, which macOS gates behind Accessibility, so the toggle only arms once you have opted in and granted the permission. Turn either one off and the tap comes straight back down. Nothing is watching your keyboard on a fresh install.

One capture runs at a time. A second chord during the hand-off is dropped rather than queued, so a nervous double press cannot land two half-finished shots. If there is no capturable window in front, you get a plain “no window to capture” instead of a black rectangle in your prompt.

The result is written as a PNG into a staging folder and attached from there, so what the agent receives is a real file, not a lossy paste. Removing the chip cleans the staging directory up behind you. This is the difference between showing a model a rendering bug and typing a paragraph about one, and it is the same instinct as giving an agent the context it actually needs rather than more prose. An editor-bound assistant like Cursor can read every file in the repo and still never see the window your app is rendering in.

macOS only shows its own Screen Recording prompt once. If you said no months ago, asking again does nothing at all, which is exactly how permission flows end up lying to people. The wizard handles that case: after your first attempt it escalates to a direct deep link into Privacy & Security → Screen Recording rather than pretending the button will work on the next press.

There is a relaunch escape hatch too, because a freshly granted Screen Recording permission sometimes only takes effect for the capture API after a restart. And the last step is a real Test capture: it runs the full path and shows you the resulting image. You leave Settings knowing it works, not hoping it does. Permission theatre is a large share of why a working setup suddenly stops working, so it is worth over-building.

04 · Into the composer

Continuum comes forward. The shot is already attached.

After capture, Continuum teleports to the front and drops the shot into the active Code composer as an attachment chip - thumbnail, window title, ready to send. Type a line of context, hit send. The agent sees the same pixels you saw.

App Shots sit next to paste, drag-drop, and the paperclip. Use whichever is fastest for the moment. Shots stage the same way as other attachments - size cap, preview, remove chip.

The window flies from where it was into the composer, so you can see which frame you grabbed without reading a filename. Under Reduce Motion the shot is simply delivered, with no animation at all.

Code workbench Dictate the caption

CodeUsage

São Paulo

São Paulo · cursorworktree · sp-1

here's the crash from the preview build

Xcode · Crash Report app shot · 1.8 MB

✕

repro: open Code → expand defx-frontend → crash on first paint. stack in the shot.

paperclip app shot mic

~$0.08 · ready to sendsame attachment path

If no session is open, the capture lands on the Code tab’s empty-state composer, which is a session waiting to be born. Pick the repo, add the sentence, send, and the shot is the first thing the agent sees. A visual bug reported as “the sidebar looks wrong on first paint” costs a turn of clarification; the same bug with the frame attached usually does not. Running the CLI on its own gets you there eventually, once you have saved a file somewhere and typed its path.

Captions matter more than people expect. The screenshot says what is broken; you still have to say what you want. Pair it with a dictated line from Voice and the whole report takes about four seconds. When the agent comes back with a patch, the reviewing-generated-code habits that apply everywhere else apply here too - an image is evidence, not a spec.

The Windows and Linux desktop app takes the same idea through a deliberately narrower door. Its capture request is only accepted from Continuum’s own trusted app origin, only when a Continuum window is focused, and every single shot puts up a native confirmation dialog naming the window it is about to share. Approving grants exactly one capture; the next one asks again. It is slower than the Mac chord on purpose, because an Electron renderer is a wider attack surface than a signed native app and a silent screenshot API inside one is not a trade worth making.

iOS has no equivalent. There is no system gesture that hands one app another app’s window, so the phone uses the ordinary paperclip, the share sheet, and paste. That is the same class of platform boundary as what an agent is allowed to touch on your machine: honest limits beat a feature that only works in the screenshot on a marketing page.