Stash: A Private Clipboard Manager for Mac Developers

Stash is a native, private clipboard manager for Mac developers who work with coding agents. It keeps a searchable history of the prompts, code, terminal output, images and files you copy, finds words inside screenshots with on-device OCR, and helps you move a deliberate sequence of context into a compatible agent editor.

I built it for the context-gathering loop that surrounds agentic development: recover an instruction you used earlier, collect a task description and error output, add the relevant code or file, mark up a screenshot, then return to the agent without losing your place.

One-time purchase — currently $3.99 · No subscription · No account · No cloud upload

Get Stash on the Mac App Store →

Move context into coding agents without losing your place.

Reuse prompts and instructions. Search local clipboard history for a previous prompt, constraint, command or code snippet, then copy or drag it into the agent conversation.

Assemble context in a useful order. Queue Mode can remember a task brief, logs, code and images so you can insert them one by one into a compatible editor without switching back to every source.

Search inside screenshots. Apple Vision recognizes text in copied images on-device, making UI labels, errors and other visual context searchable alongside text clips.

Show the agent exactly what matters. Add arrows, shapes, text or freehand marks to a copied image and place the finished version directly back on the clipboard.

Keep sensitive content under your control. Pause monitoring, exclude selected apps and choose how much history and image data Stash retains.

Why I built a clipboard manager for agentic development

The Mac clipboard is part of almost every interaction I have with a coding agent, but the useful context passing through it is temporary by default. A requirement comes from an issue, a command from the terminal, an error from Xcode, a code fragment from the repository and a screenshot from the running app. Each piece may be useful to the agent, but every new copy replaces the one immediately available.

My first recurring problem was prompt reuse. I often return to the same instructions, constraints and variations throughout a project. The larger problem was context assembly: finding those instructions again, collecting the evidence for the current task and feeding it to the agent without repeatedly navigating among an issue tracker, editor, terminal, browser and running application.

A basic chronological history helped, but I wanted labels for durable prompts, search that included screenshots, support for text, images and files, and a fast way to prepare an ordered batch of context.

That became Stash: a menu-bar utility that stays out of the Dock, opens over the current workspace with a keyboard shortcut and remains close to familiar Mac copy-and-paste behavior.

Stash is the local context layer between your development tools and your coding agent.

Search your Mac clipboard history

Stash stores supported text, images and file references in a local history. Press Command-Option-O to open the overlay and begin typing; results update as you search, while content filters narrow the view to text, images or files.

Each result keeps practical context such as its source application, relative date, image thumbnail or file icon. Pin an item when it should survive normal retention limits, or give it a short custom label so recurring material remains recognizable. Labels are searchable and can also be used as a focused filter.

This makes Stash useful as more than a recovery tool. A prompts label can become a lightweight library for instructions you regularly send to coding agents. Project labels can separate recurring context, a pinned deployment command remains easy to reach, and an image copied from a design review can be found by the words visible inside it.

The overlay is designed for the keyboard:

• Use the arrow keys to move through results.
• Press Return to copy the selected item and close Stash.
• Press Option-Return to copy it while keeping Stash open.
• Double-click an item to copy it.
• Drag text, an image or a file directly into a compatible app.

Build a context packet for a coding agent

A useful agent request often needs more than one paste. You may want to provide:

• The task or acceptance criteria
• A reusable project instruction
• The relevant code or configuration
• A compiler error, stack trace or failing test output
• A file reference
• A screenshot of the current interface
• An annotated image showing the exact problem

Stash keeps those pieces available while you investigate. Search retrieves context copied earlier, labels keep recurring instructions recognizable, pins protect durable material from normal retention cleanup, and Option-Return lets you copy successive items without repeatedly closing and reopening the overlay.

When you already know the order, Queue Mode can turn those pieces into a small context packet. Record the task first, then the evidence and visual reference; insert each item into a coding-agent editor that supports macOS Services. If a custom editor does not support the Service, the same material remains available through search, keyboard copy and drag and drop.

Copy several items and paste them in order with Queue Mode

Clipboard history solves retrieval. Queue Mode solves a different problem: moving a known sequence of values from one place to another.

Imagine preparing an agent handoff with a task description, an error message, a code fragment and an annotated screenshot. Normally, you either switch back after every paste or repeatedly reopen clipboard history to choose the next piece of context.

With Stash, press Control-Option-Q to start recording and copy the items in the order you need them. When the queue is ready, invoke Paste Next from Stash—bundled with Control-Option-S as its default shortcut—to insert the next item. Stash keeps the remaining count visible and supports queues containing both text and images.

The same workflow can transfer a debugging narrative, a code-review checklist, a structured implementation brief or any other sequence where the order is already known. It also remains useful outside development for form filling, product listings and support replies.

How Queue Mode works without Accessibility permission

I did not want a clipboard utility to inspect other applications or synthesize keystrokes simply to paste the next item. Queue Mode therefore uses an output-only macOS Service rather than Accessibility APIs.

