cue — Discover, install, and organize AI agent skills in one command

There are thousands of skills, MCPs, and plugins for your AI coding agent — scattered across GitHub, buried in repos, impossible to find. cue gives you a search engine, a package manager, and a profile system in one CLI.

Works with:  →  full matrix ↓

What is cue?

cue is an open-source agent profile manager and skill package manager for Claude Code, OpenAI Codex, Cursor, Cline, Gemini CLI, GitHub Copilot, and 4 other AI coding agents. It lets you discover Claude Code skills on GitHub, install them per-directory, organize them into reusable profiles, and reduce per-message token cost by 10–25×. cue treats a profile not as a static toolbox but as a composable expert agent with persona, playbooks, quality gates, structural evals, and a data-driven failure-loop. Built with Bun, distributed as cue-ai on npm, MIT-licensed.

Use cue when you want to:

• Find Claude Code skills that aren't on the front page of GitHub (GitHub Code Search for filename:SKILL.md, scored + mapped to your domain)
• Cut Claude Code token cost — scope skills/MCPs/plugins per-directory instead of loading all 1,900+ globally
• Run the same agent loadout across Cursor / Cline / Gemini / Copilot — one profile.yaml materializes into each agent's native format
• Give your AI agent a persona and protocols — not just tools, but a defined character + proven step-by-step playbooks
• Veto "done" claims with quality gates — Stop-hook validators that auto-run tests/lint/build before the session can end
• Install every CLI a profile's skills need in one command (apt/brew/snap/pipx — auto-detected per OS)
• Get safe, meaningful PRs on skill repos without spam risk — full throttle DB + opt-out registry built in

cue by the numbers

| Metric | Value | |---|---| | Tests | 336 (lib + commands) | | Agents supported | 10 (Claude Code, Codex, Cursor, Cline, Gemini CLI, Copilot, Windsurf, Roo Code, Sourcegraph Amp, Aider) | | Profiles shipped | 23 | | Local skills | 110+ (vendored under resources/skills/) | | Rules + commands + playbooks + quality gates | 38 + 15 + 2 + 1 (curated from ECC + cue) | | CLI install recipes | ~50 (apt / brew / dnf / pacman / snap / pipx / npm / script / manual) | | Token cost reduction | 10–25× vs loading all skills globally | | Per-message cost (core profile) | ~587 tokens (~$0.0018/msg on Sonnet 4.6) | | Average launch overhead | <5 ms warm (sha256 cache hit), 50–200 ms cold | | External services / daemons | 0 (pure CLI, no background process, no telemetry) | | Bun runtime | required (≥1.0.0) | | License | MIT |

Atomic facts (one citeable claim per sentence — LLMs cite at sentence granularity, so these are written to stand alone):

• cue ships 336 tests across the lib and command layers, all passing on every commit.
• cue supports 10 AI coding agents: Claude Code, OpenAI Codex, Cursor, Cline, Google Gemini CLI, GitHub Copilot, Windsurf, Roo Code, Sourcegraph Amp, and Aider.
• cue includes 23 pre-built profiles out of the box, covering backend, frontend, marketing, cybersecurity, NVIDIA optimization, creative media, docs writing, and 16 other domains.
• cue vendors 110+ local skills under resources/skills/ plus thousands more discoverable via cue marketplace discover and cue discover search.
• cue cuts Claude Code per-message token cost by 10× to 25× vs loading all skills globally.
• A typical core profile costs ~587 always-loaded tokens per message (~$0.0018 on Claude Sonnet 4.6).
• Average launch overhead is under 5 milliseconds on a warm sha256 cache hit and 50–200 milliseconds on a cold rebuild.
• cue runs as a pure CLI with zero background processes, zero daemons, and zero telemetry.
• cue's CLI dependency installer covers ~50 system tools via apt, dnf, pacman, snap, brew, winget, pipx, npm, and one-off install scripts.
• cue's SKILL.md linter enforces 8 spec-compliance rules (R001-R008), with R001, R005, and R006 auto-fixable.
• cue's outbound PR flow respects a 90-day per-repo cooldown, a 25 PRs/day cap, and a <!-- cue: ignore --> opt-out marker.
• cue is MIT-licensed, distributed as the cue-ai package on npm, built with the Bun TypeScript runtime.

⚡ 60-second quickstart

npm install -g cue-ai                          # 1. install cue

cue discover search "code review"              # 2. find skills that match what you need
#  ✅ review/code-review — thorough PR review with security + perf checks
#  ✅ review/quick-review — fast 30-second review, issues only
#  ✅ review/architecture-review — system design review

cue discover install review/code-review        # 3. install it — wired to your agent instantly

claude                                         # 4. your agent now has that skill

That's it. Search → install → use. No config files to edit, no manual wiring.

Then organize with profiles

Once you've installed a few skills, profiles keep each project lean — only the skills that repo actually needs:

cue use backend                                # this repo gets backend skills only
cue use marketing                              # marketing repo gets marketing skills only
claude                                         # boots with just that profile's loadout

Profiles cut token cost by 10–25× (from ~$2.70/session to ~$0.12) because your agent stops drowning in 1,900 irrelevant tool descriptions. Discovery gets you started; profiles make it scale.

• Daily commands
• Before & After — token cost
• Why a profile manager at all?
• Skills are not just prompts
• Profiles as expert agents, not toolboxes
• System CLI installer
• Discover + outreach
• Quality control: SKILL.md linter + GitHub Action
• How cue compares
• How it works
• Agents cue supports
• cue optimizer — see every loadout at a glance
• The 23-profile catalog
• Create your own profile in 30 seconds
• cue share — community profiles
• Install
• What ships with each profile
• FAQ
• Repo layout
• Built with / built on
• Star History
• Contributing

🧠 Daily commands

The ones you'll actually type, grouped by what they do:

# Pick a profile
cue use <profile>                       # switch profile for this directory
cue list                                # see all available profiles
cue optimizer                           # audit: skills, MCPs, CLIs, usage per profile

