Installation and setup

Let your coding agent install the kit: you log in once, then paste one prompt. The manual setup and the full reference follow below; every manual command was run end to end against the real registry, CLI, skills and MCP server.

Install with your coding agent

Two steps. You store your license key once in your own terminal; your agent does the rest with one prompt, in the Next.js project you want to build in.

1. In your own terminal, once
Unzip the kit to your home folder, so it lives in ~/agentic-ui-kit, then log in. login asks for the license key from your purchase without echo, checks it with the registry and stores it in your user config (~/.config/agentic-ui/credentials.json). Do this yourself: agents run commands without a terminal, and your key never goes into an agent chat.
Your terminal
```
unzip ~/Downloads/agentic-ui-kit-*.zip -d ~
node ~/agentic-ui-kit/bin/agentic-ui.mjs login
```

2. Paste one prompt into your agent

Open your agent in your Next.js project and paste this. It runs setup and the MCP check, tells you the one reload or trust step your agent needs, loads the project context and builds a screen from the catalog. Change the last line to the screen you want.

Prompt for any coding agent

Install Agentic UI Kit in this Next.js project, then build one screen with it.

1. Run: node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client detect
   If you are one of these agents, pass your own id instead of detect: claude-code, codex, cursor, vscode, gemini, kimi, opencode, amp, devin, antigravity, junie, zed, cline.
   If setup says the license key is missing, stop and ask me to run node ~/agentic-ui-kit/bin/agentic-ui.mjs login in my own terminal. Never ask me for the license key in this chat and never put it on a command line.
2. Run: node ~/agentic-ui-kit/bin/agentic-ui.mjs mcp check
3. Tell me the "next:" step that setup printed for you (approve, trust, reload or restart) so the agentic-ui MCP server loads.
4. Call the MCP tool understand_project. If the agentic-ui MCP tools are not loaded yet, run node .agents/skills/agentic-ui-extend/scripts/context.mjs --cwd . --json instead (in Claude Code the skills are in .claude/skills).
5. Build the screen below. Reuse the catalog first: call find_reusable_ui (or run node .agents/skills/agentic-ui-extend/scripts/find-reusable.mjs --intent "<what you need>" --cwd . --json), install what fits with node ~/agentic-ui-kit/bin/agentic-ui.mjs add <component>, and write only the glue code.
6. Run the project build (for example pnpm build) and fix every error.

Screen: a billing page with plan usage and invoices (replace with the screen you want).

Per agent: client id and what differs

Claude Code and Codex are verified end to end in our recorded runs; Kimi Code ran the CLI and skills. The others are configured from each agent's official docs. Step-by-step guides: Claude Code, Cursor, Codex; the tools are on MCP server.

Client id: --client claude-code
Status: Verified end to end in our recorded runs
Where to paste the prompt: The CLI (run claude in the project folder), the desktop app or the IDE extension, opened on your project.
Log in: You can run login from the Claude Code prompt with a leading !, which runs it in your shell: ! node ~/agentic-ui-kit/bin/agentic-ui.mjs login
MCP config setup writes: .mcp.json
After setup: Approve the project server agentic-ui when asked, then run /mcp (or /mcp reconnect all).
Notes: Claude Code reads CLAUDE.md. If the project has one, setup adds an @AGENTS.md line to it so the kit's AGENTS.md block is read too.
Skills: .claude/skills.