When Paste Next from Stash is invoked, the focused destination asks the Service for the next queued value. Stash prepares a compatible text or image representation, returns it through the Service pasteboard and advances the first-in, first-out queue after the transfer is prepared successfully.

This design keeps the destination in control and means Stash does not request Accessibility, Input Monitoring, Automation or Apple Events permission. It also creates an honest compatibility boundary: standard Mac text controls and rich editors are the primary target, while some custom controls may not expose macOS Services or accept every representation.

The Service shortcut belongs to macOS, so it can be changed under System Settings → Keyboard → Keyboard Shortcuts → Services.

Find text inside screenshots with on-device OCR

A screenshot often contains exactly the information an agent needs later—a runtime error, failing visual state, configuration panel or line of interface copy—but none of it has a useful filename.

Stash runs Apple Vision text recognition on copied images and adds the recognized words to its local full-text search index. Searching clipboard history can therefore find text that only ever appeared as pixels.

For a fast screenshot-to-clipboard workflow, press Control-Command-Shift-4 and select an area. The Control key tells macOS to copy the capture instead of saving it as a file; Stash then handles it like any other copied image. Stash does not capture the screen itself and does not request Screen Recording permission.

OCR and image classification run on-device. The screenshot, recognized text and generated labels remain on the Mac.

Annotate an image and copy it straight back

Sometimes finding the screenshot is only the beginning. You still need to point at the broken control, circle a number or add a short instruction before sharing it.

Stash includes an image editor with arrows, rectangles, ellipses, lines, text and freehand drawing. Press Command-Option-I to open the most recent copied image, add the necessary context and save. The completed image goes directly back to the clipboard, ready for Mail, Messages, documentation or an agent conversation without an intermediate export-and-reimport step.

This is particularly useful for agentic frontend work: capture a visual bug, mark the exact region, add a concise note and paste the annotated result beside the written request. The image carries the visual evidence while your text explains the expected behavior.

A private clipboard manager with a small permission footprint

Clipboard history used for development may contain proprietary source code, unreleased product details, credentials accidentally copied from a tool, customer information and private prompts, so local storage is only the starting point.

Stash keeps its database, search index and copied image files on the Mac. It does not upload clipboard content or require an account, and its core workflow remains available offline. The Mac App Store build is sandboxed.

You can also control what enters history:

• Pause monitoring for five minutes or indefinitely.
• Exclude any application from future capture.
• Start with a curated set of password managers already excluded.
• Ignore clipboard items marked concealed or transient by their source app.
• Choose limits for retained history and image storage.
• Pin selected items so normal retention cleanup does not remove them.
• Clear unpinned history whenever you choose.

Stash requests no Screen Recording, Accessibility, Input Monitoring, Automation or Apple Events permission. Global shortcuts use native Mac hotkey APIs, copied screenshots arrive through the system clipboard and Queue Mode inserts through macOS Services.

When is Stash the right clipboard manager?

Stash is built first for developers who spend a meaningful part of the day working with coding agents. Its strongest workflows are:

• Reusing prompts, project instructions, commands and code snippets
• Gathering task details, logs, files and visual evidence for an agent
• Searching a mixed history of text, images and file references
• Finding an error or UI state by the words inside a screenshot
• Moving an ordered batch of context into a compatible agent editor
• Annotating a visual bug and immediately pasting the result
• Keeping clipboard history local without an account or subscription
• Avoiding broad Accessibility and Screen Recording permissions

Writers, support teams and other people who move substantial context between Mac apps can use the same features, but they are no longer the center of the product story. A simpler tool may be enough if you only need to recover an occasional line of text. Stash is also intentionally not a cloud clipboard: if cross-device history synchronization is essential, or if you need exact rich-text formatting preservation, a different workflow will be a better fit.

How to use Stash with a coding agent

1. Download Stash from the Mac App Store. It requires macOS 15 or later.
2. Review the privacy defaults and optionally enable Launch at Login.
3. Copy prompts, code, terminal output, images and files normally while Stash builds local history in the background.
4. Label recurring project instructions and pin context that should survive normal history cleanup.
5. Press Command-Option-O to search, filter, copy or drag an earlier item into the agent conversation.
6. Use Control-Option-Q when you want to record an ordered context packet for Queue Mode.
7. Use Command-Option-I when a screenshot needs annotation before you share it with the agent.

Application shortcuts can be changed in Stash Settings. Because Paste Next from Stash is a macOS Service, its shortcut is managed separately in System Settings.

Current requirements and limitations

• Stash requires macOS 15 or later.
• Clipboard history is local to the Mac; Stash does not provide its own cloud sync.
• Rich-text-only clipboard content is stored and restored as plain text; exact rich-text fidelity is not currently promised.
• Stash does not take screenshots itself. Use the native screenshot-to-clipboard shortcut or copy an existing image.
• Queue insertion depends on the destination supporting macOS Services and a compatible text or image representation. Some custom controls may not.
• Application exclusions affect future copies and do not delete items already stored in history.

These boundaries are deliberate. Stash focuses on a predictable, private Mac workflow rather than claiming to intercept or synchronize every clipboard action everywhere.