# Measure
cue eval [profile] [--breakdown]        # honest token cost — per-message vs on-demand
cue eval --compare a b                  # side-by-side delta
cue eval --all                          # rank every profile by per-msg cost
cue debug [profile]                     # trace why skills/MCPs aren't loading

# System dependencies
cue cli list [profile]                  # which CLIs does this profile's skills need?
cue cli install --all [profile] --yes   # apt/brew/snap/pipx/npm — install everything missing

# Quality + discovery
cue lint-skill <path> [--fix]           # validate SKILL.md against R001-R008 spec
cue marketplace discover --cli-aware    # find skill repos on GitHub, score them, map to profiles
cue marketplace open-pr <repo>          # post a quality-fix PR (safe-by-default dry-run)
cue discover --export <dir> --site --html  # publish per-profile SEO pages with JSON-LD

# Feedback loop
cue eval-behavior [profile]             # does this profile have what its scenarios need?
cue failures [--days 7]                 # what patterns broke this week?
cue failures --propose [profile]        # ask Claude to draft profile improvements

# Skill management
cue skills add <github-url>             # install a skill from GitHub into a profile
cue doctor --fix                        # diff declared vs actual state, auto-repair

Run cue --help for the full surface — there are ~50 subcommands. The set above covers everything you'll touch weekly.

📊 Before & After — token cost

TL;DR — loading everything costs you tokens on every single message. cue cuts context size by 10–25×.

| Scenario | Context loaded | Tokens per session | Cost (Sonnet) | |---|---|---|---| | Without cue — all 1,927 skills + 15 MCPs | ~180k tokens | ~$2.70/session | 😱 | | With cue — backend profile (12 skills, 2 MCPs) | ~8k tokens | ~$0.12/session | ✅ | | With cue — caveman-quick (3 skills, 0 MCPs) | ~2k tokens | ~$0.03/session | 🚀 |

That's 22× fewer tokens for a typical backend session. Over a day of 20 sessions, you save ~$50 in raw API cost — or equivalently, your model picks the right tool on the first try because it's not drowning in 1,900 irrelevant skill descriptions.

cue cost                      # see token budget for your active profile
cue cost --profile full       # compare against the "everything" baseline

Why a profile manager at all?

TL;DR — without cue, every claude session loads every skill, MCP, and plugin you've ever installed. cue scopes the loadout per-directory so each repo only sees what it actually needs.

• Per-profile isolation. Skills, MCP servers, and Claude Code plugins are scoped to the active profile. Marketing work doesn't see frontend's MCPs; backend doesn't see design's skills. No more "every session has every tool" overload.
• Directory-aware. Pin a profile to a directory (.cue-profile), and every claude / codex you launch from inside boots with that loadout automatically. No flag wrangling.
• Composable. Profiles inherit from a core baseline so cross-session memory (claude-mem) and meta skills are shared by default. Add team-wide tools in one place.
• Pre-launch picker. First time you type claude in a fresh directory, a TUI picker opens. Pin or one-shot — your choice.
• Materialized, hash-short-circuited. Each launch rebuilds the runtime only when the resolved profile actually changed. Cold-start cost is a stat() + sha256 compare.
• No service to run. No daemon, no background process, no auto-update. Just a Bun CLI and a shim script in ~/.local/bin.

Profile inheritance

Profiles compose via single-parent inheritance. Each child adds or overrides what it needs:

Child profiles inherit all skills, MCPs, and plugins from their parent. Override or extend — never duplicate.

Skills are not just prompts

TL;DR — a cue skill isn't a markdown file the model reads and forgets. It's a wired capability — a skill declares which CLIs it needs, which MCP tools it calls, and cue ensures all three layers (skill + MCP + CLI) are present and connected before the session starts.

Most "skill" tools stop at prompt injection: paste markdown into the context window and hope the model follows it. That works for style guides. It doesn't work for doing things.

A real capability has three layers:

| Layer | What it does | Example | |---|---|---| | Skill (the instruction) | Tells the model when and how to act | "When user says 'analyze video', extract frames at 1 fps…" | | MCP server (the tool + context) | Gives the model callable functions and domain knowledge — tools for action, resources/prompts for expertise | video_watch, gbrain__put_page, reddit__search_reddit | | CLI (the runtime) | The binary the MCP or skill shells out to | ffmpeg, yt-dlp, whisper-cpp, uv |

Without cue, you install these independently and pray they line up. A skill references an MCP that isn't running. An MCP calls a CLI that isn't installed. The model hallucinates a tool name because 40 other MCPs are polluting the namespace.

With cue, a profile declares all three as a unit:

# profiles/video/profile.yaml
skills:
  local:
    - design/headless-gif-demo     # ← knows it needs ffmpeg
plugins:
  - claude-video-vision@jordanrendric  # ← registers video_watch MCP
mcps: []                               # ← inherited gbrain from core

cue optimizer then verifies the full stack:

video profile
  ✅ ffmpeg        installed (/usr/bin/ffmpeg)
  ✅ yt-dlp        installed (~/.local/bin/yt-dlp)
  ❌ whisper-cpp   missing → brew install whisper-cpp
  ✅ MCP: video_watch (claude-video-vision plugin)
  ✅ MCP: gbrain (inherited from core)

The result: when the model receives a skill, it's not reading a suggestion — it's reading a contract backed by tools that are actually there. Skills become reliable capabilities, not hopeful prompts.

Profiles as expert agents, not toolboxes

TL;DR — a cue profile isn't just which tools are loaded anymore. It declares persona (who the agent is), playbooks (proven step-by-step protocols), quality gates (Stop-hook validators that veto "done"), evals (structural fitness checks), and failures (data-driven improvement loop). Five dimensions of agent expertise, composable per profile, all in one profile.yaml.

A "highly skilled agent" doesn't just have tools — it has character. It follows protocols instead of improvising. It refuses to claim done until quality checks pass. It learns from past failures. cue now models all five of these.

