References · Styles · Local MCP

UI references your agents can actually use.

Save interfaces as living code. Keep each project's real tokens, references, and components in a Style. Connect uistash once, then any agent can add, search, or pull the right design context.

Living UI references and real project styles, ready for every agent you use.

Join early access See project Styles
Project Styles

Your project’s design language. Always in context.

Brand tokens, references, and Kept components travel together in a Style, so every agent starts from the system your project already uses.

How a reference is born

01 Drop

Drop a screenshot anywhere.

Images and GIFs land from your desktop — the drop overlay catches them globally, not in a single zone.

02 Stage

Pick an engine. Mark what mattered.

Claude Code, Codex, Cursor — or your own API keys. Survey chips for motion, color, type, layout. Start when you're ready.

03 Build

Watch it become code.

A build rail lights up as real files land — tokens first, then components, assembly, proof. And proof means measured: the rebuild is compared against your original, region by region, and refined until it holds. A camera and a ruler — never an AI grading its own homework.

04 Live

It joins your stash as living code.

Real renders, inspectable tokens, working interactions — machine-readable for the agents you already use.

The gap

A picture guesses. Code knows.

Feed the same screenshot to an agent twice and you get two different interpretations — because the specifics were never in the file. This is what your reference actually carries, before and after uistash:

Same screenshot, two builds, two guesses. Here's what the file actually carries:

your-reference.png
  • some kind of bluewhich one?
  • roundish corners8px? 14px? 20px?
  • a soft shadowalpha? layers?
  • probably animatescurve? duration?
  • looks clickablehover? active? empty?
every build: a new guess
your-reference/ · tokens.css · DESIGN.md · index.html
  • --accent: #0048ff; /* CTA + selection only */
  • --radius-card: 18px; /* pills 999 · frames 28 */
  • --shadow: 0 8px 24px rgb(0 0 0 / .10);
  • cubic-bezier(.25, 1, .5, 1) · 240ms · 90ms stagger
  • states: hover · active · drag · empty /* working */
every build: the same truth

Coded Reference Library · Stash

A gallery that's alive.

Every entry is running HTML — live-rendered cards with token strips and a green dot when the interactions actually work. Search by title, tags, fonts — or flip vibe search and rank by feel.

Live HTML cards — tokens, interactions, search by feel.

Inspector
Tags, color tokens, fonts, accent rules, interactions, and an inline DESIGN.md — fetched from the reference itself.
Preview modes
Inspect resolves measurements to the reference's own tokens. Motion scrubs real animations like a DVR. Comment anchors taste notes to elements. Full version history on every entry.
Folders, tags, and projects
Organize with folders and tags, then assign the references that belong to a Project Style. It all stays as files in a local git repo; delete moves to the Trash, never to oblivion.

Project Styles

Your project's design language, ready in every tool.

Extract real tokens and components from a repo into a Project Style. Add the references that belong to it, Keep only the components you approve, then tell any agent: “Use the Meridian style from my uistash.”

Tokens, references, and approved components from a real project — one Style every agent can pull.

‹ Styles Meridian Project style · 8 references · 6 components
Declared · tokens.css
Aa
Inter500 · 600 · 700
--ink --canvas --action --signal
481624

get_style style="meridian" returns this system, its references, and its Kept component vocabulary.

RepoSubmitReviewKeepAgents

Agents · Local MCP

Connect once. Carry context everywhere.

Your agents can add to the library, search it, and pull a complete Project Style without another screenshot handoff. HTTP and stdio both run locally.

cursor · composer MCP · uistash · connected
› Message agent…
“Add this reference to uistash”
From any agent session, a URL or screenshot can become a coded specimen in the right folder or Style.
“Use the Meridian style from my uistash”
The agent gets the project's declared tokens, member references, and only the components you explicitly Kept.
Pay the extraction once
You stop pasting screenshots into every session. The image is analyzed once, at import — after that your agents read compact text: tokens, rules, rationale. No re-uploading, no re-interpreting, no vision tokens burned on the same picture for the hundredth time. A reference gets cheaper the more you use it.
Analyze once at import. After that agents read tokens and rules — not the same image again.
Read and write, by name
add_reference, search_references, get_style, and get_component. No proprietary prompt ritual.

Local by design

Your design context stays yours.

The Reference Library, Project Styles, agent keys, and version history live as ordinary files on your Mac. uistash is a local bridge between the tools you choose, not another cloud your work disappears into.

Files, not a silo
References and Styles live in a local git repo you can inspect, version, back up, and own.
Your engines, your keys
Use the agent CLIs and direct API keys you already have. Keys stay local and go only to the provider you picked.
Approval is explicit
Agent-submitted components stay in Review. They do not become reusable project truth until you press Keep.

Experimental extras

The practical product came from a personal experiment.

Taste and Lab remain inside uistash as research tools. They are useful, inspectable, and clearly separate from the core promise.

Experimental · Taste

A mirror, not a horoscope.

What you keep distills into tastestack.md: claims about your eye with confidence and citations to the references that earned them.

The model is frozen; the file learns.
Experimental · Lab

Measure before you believe.

Run sealed blind studies with and without your taste, pick before labels reveal, and keep human evidence separate from the machine judge.

See how the Lab works →

Why uistash

Design context should survive the tool.

A reference should not turn back into a vague screenshot every time you switch agents. A project's design system should not depend on one chat remembering yesterday. uistash makes both durable: living references for inspiration, and Project Styles for the work that must stay consistent.

I built the first version to study my own taste. The practical thing that fell out was more useful: a local design-context layer I now use every day. The research rooms are still there, but the product is the library and the Styles.

References and project design systems should survive the tool. uistash keeps both ready for the next agent.

· Before you ask

Straight answers.

What will access include?
The full Mac app: coded References, Imports, Project Styles, local MCP, plus experimental Taste and Lab. $79, one-time when access opens. No subscription or tiers.
Will it be updated?
Yes. Ongoing updates are included, but this page sells what already works: the Reference Library, Styles, and MCP. It does not sell a roadmap.
Do I need my own AI?
Yes — uistash drives the agent CLIs and API keys you already have (Claude Code, Codex, Cursor, or direct keys). It never resells AI, marks up tokens, or proxies your accounts. Your keys stay on your machine, and every model-touching action shows its cost before it runs.
Where does my data live?
On your Mac: folders, files, and a local git repo. References, Styles, taste data, and keys do not leave except by your explicit act.
What is uistash not?
Not cloud storage. Not a subscription. Not a screenshot organizer. Not another AI model. It is the local reference and project-style layer between you and the agents you already use.

Access

Join early access.

$79 one-time when access opens. Mac app. No subscription.

$79 when access opens

  • Mac app
  • 3 machines
  • 14-day refund

Works with the agent CLIs and API keys you already have. Questions → hello@uistash.ai

Included

  • Coded Reference Library + Imports
  • Project Styles — tokens, references, components
  • Local MCP read and write
  • Experimental Taste + Lab
  • Lifetime license
  • Ongoing updates
  • Everything local on your Mac

Not included

  • Subscription
  • Cloud storage of your library
  • Roadmap promises
  • AI tokens — you use your own keys