Setup line for Claude Code (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client claude-code

Client id: --client codex
Status: Verified end to end in our recorded runs
Where to paste the prompt: The Codex CLI, IDE extension or app, opened on your project.
MCP config setup writes: .codex/config.toml
After setup: Trust this project and restart Codex (CLI, IDE or app) so it reads .codex/config.toml.
Notes: The sandbox blocks network by default, and setup and agentic-ui add download from the registry. Start Codex with -c sandbox_workspace_write.network_access=true, or approve those commands when Codex asks.
Codex reads AGENTS.md and the skills in .agents/skills.

Setup line for Codex (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client codex

Start Codex with network access

codex -c sandbox_workspace_write.network_access=true

Client id: --client kimi
Status: Recorded run: CLI and skills
Where to paste the prompt: kimi in the project folder.
MCP config setup writes: .kimi-code/mcp.json
After setup: Accept the trust prompt for this project and restart kimi.
Notes: Kimi Code reads AGENTS.md and the skills in .agents/skills.
On Windows, Kimi Code needs Git Bash.

Setup line for Kimi Code (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client kimi

Client id: --client cursor
Status: Configured from the agent's official docs
Where to paste the prompt: The Cursor editor (Agent) or the Cursor CLI, opened on your project.
MCP config setup writes: .cursor/mcp.json
After setup: Settings > MCP: enable agentic-ui. In the Cursor CLI: agent mcp enable agentic-ui, or start it with --approve-mcps.
Notes: Cursor reads AGENTS.md and the skills in .agents/skills and .claude/skills.

Setup line for Cursor (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client cursor

Client id: --client vscode
Status: Configured from the agent's official docs
Where to paste the prompt: VS Code with GitHub Copilot in agent mode, opened on your project.
MCP config setup writes: .vscode/mcp.json
After setup: Accept the trust dialog for the server (or open .vscode/mcp.json and click Start), then use agent mode.
Notes: Copilot reads .github/copilot-instructions.md, and AGENTS.md when that VS Code setting is on.
Skills: .claude/skills and .agents/skills.

Setup line for VS Code + Copilot (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client vscode

Client id: --client gemini
Status: Configured from the agent's official docs
Where to paste the prompt: gemini in the project folder.
MCP config setup writes: .gemini/settings.json
After setup: Trust this folder, then restart gemini and check with /mcp.
Notes: Gemini CLI reads GEMINI.md by default. Setup also lists AGENTS.md in context.fileName in .gemini/settings.json, so the kit's AGENTS.md block is read.
Skills: .agents/skills.

Setup line for Gemini CLI (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client gemini

Client id: --client opencode
Status: Configured from the agent's official docs
Where to paste the prompt: opencode in the project folder.
MCP config setup writes: opencode.json
After setup: Restart opencode.
Notes: opencode reads AGENTS.md and the skills in .claude/skills and .agents/skills.

Setup line for opencode (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client opencode

Client id: --client amp
Status: Configured from the agent's official docs
Where to paste the prompt: amp in the project folder.
MCP config setup writes: .amp/settings.json
After setup: Run amp mcp approve agentic-ui, then restart amp.
Notes: Amp reads AGENTS.md and the skills in .agents/skills and .claude/skills.

Setup line for Amp (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client amp

Approve the server (your terminal)

amp mcp approve agentic-ui

Client id: --client devin
Status: Configured from the agent's official docs
Where to paste the prompt: Devin Desktop (formerly Windsurf), opened on your project.
MCP config setup writes: .devin/mcp_config.local.json
After setup: Refresh the MCP servers in the MCP panel, or restart the app.
Notes: Setup writes the local, gitignored variant of the MCP file.
Devin Desktop reads AGENTS.md and the skills in .agents/skills and .claude/skills.

Setup line for Devin Desktop (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client devin

Client id: --client antigravity
Status: Configured from the agent's official docs
Where to paste the prompt: Antigravity, opened on your project.
MCP config setup writes: .agents/mcp_config.json
After setup: Open the MCP manager (/mcp) and refresh the servers.
Notes: Antigravity reads AGENTS.md and the skills in .agents/skills.

Setup line for Google Antigravity (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client antigravity

Client id: --client junie
Status: Configured from the agent's official docs
Where to paste the prompt: Junie in your JetBrains IDE, opened on your project.
MCP config setup writes: .junie/mcp/mcp.json
After setup: Trust the project, then reload the MCP servers in the Junie settings.
Notes: Junie reads .junie/AGENTS.md when it exists and the root AGENTS.md otherwise: if you keep a .junie/AGENTS.md, copy the kit's block into it.
Skills: .agents/skills.

Setup line for JetBrains Junie (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client junie

Client id: --client zed
Status: Configured from the agent's official docs
Where to paste the prompt: The Zed Agent panel, with your project open.
MCP config setup writes: .zed/settings.json
After setup: Trust this worktree, then check the server status in the Agent panel.
Notes: Zed reads the first rules file it finds (.rules, .cursorrules, … AGENTS.md, CLAUDE.md, GEMINI.md).
Skills: .agents/skills.

Setup line for Zed (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client zed

Client id: --client claude-desktop
Status: Configured from the agent's official docs
Where to paste the prompt: Claude Desktop is a chat app: it cannot run setup in your project. Run setup yourself in your project folder with the client id below.
MCP config setup writes: Nothing in the project: the config is user-level
After setup: Paste the block setup prints into the file it names (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Windows: %APPDATA%\Claude\claude_desktop_config.json), then fully quit and relaunch the app.
Notes: Its MCP config is user-level only, so the CLI prints the file path and the exact JSON block instead of writing it.

In your project folder (your terminal)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --validate --client claude-desktop

Shape of the printed block (paste the exact one setup prints)

{
  "mcpServers": {
    "agentic-ui": {
      "command": "<absolute path to node>",
      "args": ["<kit server path>", "--project", "<your project path>"],
      "env": { "…": "…" }
    }
  }
}

Client id: --client cline
Status: Configured from the agent's official docs
Where to paste the prompt: Cline, opened on your project.
MCP config setup writes: Nothing in the project: the config is user-level
After setup: Paste the block setup prints into the file it names (~/.cline/data/settings/cline_mcp_settings.json, or the VS Code extension's settings file), then open the MCP Servers panel: the server appears after the file is saved.
Notes: Its MCP config is user-level only, so the CLI prints the file path and the exact JSON block instead of writing it.
Cline reads AGENTS.md and the skills in .claude/skills.

Setup line for Cline (the prompt's step 1 with its id)

node ~/agentic-ui-kit/bin/agentic-ui.mjs setup --yes --validate --client cline

Shape of the printed block (paste the exact one setup prints)

{
  "mcpServers": {
    "agentic-ui": {
      "command": "<absolute path to node>",
      "args": ["<kit server path>", "--project", "<your project path>"],
      "env": { "…": "…" }
    }
  }
}

Without an agent, or to see what it runs

Manual setup and reference

Pick what you want to do. Each path lists only the steps it needs.

Install a componentagentic-ui add <component>
Start from a template or blueprintnpx shadcn@4.17.0 add @agentic-ui/<blueprint>
Configure a coding agentagentic-ui setup --client detect
Configure MCPagentic-ui mcp check
Use agent skillsagentic-ui setup
Export or import a themeagentic-ui theme apply <aui1_code>

Prerequisites

Needed for every path below.

Node.js: 22 or newer
Package manager: pnpm (the kit tools install with pnpm; your project can use its own package manager for the build)
Framework: Next.js with the App Router and Tailwind CSS 4, following shadcn conventions
Variant: Radix UI (registry variant new-york) or Base UI (registry variant base-vega). Choose the primitives library your project already uses. Both look the same: your theme, not the variant, controls colors, shape, type and motion.
Access: The kit download and your license key, both in your purchase email and customer portal. The CLI uses the registry at https://registry.agentic-ui-kit.com; pass --registry-url only for a registry you host yourself.
Network: Setup (package installs, shadcn init) and installing components need the network; the MCP server and skills run offline

Kit location

Point one variable at the folder where you unzipped the kit. Your license key is stored once by agentic-ui login (or asked by agentic-ui setup), never exported.

Shell (bash or zsh)

export AGENTIC_UI_KIT="$HOME/agentic-ui-kit"
agentic-ui() { node "$AGENTIC_UI_KIT/bin/agentic-ui.mjs" "$@"; }

AGENTIC_UI_KIT: Folder where you unzipped the kit. Only needed for the shell function below and the MCP launcher; login (or setup) stores your license key in your user config.

Set up the kit (once per machine)

Unzip the download, make the agentic-ui command available and store your license key.

1. Unzip the kit and check it runs
Unzip the download, for example to ~/agentic-ui-kit. Node.js 22+ and pnpm 10+ are required. Nothing else is installed by hand: setup installs the kit tools for you. Instead of the shell function, you can put the kit bin folder on your PATH or call node ~/agentic-ui-kit/bin/agentic-ui.mjs directly.
Anywhere
```
agentic-ui --version
```
Verified: exit code 0.
2. Store your license key Optional
Asks for the key without echo, checks it with the registry and stores it in ~/.config/agentic-ui/credentials.json (mode 0600). Needed before a coding agent runs setup; without it, setup asks for the key itself.
Anywhere
```
agentic-ui login
```

Add a component to an existing project

For a Next.js project you already have. The CLI protects your business logic and existing tokens.

1. Connect your Next.js project (one command)
Run it in the root of your Next.js project. It uses the license key stored by agentic-ui login, or asks for it without echo, and keeps it in ~/.config/agentic-ui/credentials.json (never in the project). The registry defaults to https://registry.agentic-ui-kit.com. Then it installs the kit tools, runs shadcn init, profiles the project (ui-kit.config.yaml, Design DNA, AGENTS.md block), registers the MCP server agentic-ui for your coding agents (--client, default detect) and installs the four agent skills in .claude/skills and .agents/skills. Add --style base-vega for Base UI and --validate to confirm the key with one request. It is safe to run again.
In your project folder
```
agentic-ui setup --validate
```
Verified: exit code 0.
2. Add a component
Installs the component with its dependencies and adapts it to your tokens. Your business logic, existing tokens and design system are protected.
In your project folder
```
agentic-ui add billing-usage-meter
```
Verified: exit code 0.
3. Build as usual
Installed components are plain source files in your repository.
In your project folder
```
pnpm build
```
Verified: exit code 0.

Without the CLI you can also run npx shadcn@4.17.0 add @agentic-ui/<component>; plain shadcn needs AGENTIC_UI_REGISTRY_URL and AGENTIC_UI_TOKEN exported in your shell. Every component page shows both commands.

Start a new app from a blueprint

Start from an empty Next.js App Router project with Tailwind CSS 4, run setup, then add a blueprint: one command writes its routes and installs its components. Choose a blueprint.

1. Connect your Next.js project (one command)
Run it in the root of your Next.js project. It uses the license key stored by agentic-ui login, or asks for it without echo, and keeps it in ~/.config/agentic-ui/credentials.json (never in the project). The registry defaults to https://registry.agentic-ui-kit.com. Then it installs the kit tools, runs shadcn init, profiles the project (ui-kit.config.yaml, Design DNA, AGENTS.md block), registers the MCP server agentic-ui for your coding agents (--client, default detect) and installs the four agent skills in .claude/skills and .agents/skills. Add --style base-vega for Base UI and --validate to confirm the key with one request. It is safe to run again.
In your project folder
```
agentic-ui setup --validate
```
Verified: exit code 0.
2. Add the blueprint
Replace the name with the blueprint you chose. It is also listed on each blueprint page. This command uses plain shadcn, so export AGENTIC_UI_REGISTRY_URL and AGENTIC_UI_TOKEN (your registry URL and license key) in the shell first.
In your project folder
```
npx shadcn@4.17.0 add @agentic-ui/blueprint-saas-backoffice
```
Checked: every blueprint installs and builds in a clean Next.js project (38/38).
3. Build as usual
Installed components are plain source files in your repository.
In your project folder
```
pnpm build
```
Verified: exit code 0.

Templates are not installed whole: add the screens and components you need from a template with agentic-ui add. Each template page links to its components.

Apply, export or import a theme

A theme is one CSS file of variables on top of the base tokens: components are never edited, and Radix UI and Base UI projects follow it the same way. Pick a preset or design your own in the Theme Studio; its Use in project dialog gives the CLI command, the agent prompt, the share code and CSS or JSON files, and its Import takes a share code or a theme JSON back.

1. Apply a theme
With the CLI. Replace corporate with a preset id or with the aui1_ code you copied from the Theme Studio. The dry run prints the variable diff; apply writes agentic-ui-theme.css next to your entry CSS, imports it once and records it in ui-kit.config.yaml. Applying another theme replaces it.
In your project folder
```
agentic-ui theme list
agentic-ui theme apply corporate --dry-run
agentic-ui theme apply corporate
agentic-ui theme show
```
Verified: exit code 0.
2. With a code from the Theme Studio
The Studio copies this command with your code. Start a new project with a theme using agentic-ui init --theme <code>; export or remove it with agentic-ui theme export --format css and agentic-ui theme remove.
In your project folder
```
agentic-ui theme apply aui1_<your code>
```
3. From your agent over MCP
resolve_theme checks a code, preset or spec and returns its summary, AA report and the exact apply command; list_themes lists the 26 presets. The agent then runs the CLI command.
MCP tool call (recorded in verification)
```
resolve_theme {"theme":"corporate","include_css":false}
```
Returned Corporate with its apply command.
4. With the agent skills
Every skill resolves and applies the theme right after loading the project context, before it adds any UI. Paste the prompt from the Theme Studio into your agent, or run the step yourself:
In your project folder
```
node .claude/skills/agentic-ui-extend/scripts/theme.mjs resolve --theme corporate --json
```
Exit code 0 in verification.

Configure your coding agent

Makes your agent check the catalog before it writes new UI. Setup does all of it; run it again at any time. The client id of each agent is listed under Per agent.

1. Connect your Next.js project (one command)
Writes ui-kit.config.yaml, the project profile and its Design DNA, adds an AGENTS.md block for agents (and an @AGENTS.md line to an existing CLAUDE.md), registers the MCP server agentic-ui for your agents and installs the four skills (greenfield, rework, extend, audit) in .claude/skills and .agents/skills. --client picks the agents; the default, detect, is Claude Code plus every agent whose folder already exists in the project. Finished steps are reported as present on a second run.
In your project folder
```
agentic-ui setup --validate
```
Verified: exit code 0.
2. Add more agents later
Writes the MCP config of each agent you name (comma-separated ids, all or detect) and keeps the other servers in those files.
In your project folder
```
agentic-ui mcp install --client cursor,vscode
```

Configure MCP

The stdio MCP server is called agentic-ui. Setup registers it in the MCP config of your agents; the agent starts it when it calls a tool, after the reload or trust step listed for it above.

1. Check the MCP server
Setup already registered the agentic-ui server. This starts it the way your agent would (initialize and tools/list) and prints the tool count; it exits with code 1 if the server cannot start. agentic-ui mcp check does the same.
In your project folder
```
node "$AGENTIC_UI_KIT/bin/agentic-ui-mcp.mjs" check --project .
```
Verified: exit code 0.
2. Register or re-register it
Same entry as setup, for the agents you name. Run it again after moving the kit or upgrading Node.js, then check it.
In your project folder
```
agentic-ui mcp install --client detect
agentic-ui mcp check
```
3. Register it with the launcher Optional
The MCP tool itself, for a project where you do not run agentic-ui setup.
In your project folder
```
node "$AGENTIC_UI_KIT/bin/agentic-ui-mcp.mjs" install --project . --client detect
```
Checked in the MCP server's own test suite.

The entry uses absolute paths: the Node.js binary that ran the command (agents started from a dock may not have node on their PATH), this kit's server, catalog and registry index, and your project. After upgrading Node.js or moving the kit, run agentic-ui mcp install again.
Those files hold paths of this machine, so the command adds them to .gitignore and prints which. Do not commit them.
Other servers and settings in those files are kept, an existing file is backed up once as <file>.agentic-ui-bak, and re-running changes nothing. A file that is not plain JSON (for example with comments) is left alone and the entry is printed for you to paste.
Claude Desktop and Cline keep their MCP config at user level: nothing is written, the CLI prints the file path and the JSON block.

Use the agent skills

Setup copied the four skills into .claude/skills (read by Claude Code) and .agents/skills (Codex, Cursor, Gemini CLI and most other agents); both copies are identical. Your agent runs these scripts as the skills instruct. You can run them yourself to see what the agent sees.

1. Load the project context (the first step of every skill)
In your project folder
```
node .claude/skills/agentic-ui-extend/scripts/context.mjs --json
```
Exit code 0 in verification.

2. Plan a feature with reuse first

In your project folder

node .claude/skills/agentic-ui-extend/scripts/plan-extend.mjs --feature "seat usage with plan limits" --provider mcp --json

Exit code 0 in verification.

3. Audit the current UI (read-only)
In your project folder
```
node .claude/skills/agentic-ui-audit/scripts/audit.mjs --json
```
Exit code 0 in verification.

Reinstalling and updates

Running agentic-ui add again for an installed component keeps your files and its adaptation report unchanged.
Installed components are your source files: edit them like any other code. Nothing is updated behind your back.
Use agentic-ui add <component> --dry-run to see the files and dependencies before writing anything.
After downloading a newer kit, agentic-ui update refreshes the agent skills and every installed item. Files you did not touch are replaced; a file you edited is never overwritten: the new version is written next to it as <file>.agentic-ui-new for you to merge.
agentic-ui add <component> --overwrite refreshes one item with the same rule; agentic-ui remove <component> uninstalls it and keeps the files you edited.

In your project folder

agentic-ui update --dry-run
agentic-ui update
agentic-ui remove <component> --dry-run

Known limitations

The installation steps above are run end to end in the Radix UI variant. The Base UI variant is covered by the registry's install and build checks.
A few components request data files that their registry item does not include: payments-regions-map (a countries GeoJSON), the regatta-ops maps (a land GeoJSON) and some devtools screens (an SVG image). Add those files to your public folder or replace the data source.
The CLI supports Next.js projects with Tailwind CSS 4 only, and refuses to add a second design system to a project that already has one.
Coding agents run commands without a terminal, so they cannot type the license key: run agentic-ui login yourself first. Agents other than Claude Code, Codex and Kimi Code are configured from their official docs and not yet covered by our recorded runs.

CLI reference

agentic-ui --help

Usage: agentic-ui <command> [options]

  login                store your license key (asked without echo, checked with the registry) in the user config; run it in
                       your own terminal, then let your coding agent run `setup --yes`
  setup                one-command onboarding: license key + registry URL → user config, kit deps, shadcn init, init, skills,
                       MCP config for your coding agents (--client, default detect)
  mcp install --client <ids|all|detect>   register the MCP server `agentic-ui` for coding agents (agentic-ui mcp --help)
  mcp check            start the registered MCP server (initialize + tools/list) and report its tool count
  init                 @agentic-ui registry in components.json, AGENTS.md, skills/MCP status and ui-kit.config.yaml
  analyze              Project Intelligence → .ui-kit/project-profile.json + proposes/persists ui-kit.config.yaml
  dna                  Design DNA → .ui-kit/design-dna.json + design_dna in ui-kit.config.yaml
  add <pattern>...     shadcn add @agentic-ui/<pattern> (one or several) + guards + adaptation rules; --overwrite refreshes installed items
  remove <item>...     uninstall items: unchanged files, adaptation reports and ledger entry (edited files are kept; --force, --dry-run)
  update               refresh a project after downloading a newer kit: agent skills + every installed item (--dry-run first)
  theme <subcommand>   apply <aui1_code|preset|spec.json> · show · list · export · remove (agentic-ui theme --help)
  help                 show this help (same as --help)

Options:
  --cwd <dir>              target project (defaults to the current directory)
  --json                   JSON output
  --refresh                (dna) regenerate design_dna in the config
  --variant <v>            new-york | base-vega
  --mode <m>               (init) conservative | balanced | transformative | greenfield
  --bootstrap              (init) no components.json: run shadcn init with the registry's variant-{v} bootstrap
  --theme <t>              (init) apply a theme: aui1_ code, preset id or Theme Spec JSON file
  --registry-url <url>     registry URL (defaults to $AGENTIC_UI_REGISTRY_URL, then https://registry.agentic-ui-kit.com)
  --license-key <key>      (setup, login) license key; prefer the prompt or $AGENTIC_UI_TOKEN (flags show up in shell history)
  --style <v>              (setup) alias of --variant
  --client <ids>           (setup, mcp install) agents to configure: claude-code, cursor, vscode, gemini, codex, kimi, amp, junie,
                           devin, antigravity, opencode, zed, claude-desktop, cline (comma-separated), all, or detect (setup default)
  --validate               (setup) one GET of a non-public registry item to confirm the license key
  --yes                    (setup) never prompt; fail when a value is missing
  --dry-run                (add, update, theme apply/remove) show the plan without writing files
  --overwrite              (add) also refresh the files of an already-installed item: unchanged since install → replaced,
                           edited by you → new version written as <file>.agentic-ui-new (never overwritten)
  --force-kit-files        (update, add --overwrite) also replace kit library files (components/agentic-ui/lib/**, lib/motion/**,
                           hooks/use-mobile, components/ui/**) that you edited or whose install hash was never recorded
                           (projects installed by an older kit); the previous file is kept as <file>.agentic-ui-bak
  --prune                  (update) also delete files "no longer in the kit" that are unchanged since install and not imported by any
                           project file (others are kept and reported)
  --accept <file>          (update) resolve a conflict by taking <file>.agentic-ui-new (the pristine upstream file): replaces <file>, refreshes the
                           install hash and the tokenize record. Repeatable
  --keep <file>            (update) resolve a conflict by keeping your <file>: deletes <file>.agentic-ui-new and records this upstream version
                           so the next update does not conflict on it again. Repeatable
  --verbose                (update) also list the files that were replaced or added
  --force                  (remove) also remove files you edited since install (files shared with another installed item or still
                           imported by a project file are never removed)
  --code-file <file|->     (theme apply) read the aui1_ code from a file or stdin (-) instead of the command line
  --out <file>             (theme apply) theme CSS path (defaults to agentic-ui-theme.css next to the entry CSS)
  --format <f>             (theme export) code | json | css | prompt
  --allow-undistributable  (add) install ship-after-fix items locally
  --index <dir>            local registry index (no registry URL)
  --catalog-root <dir>     root directory that contains catalog/

agentic-ui mcp --help

Usage: agentic-ui mcp <install|check|uninstall> [--client <ids|all|detect>] [--cwd <dir>] [--json]

  install    register the MCP server `agentic-ui` in the project config of each agent (default: claude-code)
  check      start the registered server, run initialize + tools/list and report the tool count (exit 1 on failure)
  uninstall  remove the entry from every agent config of the project

Clients: claude-code, cursor, vscode, gemini, codex, kimi, amp, junie, devin, antigravity, opencode, zed
(project files), claude-desktop, cline (user-level: the snippet and file path are printed, nothing is written),
all, detect (claude-code plus every agent whose folder exists in the project).

MCP server launcher

node "$AGENTIC_UI_KIT/bin/agentic-ui-mcp.mjs" <command> [options]

  install    [--project <dir>] [--client <ids|all|detect>] [--catalog <dir>] [--registry-index <dir>] [--no-gitignore] [--json]
  uninstall  [--project <dir>] [--json]
  check      [--project <dir>] [--client <id>] [--timeout <ms>] [--json]   starts the server: initialize + tools/list

The 9 MCP tools and the four skills are described on For agents.

Availability states

Each component shows the state the registry reports, updated whenever the site is rebuilt.

Available: Installable now from the private registry.; 828
Not in v1.0: Excluded from this release for quality reasons.; 15

Which file does each agent read?

Setup writes one AGENTS.md block, the MCP config of each agent you pass to --client, and the same four skills in .claude/skills and .agents/skills.

Agent	Instructions	MCP config	Skills folder
Claude Code	CLAUDE.md (AGENTS.md only when there is no CLAUDE.md; setup adds @AGENTS.md to an existing CLAUDE.md)	.mcp.json	.claude/skills
Codex	AGENTS.md	.codex/config.toml	.agents/skills
Kimi Code	AGENTS.md	.kimi-code/mcp.json	.agents/skills
Cursor	AGENTS.md	.cursor/mcp.json	.agents/skills, .claude/skills
VS Code + Copilot	.github/copilot-instructions.md, AGENTS.md (setting)	.vscode/mcp.json	.claude/skills, .agents/skills
Gemini CLI	GEMINI.md, plus AGENTS.md through context.fileName	.gemini/settings.json	.agents/skills
opencode	AGENTS.md	opencode.json	.claude/skills, .agents/skills
Amp	AGENTS.md	.amp/settings.json	.agents/skills, .claude/skills
Devin Desktop	AGENTS.md	.devin/mcp_config.local.json	.agents/skills, .claude/skills
Google Antigravity	AGENTS.md	.agents/mcp_config.json	.agents/skills
JetBrains Junie	.junie/AGENTS.md if present, else AGENTS.md	.junie/mcp/mcp.json	.agents/skills
Zed	First rules file found (AGENTS.md is in its list)	.zed/settings.json	.agents/skills
Claude Desktop	None	claude_desktop_config.json (user-level, printed)	Not read from the project
Cline	AGENTS.md	cline_mcp_settings.json (user-level, printed)	.claude/skills

Installation and setup

Install with your coding agent

1. In your own terminal, once

2. Paste one prompt into your agent

Per agent: client id and what differs

Manual setup and reference

Prerequisites

Kit location

Set up the kit (once per machine)

1. Unzip the kit and check it runs

2. Store your license key Optional

Add a component to an existing project

1. Connect your Next.js project (one command)

2. Add a component

3. Build as usual

Start a new app from a blueprint

1. Connect your Next.js project (one command)

2. Add the blueprint

3. Build as usual

Apply, export or import a theme

1. Apply a theme

2. With a code from the Theme Studio

3. From your agent over MCP

4. With the agent skills

Configure your coding agent

1. Connect your Next.js project (one command)

2. Add more agents later

Configure MCP

1. Check the MCP server

2. Register or re-register it

3. Register it with the launcher Optional

Use the agent skills

1. Load the project context (the first step of every skill)

2. Plan a feature with reuse first

3. Audit the current UI (read-only)

Reinstalling and updates

Known limitations

CLI reference

Availability states

Which file does each agent read?