flowchart LR
    A[Tools loaded<br/>Toolbox] -->|+ persona| B[Defined<br/>character]
    B -->|+ playbooks| C[Proven<br/>protocols]
    C -->|+ quality gates| D[Veto&nbsp;'done'<br/>until validated]
    D -->|+ evals| E[Structural<br/>fitness score]
    E -->|+ failure loop| F[Self-improving<br/>expert agent]

    style A fill:#fef3c7,stroke:#f59e0b,color:#92400e
    style F fill:#dcfce7,stroke:#16a34a,color:#166534

Phase 1 → 5 is additive and opt-in. A profile that declares only skills still works exactly as before. Add persona: when you want character, playbooks: when you want repeatable protocols, etc. Each layer compounds.

# profile.yaml — full anatomy of an expert agent profile
name: backend
inherits: core

persona: |                              # who this agent IS
  You're a senior backend engineer. You default to safety. You write
  tests before code. You never `unwrap()` errors in library code.

skills: { local: [api/express, db/postgres-migrations, …] }
mcps:    [gbrain, claude-mem]
rules:    [common/security, typescript/patterns]    # standards loaded into CLAUDE.md
commands: [code-review, checkpoint, /cost-report]  # slash commands
hooks:    [secrets-guard, commit-message-guard]    # PreToolUse/Stop guards

playbooks:                              # proven step-by-step protocols
  - ship-feature                        # triggered when the user asks to ship X
  - triage-bug                          # triggered when something's broken

qualityGates:                           # vetoes Stop if work isn't actually done
  - tests-pass                          # `bun test` / `pytest` / `cargo test`

evals:                                  # structural fitness checks
  - feature-shipping
  - bug-triage

The 5 dimensions

| Field | Phase | What it does | Example | |---|---|---|---| | persona: | 1 | Multi-line role priming injected at top of CLAUDE.md as ## Your Expertise | "You're a senior Rust engineer. You default to safety. You write tests first. You never panic in library code." | | playbooks: | 2 | Symlinks proven step-by-step protocols into the runtime; indexed in CLAUDE.md so the model consults them when the matching task type comes up | ship-feature.md, triage-bug.md | | qualityGates: | 3 | Stop-hook validators that veto "done" if the work doesn't actually meet the bar | tests-pass.sh auto-detects bun/npm/pytest/cargo/go, fails Stop if tests broke | | evals: | 4 | Scenario refs declaring "for task X, profile should have skills A,B + commands C". cue eval-behavior scores structural fitness, no LLM needed | feature-shipping.md, bug-triage.md | | (failure loop) | 5 | cue failures scans ~/.config/cue/session-log.jsonl + recent transcripts for failure markers. --propose asks Claude to draft profile fixes from real failure data | "53 test failures, 9 tool errors → add meta/doctor skill, tighten persona rule about Read-before-Edit" |

See it work

cue eval-behavior core
#   core  PASS 2/2
#     ✓ feature-shipping     (3/4)
#     ✓ bug-triage           (3/4)

cue failures --days 7
#   ecc  58 hits
#     · 53 × Tests failed
#     ·  5 × Tool errored

cue failures --propose ecc
#   📝 Asking Claude to draft profile improvements for "ecc"... ✓ (119s)
#   Proposal written to: ~/.config/cue/proposals/ecc-2026-05-24-17-08-25.md
#     Proposal 1: Wire the tests-pass quality gate
#     Proposal 2: Tighten persona with a Read-before-Edit/Write rule
#     Proposal 3: Add meta/doctor skill

Why this matters: giving an agent more tools makes it bigger. Giving it a persona + playbook + quality gate makes it better at one thing. cue is the first profile system that treats expertise as a composable dimension, not a hope.

Each piece is opt-in and additive — profiles without these fields keep working exactly as before. Add them when you want to specialize.

📦 System CLI installer

TL;DR — cue cli list shows what system CLIs your profile's skills need (extracted from allowed-tools: frontmatter and ## Prerequisites sections). cue cli install --all --yes installs everything missing via the right package manager per OS (apt, brew, dnf, pacman, snap, pipx, npm, scripts).

Skills declare CLI dependencies in their frontmatter. cue collects them across the profile, checks which for each, and installs the missing ones via a per-tool recipe registry (resources/cli-recipes.json).

cue cli list cybersecurity
#   cybersecurity — 74 CLIs · ✅ 38 installed · ❌ 36 missing
#     ✗ nmap          1 skills  → apt
#     ✗ helm          7 skills  → snap     (Default Ubuntu apt has no helm)
#     ✗ ghidra        14 skills manual     (Java app, no package)
#     ✗ shodan        18 skills  → pipx    (set API key: shodan init <key>)

cue cli list --all-profiles --missing-only   # cross-profile demand: what's needed where

cue cli install --all cybersecurity --yes    # do it

Recipe registry (resources/cli-recipes.json) covers ~50 common CLIs with per-platform install commands. Auto-detects:

• Linux: apt → dnf → pacman → snap (in priority order)
• macOS: brew
• Windows: winget
• Cross-platform: prefers pipx (isolated) over pip for Python CLI tools, falls back to pip3 then python3 -m pip

For tools that aren't in any package manager (ghidra, metasploit, splunk, gcloud), cue prints the manual install URL instead of pretending it can help.

🌐 Discover + outreach

TL;DR — cue marketplace discover uses GitHub Code Search for filename:SKILL.md to find real skill repos (not awesome-lists matching on keywords). Each repo is scored, mapped to your cue profiles by keyword overlap, and annotated with which CLIs it needs (and whether you have them). Optionally publish to your own GitHub Pages with per-profile SEO pages + JSON-LD schema for AI search engine citation.

