# Using palate

> Install it in your agent, then ask in your own words. Everything palate can do, every command, and what people ask.

palate is design intelligence for coding agents. It runs inside the agent you already use (Claude Code, Codex, Cursor or any MCP client) as an MCP server and a CLI, in your own codebase. Your agent gets a screen most of the way; palate does the last 20%: the research, the plan, the craft in every section, every state, and a check by judges who didn't build it. It learns your taste from your picks and corrections.

Updated 7 Nov 2026. The page: https://palate.sh/docs

## Install

Before you start: Node 22 or newer, Chrome or Edge (palate takes screenshots with it), your invite code (only to build; the checks are free).

### 1. Add palate to your agent

**Claude Code.** In a terminal:

```bash
claude mcp add palate -- npx @palate/cli mcp
```

**Codex.** Add to ~/.codex/config.toml:

```toml
[mcp_servers.palate]
command = "npx"
args = ["@palate/cli", "mcp"]
```

**Cursor.** Add to .cursor/mcp.json in your project, or ~/.cursor/mcp.json for every project:

```json
{
  "mcpServers": {
    "palate": { "command": "npx", "args": ["@palate/cli", "mcp"] }
  }
}
```

Any other agent that runs MCP servers: the command is `npx @palate/cli mcp`.

### 2. Activate it

Once per machine, with the code from your invite. A code works on up to three machines.

```bash
npx @palate/cli activate palate-XXXX-XXXX-XXXX
```

Check it with `npx @palate/cli activate --status`.

### 3. Try it

Ask your agent, in your own words: "make the pricing section". palate sizes the work first (a fix, a build, or research), says what it will cost in tokens, then guides your agent through it.

### Or let your agent do it

Paste this into your agent:

```text
Set up palate for me: read https://palate.sh/docs.md and follow the install steps for this agent. My invite code is palate-XXXX-XXXX-XXXX.
```

## What it can do

Ask in your own words. Each of these is an example of what to type and what happens next.

### Not done until it's checked

When your agent says it's finished, palate checks first. Free, no code needed.

Try: "add a testimonials row"

- Every changed screen looked at after its last edit; the copy, credits and gates checked
- Sent back with what's still open, three rounds at most, then it tells you
- In Claude Code, Codex, Cursor, Gemini CLI and Copilot, or a git check for any agent

Command: `palate guard --install`

### Fix or tweak

A small change, made in place and checked once. No loop.

Try: "the headings are three different sizes"

- Changed where it is, in your code
- One screenshot of the result, then palate check
- About 12k tokens

Command: `palate plan → direct`

### Build a page

One build, planned before code and finished to the last state.

Try: "build the pricing page"

- A blueprint first: the system, a look of its own, one archetype per section
- The hero and every section built, then every state and detail
- Judged by agents that didn't build it; about 137k tokens

Command: `palate build`

### Something new

For a new product or a new kind of screen: research before the build.

Try: "design a homepage for a bakery that takes weekend pre-orders"

- Competitors and well-crafted pages looked at live
- Three art directions; palate picks from your taste, or you do
- Then one build; about 174k tokens

Command: `palate research · palate direction`

### Match my design

Your screenshot, page or Figma frame is the spec, built faithfully.

Try: "build this from my screenshot"

- Every value tagged measured, guessed or swapped
- Your design and the build checked side by side
- A verdict: ready, ready with substitutions, or not yet

Command: `palate match`

### Point at what's wrong

Click anything in your running app and say what should change.

Try: "let me point at what's off"

- palate opens your app with its overlay
- Your agent fixes each pin while you keep going
- A before and after for every fix, at both widths

Command: `palate point`

### Options, when you ask

Several directions as sketches, only when you want to explore.

Try: "show me three takes on the hero"

- Sketches built in parallel
- You pick blind, side by side, in your browser
- The winner is built out in full

Command: `palate variants · palate pick`

### Critique

A designer's review of a page, section by section.

Try: "review this page like a designer"

- Findings on a board in your browser
- Agree or disagree with each one
- Agreed ones get fixed; the rest teach palate

Command: `palate critique · palate fix`

### Your references and rules

Tell it what you like and what you never want. It keeps both.

Try: "never use cream backgrounds"

- Kept as a rule, at the top of every brief
- Checked on every screenshot and by every judge
- Every pick, pin and correction can become a rule you keep, by type of screen

Command: `palate rule add · palate refs add · palate taste`

## Commands

Everything the MCP server does is also a command. The agent calls the MCP tool in brackets.

### Check, free

- `palate guard --install [--agent …]`: Your agent can't call UI work done until palate has looked at it. A stop hook for Claude Code, Codex, Cursor, Gemini CLI and Copilot; --agent git for any agent. (`palate_guard`)
- `palate guard`: What's still open: screens not looked at since their last edit, copy, credits, gates. (`palate_guard`)
- `palate copy [files…]`: Copy that reads as generated (hype, filler, placeholder text, proof with no source), with what to write instead. (`palate_copy`)
- `palate waive <id> --reason "…"`: A finding that's wrong for your project, with the reason. Every report lists it. (`palate_waive`)
- `palate imagery "<query>" [--sources commons]`: Photos you may use: CC0 museum images, or Commons photos under CC0, public domain or CC BY, credited. (`palate_imagery`)
- `palate icons <brand…>`: Real brand marks as local SVGs in their own colour, for a works-with row. (`palate_icons`)