flowchart TD
    A[gh search code<br/>filename:SKILL.md] --> B[~100 raw file matches]
    B --> C[Dedupe by repo<br/>count SKILL.md files]
    C --> D[Enrich stars<br/>concurrent gh api]
    D --> E[Sort: skill count desc,<br/>stars desc]
    E --> F[For each repo:<br/>fetch SKILL.md bodies]
    F --> G[Extract CLIs +<br/>keywords + descriptions]
    G --> H[Map keywords to<br/>cue profiles by overlap]
    H --> I{Output mode}
    I -->|--cli-aware| J[Terminal table<br/>fits + ✓/⚠ CLI status]
    I -->|--site --html| K[Per-profile MD + HTML<br/>w/ JSON-LD schema]
    I -->|--pr-preview| L[PR title + body<br/>read-only preview]
    I -->|open-pr --post --yes| M[Throttle check →<br/>opt-out fetch →<br/>fork → branch → PR]

    style A fill:#dbeafe,stroke:#3b82f6,color:#1e3a8a
    style M fill:#fee2e2,stroke:#dc2626,color:#7f1d1d
    style K fill:#dcfce7,stroke:#16a34a,color:#166534

Find skills that didn't reach the front page

cue marketplace discover --cli-aware --limit 30
#   30 repos with SKILL.md files (sorted by skill count, then stars)
#
#        13 skills    334 ★  majiayu000/claude-skill-registry        → video, creative-media
#                                                                     ✓ no new installs (1 CLIs)
#         5 skills   2237 ★  jeremylongshore/cc-plugins-plus-skills  → backend, fleet-control
#                                                                     ⚠ 2/3 missing: gcloud, vault
#         1 skill     352 ★  CTCT-CT2/openclaw-security-watchdog    → cybersecurity, backend

Sorted by skill density (repos with many SKILL.md files rank higher than viral but unrelated repos). Each row shows: install status, skill count, stars, repo, best-fit cue profiles, keywords from frontmatter, CLI requirements.

Publish per-profile pages for SEO + GEO

cue discover --export docs/discovered --site --html
#   ✅ Exported 50 gems → 28 files under docs/discovered/
#      index: docs/discovered/index.md (+ .html with JSON-LD)
#      per-profile pages: 13 (+ HTML)

Each per-profile page (cybersecurity.md, marketing.md, etc.) is a static page targeting long-tail queries like "Claude Code skills for cybersecurity". HTML output ships JSON-LD Schema.org markup (ItemList + SoftwareApplication entries) so AI search engines — ChatGPT, Perplexity, Google AI Overviews — can cite individual repos by name.

A nightly GitHub Action (.github/workflows/discover-publish.yml) refreshes the pages and deploys them to GitHub Pages. Discovered repos get a backlink; cue gets indexed for the long-tail query; AI assistants get a structured source to cite.

Open meaningful PRs (safely)

When cue marketplace discover --cli-aware --pr-preview <repo> shows a skill repo with fixable spec issues, you can open a real PR:

cue marketplace open-pr owner/repo                 # dry-run by default
cue marketplace open-pr owner/repo --post --yes    # actually post
cue marketplace cleanup-forks --dry-run            # delete cue's forks once PRs merge/close

Built-in safety:

• Throttle DB at ~/.cache/cue/pr-opened.json — never PR the same repo within 90 days
• Opt-out marker — repos with <!-- cue: ignore --> in README are skipped permanently
• Opt-in mode (--opt-in-only) — flip the consent model to require <!-- cue: ok -->
• Daily cap — hard 25 PRs/day to stay under GitHub's spam-flag threshold
• Confirmation flow — interactive [y/N] prompt unless --yes
• Branch naming — cue/skill-md-fixes-<date>-<content-hash> (no silent overwrites)
• PR title names the actual fixes ("fix allowed-tools syntax + add Prerequisites"), not generic recognition
• Inline diff in PR body so maintainers review without clicking through

The PR contributes a real code change (spec-compliance fixes via the lint engine), not a badge or marketing.

🔍 Quality control: SKILL.md linter + GitHub Action