### Start

- `palate activate <code>`: Activate palate on this machine with your invite code, once. (`palate_activate`)
- `palate activate --status`: Whether palate is activated here.
- `palate plan "<request>" [--route /x]`: What a request deserves (a fix, a build, research, options), why, and its token cost. (`palate_plan`)
- `palate context`: What the project already uses: stack, tokens, fonts, components, screens. (`palate_context`)
- `palate version`: The installed version.

### Build

- `palate build "<job>" --route /x`: One build of a real route from your rules, references and taste. (`palate_build`)
- `palate blueprint --file <plan.json>`: Check a new page's plan before any code: system, look, one archetype per section. (`palate_blueprint`)
- `palate research "<job>"`: Competitors and well-crafted pages, looked at live, for a new screen. (`palate_research`)
- `palate direction "<job>"`: Three art directions, or three ideas for a problem, before a build. (`palate_direction`)
- `palate match <image | url | figma link>`: Build your own design faithfully, then check it side by side. (`palate_match`)
- `palate variants "<job>" --name <n>`: Several directions as sketches, when you ask for options. (`palate_variants`)
- `palate pick --name <n>`: Pick the best variant blind, side by side, in your browser. (`palate_pick_start`)

### Finish

- `palate finish <route>`: Screenshots at both widths, every state, the small details and motion, in one pass. (`palate_finish`)
- `palate gate <route>`: The quality floor, judged by fresh agents that didn't build the page. (`palate_gate`)
- `palate shoot <route>`: Screenshots and measured problems: contrast, overflow, small text, repeats. (`palate_shoot`)
- `palate states <route>`: Empty, loading, error, long text, offline and keyboard states, rendered. (`palate_states`)
- `palate details <route>`: The small parts: avatars, inputs, icons, badges, hover and focus. (`palate_details`)
- `palate animate <route> --check`: Motion that serves the content, checked frame by frame. (`palate_animate`)
- `palate critique <route>`: A designer's review, section by section. (`palate_critique`)
- `palate fix <route>`: A brief from the findings you agreed with, most severe first. (`palate_fix`)
- `palate check`: Generated-UI tells and token drift in your changed code. (`palate_check`)

### Point

- `palate point [route]`: Open your running app with palate's overlay; click what's wrong and say why. (`palate_point_start`)
- `palate point [route] --auto`: The same, and palate runs your agent headless on each pin.

### Your taste

- `palate refs add <image | url> --like "…"`: Save a reference with what you like and dislike about it. (`palate_refs_add`)
- `palate rule add "<rule>"`: A rule in your words, active at once and checked on every build. (`palate_rule`)
- `palate rule review`: Keep or discard the rules palate proposed from your picks and fixes. (`palate_rule`)
- `palate taste [learn]`: Your taste profile, by type of screen; learn proposes new rules. (`palate_taste`)
- `palate fail <route> "<why>"`: Mark a screen as bad and why; palate proposes rules from it. (`palate_fail`)
- `palate forget <project>`: Drop a throwaway project from palate's history; taste is untouched.
- `palate stats`: Time and tokens per mode, from your own runs. (`palate_stats`)

### Run as a server

- `palate mcp`: Run palate as an MCP server (stdio) for Claude Code, Codex, Cursor and other MCP clients.

In Claude Code you can also use the slash prompts `/mcp__palate__design`, `/mcp__palate__direction`, `/mcp__palate__point`, `/mcp__palate__explore`.

## Questions

### What's free, and what needs an invite?

Checking and finishing screens you already have is free with no code: the guard, the copy check, screenshots and every state, the quality gate, photos and brand icons. Building from your taste, research and directions, options, pointing at what's wrong, critique and the rules palate learns need an invite. What palate learns while you use the free part is there when you activate.

### Does my code or design leave my machine?

No. Screenshots, references, picks and your taste profile stay on your machine. The only network call is activation and an occasional licence check, which send your invite code and an anonymous machine id.

### Which agents does it work with?

Any agent that runs MCP servers: Claude Code, Codex and Cursor are set up above. The guard hooks into Claude Code, Codex, Cursor, Gemini CLI and Copilot; for any other agent, a git pre-commit check does the same job. Everything the server does is also a command, so the CLI works on its own.

### How many tokens does it use?

palate tells you before it starts. A fix is about 12k tokens, a page build about 137k, research and a build about 174k. Options are opt-in because they cost more.

### Does it work with my stack and components?

Yes. It reads your project first (its stack, tokens, fonts and components) and builds in your codebase with them. It starts your own dev server: Next.js, Vite, Astro, Nuxt, Remix and React Router, Angular, SvelteKit and Create React App.

### How many machines can I use it on?

Up to three per invite code. Activate once on each; palate re-checks the code now and then and keeps working offline for a while if it can't reach us.

### Something broke, or I have an idea?

Reply to your invite email, or write to Garvit through garvit.me. Bugs with the command you ran and what you saw get fixed fastest.