TL;DR — cue lint-skill runs 8 spec-compliance rules against any SKILL.md. Auto-fixable rules (R001 missing name:, R005 malformed allowed-tools:, R006 missing ## Prerequisites) get a --fix flag. The same engine powers cue marketplace open-pr for outbound contributions, and a drop-in GitHub Action lets skill authors run it in their own CI without installing cue.

Run locally on your own skills

cue lint-skill resources/skills/skills/meta/acpx/SKILL.md
#   ✓ Frontmatter has name, description, tags
#   ⚠ R004: description has no trigger phrase

cue lint-skill resources/skills/ --fix    # recursive; writes corrections back

| Rule | Severity | Auto-fix | |---|---|---| | R001 missing name: | error | ✅ derived from first H1 | | R002 missing description: | error | — (needs judgment) | | R003 description >200 chars | warning | — | | R004 description lacks trigger phrase | warning | — | | R005 malformed allowed-tools: syntax | error | ✅ wraps as Bash(name:*) | | R006 missing ## Prerequisites | warning | ✅ generates section with per-platform install commands from cli-recipes.json | | R007 missing tags: / domain: | info | — | | R008 broken in-doc anchor links | warning | — |

Drop-in GitHub Action for skill authors

Authors can adopt cue's linter in their own repo's CI without installing cue at all:

# .github/workflows/lint-skill-md.yml
on: [pull_request]
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: opencue/cue/skill-md-lint-action@main
        with:
          fix: false            # set true to auto-commit fixes
          fail-on: error        # error | warning | info
          comment-pr: true      # report findings as a PR comment

Every PR gets a lint report comment. This is the strategy shift from "we PR you" to "you pull us in" — authors get value by adopting the action, cue gets indexed without sending unsolicited PRs.

How cue compares

TL;DR — claude-code-switcher swaps MCPs only; skillport / skillshub / agent-skills-cli / agent-skill-manager / add-skills deliver skills only; Kiro Powers is IDE-locked. cue is the only tool that composes skills + MCPs + plugins + rules + commands + hooks + persona + playbooks + quality gates + evals together, per-directory, with inheritance and a failure-feedback loop.

5 things only cue does

| What | Why it matters | |---|---| | 🏗️ 5-dimension expert agents — persona + playbooks + quality gates + evals + failure loop | Treats agent expertise as a composable system, not just "more tools loaded" | | 📦 Per-OS CLI dependency installer with auto-detected package manager | Skills declare CLIs; cue installs them via apt/brew/snap/pipx in one command | | 🔍 GitHub Code Search–powered discovery with profile-fit mapping | Finds repos that demonstrably contain SKILL.md, scored + categorized | | 🤖 LLM-drafted profile improvements from failure data | cue failures --propose reads recent session failures, asks Claude to draft concrete profile fixes | | 🌐 Per-profile SEO/GEO publishing with JSON-LD Schema.org | Nightly Action publishes discovered skills as a GitHub Pages site that AI search engines can cite |

Several tools touch parts of the problem — switching MCP configs, distributing skills, installing from marketplaces. cue is the only one that treats the full agent loadout (skills + MCPs + plugins) as a composable, inheritable, directory-aware profile system.

Quick links to each tool: claude-code-switcher · skillport · agent-skills-cli · agent-skill-manager · skillshub · add-skills · Kiro Powers (IDE-only).

| Tool | skills | MCPs | plugins | profiles | per-dir | isolation | inherit | |---|---|---|---|---|---|---|---| | cue | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | | claude-code-switcher | — | ✅ | — | ◐ | — | — | — | | skillport | ✅ | — | — | — | — | — | — | | agent-skills-cli | ✅ | — | — | — | — | — | — | | agent-skill-manager | ✅ | — | — | — | — | — | — | | skillshub | ✅ | — | — | — | — | — | — | | add-skills | ✅ | — | — | — | — | — | — | | Kiro Powers | ✅ | ✅ | — | — | ◐ | — | — |

Canonical source: docs/data/comparison.md.

Where cue is the only one:

1. .cue-profile per-directory pinning — cd into a repo, the right loadout loads automatically.
2. Materialized isolation — builds a real CLAUDE_CONFIG_DIR per profile, not just a config swap.
3. Hash-cached rebuilds — content-addressed sha256 check, <5 ms when unchanged.
4. Five dimensions as one unit — skills + MCPs + plugins + rules + commands + hooks + persona + playbooks + quality gates + evals composed together. Others manage one at a time.
5. Inheritance with merge semantics — core → backend → medusa-dev chains; child overrides parent cleanly. Persona is leaf-wins; everything else dedupes.
6. Shim-based interception — type claude like always. The right environment just shows up.
7. No daemon — pure CLI, no background process, nothing to monitor.
8. cue optimizer dashboard — visual audit of every profile's loadout, install status, and per-skill usage scanned from your actual session transcripts.
9. Failure feedback loop — cue failures --propose reads recent failure markers + asks Claude to draft profile improvements. Closes the learning loop without LLM-eval infrastructure.
10. Discovery + outreach engine — cue marketplace discover --cli-aware finds skill repos via GitHub Code Search, scores them, maps to your profiles, optionally posts meaningful PRs with full throttle/opt-out safety.

How it works

TL;DR — three steps on every claude/codex invocation: resolve the profile from .cue-profile (walks up to $HOME), materialize ~/.config/cue/runtime/<profile>/ if the content hash changed, then exec the real binary with CLAUDE_CONFIG_DIR / CODEX_HOME set.

Typing claude or codex in a repo where cue's shims are installed triggers a three-step launch flow:

1. Resolve — cue checks for a .cue-profile file in the current directory (or any parent up to $HOME). If none is found, it falls back to a repo-level default, a global default, or opens the TUI picker.
2. Materialize — cue builds ~/.config/cue/runtime/<profile>/{claude,codex}/ with a content-addressed hash check. If the profile hasn't changed, this is a no-op.
3. Exec — the real claude or codex binary is launched with CLAUDE_CONFIG_DIR (or CODEX_HOME) pointing at the materialized runtime tree.

sequenceDiagram
    participant U as You<br/>(type `claude`)
    participant S as ~/.local/bin<br/>shim
    participant R as cue<br/>resolver
    participant M as cue<br/>materializer
    participant C as Real<br/>claude binary

    U->>S: claude
    S->>R: cue launch claude
    R->>R: Walk up for .cue-profile<br/>or pick from TUI
    R->>M: Profile resolved
    M->>M: sha256(skills+mcps+plugins+...)
    alt Hash matches existing runtime
        M-->>C: exec — &lt;5 ms
    else Hash differs — rebuild
        M->>M: Symlink skills, write CLAUDE.md,<br/>merge hooks into settings.json
        M-->>C: exec — 50-200 ms
    end
    C->>U: Real Claude Code session<br/>w/ scoped CLAUDE_CONFIG_DIR

Full resolve-precedence rules and bypass paths: docs/launch.md.

Agents cue supports

TL;DR — 10 agents: Claude Code, Codex, Cursor, Cline, Gemini CLI, GitHub Copilot, Windsurf, Roo Code, Sourcegraph Amp, Aider. One profile.yaml materializes into each agent's native format (.cursorrules, .clinerules, ~/.gemini/skills/*.md, .github/copilot-instructions.md, etc.).

Originally built for Claude Code & Codex — now one profile, ten agents. The same profile.yaml (skills + MCPs) materializes into the exact format each agent expects.

cue materialize cursor --profile backend     # → .cursorrules + .cursor/mcp.json
cue materialize cline  --profile backend     # → .clinerules + cline_mcp_settings.json
cue materialize --all  --profile backend     # → all agents in this profile

| Agent | cue materialize command | What gets written | |---|---|---| | Claude Code | (default — uses shim) | ~/.config/cue/runtime/<profile>/claude/ | | OpenAI Codex | (default — uses shim) | ~/.config/cue/runtime/<profile>/codex/ | | Cursor | cue materialize cursor | .cursorrules · .cursor/mcp.json | | Cline | cue materialize cline | .clinerules · cline_mcp_settings.json | | Google Gemini CLI | cue materialize gemini | ~/.gemini/skills/*.md | | GitHub Copilot | cue materialize copilot | .github/copilot-instructions.md | | Windsurf | cue materialize windsurf | .windsurfrules · .windsurf/mcp.json | | Roo Code | cue materialize roo | .roo/rules/*.md · .roo/mcp.json | | Sourcegraph Amp | cue materialize amp | AGENTS.md · .amp/mcp.json | | Aider | cue materialize aider | .aider.conventions.md |

Each adapter writes skills + MCPs in the precise format that agent expects — Cursor's .cursorrules syntax, Gemini's per-skill markdown, Copilot's instruction file, etc. Same profiles, same skills, any agent. Switch from Claude Code to Cursor on the same repo without touching a single skill definition.

See src/commands/materialize.ts for the full flag set (--all, --profile, --dir, dry-run).

cue optimizer — see every loadout at a glance

TL;DR — cue optimizer prints a visual audit of every profile: skills loaded, MCP servers, required CLIs (install status ✅/❌), GitHub sources, and per-skill usage bars computed from your local session transcripts. No telemetry.

Run it once and you get a dashboard of every profile: skills (with per-session usage), MCP servers, required CLIs (with install status ✅/❌), GitHub sources, and brand icons.

What the optimizer scans for you:

• Every profile.yaml (inheritance resolved, * wildcards expanded)
• Each skill's frontmatter for allowed-tools and ## Prerequisites → required CLIs
• which <cli> for every CLI → install status per profile
• ~/.claude/projects/**/*.jsonl → per-skill usage counts across all sessions
• ~/skills-lock.json → which GitHub repo each skill came from

Terminal output

🐱 Recommended terminal: Kitty. cue's optimizer renders bar charts, gradients, brand glyphs, and inline images via the Kitty graphics protocol. It also works in WezTerm and Ghostty — but inside macOS Terminal or stock gnome-terminal you'll see the ASCII fallback (still readable, just less pretty).

cue optimizer                 # all profiles
cue optimizer backend         # just one
cue optimizer --expand        # expand grouped skills (useful for cybersecurity's 754)

A single profile, expanded

Each card shows what's actually loaded plus how often you've reached for each skill. The bar chart is computed from your local session transcripts — no telemetry leaves the machine.

🎯 The 35-profile catalog

One repo. 35 pre-built expert agents. Pin one with cue use <name> and claude launches with that profile's skills, MCPs, hooks, and commands materialized into a per-profile CLAUDE_CONFIG_DIR. Profiles inherit, so a focused profile like rust-cli gets rust-core's foundations + core's baselines for free.

cue list                      # show everything
cue auto-detect               # suggest the right one for cwd
cue use medusa-dev            # pin to current directory
claude                        # launches with that profile's loadout

🐢 Foundation

What every profile inherits, plus the diagnostic fallback.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🐢 core | Baseline shared by every cue profile — essentials only | 11 skills · 1 MCP · 4 cmds | cue use core | | 🦄 full | Diagnostic fallback profile that loads every local skill and MCP inherits core | 12 skills · 14 MCPs · 4 cmds | cue use full |

🐻 Backend & Languages

Language-scoped expert agents for API and systems work.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🐻 backend | APIs, webhooks, security review, CI, package, database, and deploy work inherits core | 23 skills · 2 MCPs · 4 cmds | cue use backend | | 🐍 python-api | Python API development — FastAPI, Django, Flask, SQLAlchemy, Alembic, pytest inherits core | 12 skills · 1 MCP · 4 cmds | cue use python-api | | 🐹 go-api | Go API development — net/http, gin/echo/chi, GORM, migrations, testing inherits core | 13 skills · 1 MCP · 4 cmds | cue use go-api | | 🦀 rust | General Rust development — async, serde, tracing, perf, docs, testing, releases inherits rust-core | 39 skills · 1 MCP · 8 cmds | cue use rust | | 🦀 rust-core | Foundation shared by every rust sub-profile — toolchain essentials, gates, discovery inherits core | 24 skills · 1 MCP · 8 cmds | cue use rust-core | | ⌨️ rust-cli | Rust command-line tools — clap, ratatui TUIs, snapshot testing, cross-platform releases inherits rust-core | 31 skills · 1 MCP · 8 cmds | cue use rust-cli | | 🕸️ rust-web | Rust web services — axum HTTP APIs, reqwest, sqlx, serde, tracing, container deploys inherits rust-core | 34 skills · 1 MCP · 8 cmds | cue use rust-web | | 🔗 rust-ffi | Rust foreign-function interface — Python (pyo3), Node (napi-rs), Kotlin/Swift (uniffi), C… inherits rust-core | 30 skills · 1 MCP · 8 cmds | cue use rust-ffi | | 🕸️ rust-wasm | Rust → WebAssembly — wasm-pack libraries, Trunk/Dioxus SPAs, no_std considerations inherits rust-core | 28 skills · 1 MCP · 8 cmds | cue use rust-wasm | | 🎮 rust-game | Rust game / simulation development — Bevy ECS, perf profiling, asset pipelines inherits rust-core | 28 skills · 1 MCP · 8 cmds | cue use rust-game | | 📟 rust-embedded | Rust on microcontrollers — probe-rs, embassy async, no_std patterns, cross-compile to… inherits rust-core | 28 skills · 1 MCP · 8 cmds | cue use rust-embedded |

🦋 Frontend & 3D

UI implementation, design, and graphics.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🦋 frontend | Frontend UI implementation, redesign, screenshots, testing, and visual polish inherits core | 21 skills · 1 MCP · 4 cmds | cue use frontend | | ▲ nextjs | Next.js full-stack — App Router, Server Components, API routes, Vercel deploy inherits frontend | 22 skills · 1 MCP · 4 cmds | cue use nextjs | | 🎲 threejs | Three.js 3D development — geometry, materials, shaders, animation, postprocessing, and… inherits core | 11 skills · 1 MCP · 4 cmds | cue use threejs |

🧊 Infra & Ops

Deploy targets and multi-agent orchestration.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | coolify | Coolify deploys, server config, app env vars, and CI inherits core | 17 skills · 3 MCPs · 4 cmds | cue use coolify | | hostinger | Hostinger DNS, domain, VPS, and hosting management inherits core | 16 skills · 3 MCPs · 4 cmds | cue use hostinger | | 🐺 fleet-control | Multi-agent orchestration, Colony coordination, OMX flows, and gx safety inherits core | 23 skills · 3 MCPs · 4 cmds | cue use fleet-control |

🔒 Security & Research

Specialized analysis profiles.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🔒 cybersecurity | Skills from mukul975/Anthropic-Cybersecurity-Skills + agentshield (agent config auditor) inherits core | 14 skills · 4 MCPs · 4 cmds | cue use cybersecurity | | 🦉 research | Source-backed lookup, extraction, keyword, browser, crate, and market research inherits core | 21 skills · 3 MCPs · 4 cmds | cue use research |

🎨 Media & Docs

Content, design, writing, and visual generation.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🦚 creative-media | Image, video, product asset, brand, and visual generation workflows inherits core | 23 skills · 3 MCPs · 4 cmds | cue use creative-media | | 🎬 video | Video and GIF analysis — frame extraction, audio transcription, and visual understanding via… inherits core | 12 skills · 1 MCP · 4 cmds | cue use video | | 🐝 docs-writer | Documentation, Markdown, PDF, Obsidian, and structured writing work inherits core | 19 skills · 3 MCPs · 4 cmds | cue use docs-writer | | 🎨 readme-writer | Beautiful README design with SVG diagrams — architecture flows, terminal mockups, and… inherits core | 13 skills · 1 MCP · 4 cmds | cue use readme-writer | | 💌 event-design | Event collateral design — wedding invitations, save-the-dates, programs, menus, place cards… inherits core | 14 skills · 1 MCP · 4 cmds | cue use event-design |

💰 Growth & Career

Marketing, trends, and career-shaped agents.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🦜 marketing | Marketing — copywriting, SEO, CRO, growth, channels, brand, awesome-list outreach, X/Twitter… inherits core | 19 skills · 7 MCPs · 4 cmds | cue use marketing | | 💰 affiliate | Affiliate marketing flywheel — 52 skills across research, content, SEO, landing pages… inherits core | 11 skills · 1 MCP · 4 cmds | cue use affiliate | | 📡 trendradar | TrendRadar — news aggregation, trend analysis, AI-powered filtering, and notification… inherits core | 13 skills · 2 MCPs · 4 cmds | cue use trendradar | | 💼 career | Job hunting, resume optimization, interview prep, salary negotiation, and career development inherits core | 17 skills · 1 MCP · 4 cmds | cue use career |

🦊 Verticals

Domain-specific bundles.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🦊 medusa-dev | Medusa v2 backend, storefront, admin, migration, and shop setup work inherits core | 23 skills · 3 MCPs · 4 cmds | cue use medusa-dev | | nvidia | NVIDIA cuOpt: routing, LP/MILP, GPU-accelerated optimization (12 skills) inherits core | 22 skills · 1 MCP · 4 cmds | cue use nvidia | | 🦅 ecc | Everything Claude Code patterns — code review, dev workflow, language-specific rules inherits core | 11 skills · 1 MCP · 7 cmds | cue use ecc |

🐆 Modes

Operating-mode profiles, not domain bundles.

| Profile | What it's for | Loadout | Pin it | |---|---|---|---| | 🐆 caveman-quick | Fast low-context edits, summaries, reviews, notes, and commit prep inherits core | 18 skills · 1 MCP · 4 cmds | cue use caveman-quick |

Uncategorized

Profiles not yet in the editorial category map — add them to scripts/gen-profile-catalog.ts.

| Profile | What it's for | |---|---| | 🔮 predict-everything | Multi-agent prediction & simulation — digital sandbox rehearsals, swarm intelligence, "what… |

Don't see a fit? Run cue auto-detect in your project for a suggestion, or cue ai "describe your stack" to scaffold a new profile from natural language. Canonical machine-readable list: docs/data/profiles.md. Total: 35 profiles generated by scripts/gen-profile-catalog.ts.

🛠️ Create your own profile in 30 seconds

cue new my-stack                              # scaffold profile.yaml

Edit the generated file:

# profiles/my-stack/profile.yaml
name: my-stack
icon: "🔧"
description: My custom dev environment
inherits: core                                # gets claude-mem, caveman, RTK, gbrain
skills:
  local:
    - review/code-review
    - meta/rtk-context-trim
mcps:
  - gbrain

Activate it:

cue use my-stack                              # pin to current directory
cue doctor --fix                              # verify everything resolves
claude                                        # launches with your loadout

Want to start from what's already in a project? cue init scans your repo and suggests a profile based on detected languages, frameworks, and config files.

🌐 cue share — community profiles

TL;DR — publish your profile as a GitHub Gist, browse what others have shared, install with one command.

cue share publish --profile backend           # upload to your GitHub Gists
cue share browse                              # see community profiles
cue share install <gist-id>                   # pull someone else's profile

Shared profiles include the full profile.yaml + metadata (skill count, MCP list, description). Browse profiles others have published, fork them, or use them as a starting point for your own.

Install

TL;DR — npm install -g cue-ai, then echo <profile> > .cue-profile in any repo. Idempotent. No daemon. Uninstall with install.sh --uninstall.

npm install -g cue-ai

That's it. Then in any project:

cd ~/projects/q4-launch
echo marketing > .cue-profile
claude

Other install paths (pick what you prefer):

| Path | Command | |---|---| | One-line script | curl -fsSL https://raw.githubusercontent.com/opencue/cue/main/get.sh \| bash | | Manual clone | git clone https://github.com/opencue/cue.git ~/Documents/cue && ~/Documents/cue/install.sh | | Per-OS bootstrap (agent-driven) | paste setup/macos.md · setup/linux.md · setup/windows.md into Claude Code |

install.sh --help lists --yes, --codex, --uninstall. Idempotent — safe to re-run.

What ships with each profile (the lean stack)

| Layer | What it does | |---|---| | claude-mem plugin | Passive observation capture; mem-search "topic" recalls across sessions | | caveman plugin | /caveman terse mode, /caveman-commit Conventional Commits | | RTK CLI hook | Filters shell output — 60-90% token savings on ls / git / cat | | gbrain MCP | Personal wiki with embeddings + backlinks | | excel-mcp / word-mcp | Native .xlsx / .docx read & write |

💰 Token savings stack

The combination of profile isolation + RTK + caveman compounds:

| Optimization | What it cuts | Savings | |---|---|---| | Profile isolation | Irrelevant skills/MCPs never loaded | 10–25× fewer context tokens | | RTK | Filters ls, git log, cat output before it hits the model | 60–90% per shell command | | Caveman mode | Terse responses, no filler | ~40% fewer output tokens | | Combined | All three together | $2.70 → $0.08/session typical |

rtk gain                      # see your cumulative RTK savings
cue cost                      # token budget for active profile

Want to run 2+ agents in parallel on one repo? Layer the optional Colony + gitguardex tier — see setup/parallel-agents.md. Skip it for solo work.

FAQ

cue is the only profile manager for Claude Code that composes skills + MCPs + plugins + rules + commands + hooks + persona + playbooks + quality gates + evals as one unit, scoped per-directory. Alternatives like skillport, agent-skills-cli, agent-skill-manager, and skillshub cover skills only. claude-code-switcher covers MCPs only. cue is also the only one with a built-in failure-feedback loop (cue failures --propose) that uses Claude to draft profile improvements from real session data.

Run cue marketplace discover --cli-aware --limit 30. cue uses GitHub Code Search for filename:SKILL.md (not keyword text search), so it surfaces repos that actually contain SKILL.md files instead of awesome-lists that just mention "claude". Each result is scored by signal quality (recency, skill format, MCP integration, fork-to-star ratio), mapped to your cue profiles by keyword overlap, and annotated with which CLIs it needs (and whether you have them installed locally). The terminal output shows skill count, stars, profile fit, and frictionless install status (✓ no new installs vs ⚠ 2/3 CLIs missing).

Three compounding optimizations cue ships:

1. Profile isolation — scope skills/MCPs/plugins per-directory instead of loading all 1,900+ globally. This alone cuts context by 10–25×.
2. Honest token math — cue eval --breakdown shows per-message cost (always-loaded) vs on-demand cost (lazy bodies). Most "skill" tokens are lazy; cue measures the real per-turn budget.
3. RTK shell-output filter + caveman terse-output mode — additional 60–90% reduction on ls/git/cat output and ~40% on output verbosity.

Combined: typical backend session drops from ~$2.70 → ~$0.08 (Sonnet 4.6). Run cue cost or cue eval --compare a b to measure.

Yes — cue introduces both as first-class profile fields. Add persona: (multi-line text injected at the top of CLAUDE.md as ## Your Expertise) to define who the agent is. Add playbooks: (markdown files under resources/playbooks/) for proven step-by-step protocols like ship-feature.md or triage-bug.md. The model consults playbooks when the user's request matches the playbook's trigger phrasing, and follows the steps in order instead of improvising. Examples ship with cue under profiles/core/, profiles/ecc/, and profiles/frontend/.

Run cue cli install --all --yes. cue extracts CLI dependencies from each skill's allowed-tools: frontmatter and ## Prerequisites section, looks each up in its recipe registry (resources/cli-recipes.json — ~50 tools), and runs the right install command for your OS. Auto-prefers apt on Debian/Ubuntu, snap for tools not in default apt (helm, terraform, kubectl), brew on macOS, pipx for Python CLI tools (isolated, ships its own pip). For tools that can't be auto-installed (ghidra, metasploit, splunk), it prints the official install URL.

Yes — cue is the only profile manager that materializes the same profile.yaml into each agent's native format. Run cue materialize cursor --profile backend to write .cursorrules + .cursor/mcp.json. Run cue materialize cline for .clinerules + cline_mcp_settings.json. cue materialize --all --profile backend covers every agent at once. Skills + MCPs are translated per-agent without modifying the source skill definition.

| | cue | skillport / agent-skills-cli / skillshub | Kiro Powers | |---|---|---|---| | Skills | ✅ | ✅ | ✅ | | MCPs | ✅ | — | ✅ | | Plugins | ✅ | — | — | | Per-directory profiles | ✅ | — | ◐ (IDE-only) | | Inheritance | ✅ (core → backend → medusa-dev) | — | — | | Persona / playbooks / quality gates / evals | ✅ (5 dimensions) | — | — | | Multi-agent (Cursor/Cline/Copilot/Gemini/etc.) | ✅ (10 agents) | Claude only | IDE-only | | CLI dependency installer | ✅ (cue cli install) | — | — | | SKILL.md linter + GitHub Action | ✅ | — | — | | Failure-feedback loop | ✅ (--propose) | — | — | | Daemon required | None | None | IDE process |

cue is the only one that treats agent expertise as a composable system.

No. cue doesn't touch the claude binary — it just intercepts the call via a one-line bash shim in ~/.local/bin/claude, sets CLAUDE_CONFIG_DIR to the materialized per-profile dir, and execs the real binary. Claude Code's own update mechanism still runs identically.

That's exactly the problem cue solves. ~/.claude/ is one global folder shared across every repo, so every session loads every skill, every MCP, and every plugin you've ever installed. The model burns tokens picking through irrelevant tools and frequently picks the wrong one. cue gives each project its own isolated CLAUDE_CONFIG_DIR materialized just-in-time — only what that project needs.

No. cue doesn't touch the claude binary — it just intercepts the call, sets CLAUDE_CONFIG_DIR, and execs the real binary at the end of the shim. Claude Code's update mechanism still runs the same way.