cue — Discover, install, and organize Claude Code skills, MCP servers, and AI agent plugins

_{Last updated: 2026-05-24 · 336 tests passing · v0.5.0}

cue — Discover, install, and organize Claude Code skills, MCP servers, and AI agent plugins

The package manager for Claude Code, Codex, Cursor, and 7 other AI coding agents. Discover skills hidden in GitHub, install them per-directory, share one loadout across every agent — and cut per-message token cost by 10–25×. Open source. MIT.

Works with: → full matrix ↓

⚡ 60-second quickstart

npm install -g cue-ai                          # 1. install cue (Node 18+)

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 — wired into your agent instantly

claude                                         # 4. your agent now has that skill

Search → install → use. No config files to edit. No manual wiring. Works the same with codex, cursor, cline, gemini, and 5 other agents — one install, ten supported runtimes.

What is cue?

cue is an open-source profile manager and skill package manager for AI coding agents — Claude Code, OpenAI Codex, Cursor, Cline, Gemini CLI, GitHub Copilot, Windsurf, Roo Code, Sourcegraph Amp, and Aider.

It does three jobs that nothing else does together:

Discovers Claude Code skills on GitHub that don't show up on the front page — scans filename:SKILL.md, scores each repo on signal quality, and surfaces hidden gems.
Installs them per directory — every project gets its own profile of skills, MCPs, plugins, rules, and slash-commands; agents only load what the current project needs.
Treats a profile as an expert agent — not just a bag of tools, but a composable identity with persona, playbooks, quality gates, structural evals, and a data-driven failure-loop.

Built with Bun + TypeScript, distributed as the cue-ai package on npm, MIT-licensed.

Use cue when you want to

Find Claude Code skills that aren't on the front page of GitHub — cue discover search queries GitHub Code Search for filename:SKILL.md, scores results, maps each repo to a target profile.
Cut per-message Claude Code token cost by 10–25× — scope skills/MCPs/plugins per directory instead of loading every installed skill into every session.
Share one agent loadout across Cursor, Cline, Gemini CLI, and Copilot — one profile.yaml materializes into each agent's native config format (.cursorrules, .clinerules, ~/.gemini/skills/, .github/copilot-instructions.md, …).
Give your AI agent a persona and protocols — profiles ship with character + step-by-step playbooks, not just tools.
Block "done" claims with quality gates — Stop-hook validators auto-run tests, lint, and build before the agent can declare the task complete.
Install every CLI a profile's skills need in one command — cue cli install --all <profile> auto-detects apt / brew / snap / pipx / npm per OS.
Open safe, meaningful PRs on skill repos at scale — built-in 90-day per-repo cooldown, 25-PRs/day cap, and  opt-out marker.

cue by the numbers

10–25× token cost reduction · <5 ms warm launch · 0 daemons · MIT

Capabilities

	Count	Notes
Tests	336	lib + commands, green on every commit
AI agents supported	10	Claude Code · Codex · Cursor · Cline · Gemini CLI · Copilot · Windsurf · Roo Code · Sourcegraph Amp · Aider
Pre-built profiles	23	backend, frontend, cybersecurity, marketing, NVIDIA, creative-media, docs-writer + 16 more
Local skills	110+	vendored under `resources/skills/` (thousands more via `cue discover`)
Rules · Commands · Playbooks · Gates	38 · 15 · 2 · 1	curated from ECC + cue
CLI install recipes	~50	apt · brew · dnf · pacman · snap · pipx · npm · script · manual

Performance

	Value	Notes
Token cost reduction	10–25×	vs loading all skills globally
Per-message cost (`core`)	~587 tokens	~$0.0018/msg on Claude Sonnet 4.6
Launch overhead (warm)	<5 ms	sha256 cache hit
Launch overhead (cold)	50–200 ms	full rebuild
External services / daemons	0	pure CLI · no background process · no telemetry

Stack

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  opt-out marker.
cue is MIT-licensed, distributed as the cue-ai package on npm, built with the Bun TypeScript runtime.

🗂️ 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 per-message token cost by 10–25× because your agent stops loading skill descriptions for tools the current project doesn't use. The exact savings depend on how many skills you have installed globally (see Before & After — token cost below for a measured comparison on a real loadout). Discovery gets you started; profiles make it scale.

📑 Table of contents

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 — measured on a real loadout (backend profile, 24 skills) vs. the unmanaged baseline (a heavy ~/.claude/skills/ directory + every globally-installed MCP). Your model picks the right tool faster because it's not scanning irrelevant skill descriptions on every message; raw API spend drops accordingly.

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  in README are skipped permanently
Opt-in mode (--opt-in-only) — flip the consent model to require 
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).

📊 Same matrix as a markdown table (for screen readers / LLM ingestion)

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:

.cue-profile per-directory pinning — cd into a repo, the right loadout loads automatically.
Materialized isolation — builds a real CLAUDE_CONFIG_DIR per profile, not just a config swap.
Hash-cached rebuilds — content-addressed sha256 check, <5 ms when unchanged.
Five dimensions as one unit — skills + MCPs + plugins + rules + commands + hooks + persona + playbooks + quality gates + evals composed together. Others manage one at a time.
Inheritance with merge semantics — core → backend → medusa-dev chains; child overrides parent cleanly. Persona is leaf-wins; everything else dedupes.
Shim-based interception — type claude like always. The right environment just shows up.
No daemon — pure CLI, no background process, nothing to monitor.
cue optimizer dashboard — visual audit of every profile's loadout, install status, and per-skill usage scanned from your actual session transcripts.
Failure feedback loop — cue failures --propose reads recent failure markers + asks Claude to draft profile improvements. Closes the learning loop without LLM-eval infrastructure.
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:

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.
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.
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 (under 5 ms)
    else Hash differs — rebuild
        M->>M: Symlink skills, write CLAUDE.md,<br/>merge hooks into settings.json
        M-->>C: exec (50 to 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.

🐢 core 🐻 backend 🦋 frontend 🦀 rust 🔒 cybersecurity 🦊 medusa-dev 🦚 creative-media 🐆 caveman-quick

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

What is the best skill manager for Claude Code?

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.

How do I find Claude Code skills on GitHub?

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).

How do I reduce Claude Code's token cost?

Three compounding optimizations cue ships:

Profile isolation — scope skills/MCPs/plugins per directory instead of loading every installed skill into every session. This alone cuts context by 10–25× on a typical loadout.
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.
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.

Can Claude Code agents have personas or playbooks?

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/.

How do I install every CLI my Claude Code skills need?

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.

Can I use one Claude Code skill across Cursor, Cline, Copilot, and Gemini?

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.

What's the difference between cue, skillport, and Kiro Powers?

	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.

Does Claude Code's auto-update break cue?

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.

Why not just use ~/.claude/ like everyone else?

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.

Does this break Claude Code's auto-update?

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.

Can I use cue with only Codex (no Claude Code)?

Yes. Run cue shell install --codex-only (or skip the claude shim during interactive install). cue scopes resources per-agent in profile.yaml, so a Codex-only profile only materializes CODEX_HOME.

What if I only want one global profile and never want to think about this?

Set a global default with cue use <profile> --global. cue will use it for every directory that doesn't have its own .cue-profile. The picker stops appearing.

Is this a daemon or background service?

No. cue is a pure CLI — when you type claude, the shim runs cue launch, which does a stat() + sha256 compare, materializes the runtime if anything changed (else no-op), and then execs the real binary. Nothing stays resident. Nothing to monitor. Nothing to systemctl restart.

How fast is the launch overhead?

Cold start (first launch of a new profile): typically 50–200 ms depending on how many skills + MCPs are linked. Warm start (profile unchanged): <5 ms — just a sha256 compare and an exec. Both are imperceptible vs. Claude Code's own startup.

Does cue send telemetry anywhere?

No. Everything cue computes (including the per-skill usage bars in cue optimizer) is read from your local ~/.claude/projects/**/*.jsonl session transcripts. Nothing leaves the machine.

What does cue NOT do?

It does not modify or repackage the Claude Code / Codex binary.
It does not host a remote skill marketplace — skills live in your repo or come from open-source sources.
It does not coordinate multi-agent runs (that's recodeee/colony + gitguardex, layered on top via the parallel-agents tier).
It does not auto-pick a profile from repo contents — you pin once with echo <profile> > .cue-profile. (A scan-to-profile flow is on the roadmap.)

Repo layout

cue/
├── profiles/                one dir per profile, YAML decides what loads (inheritance, agent scoping)
├── resources/
│   ├── skills/              110+ local skills (medusa, codex-fleet, higgsfield, caveman, …)
│   ├── mcps/                MCP server configs (claude.sanitized.json, codex.sanitized.json)
│   ├── rules/               38 markdown rule files vendored from ECC (typescript, python, common, …)
│   ├── commands/            15 slash commands (code-review, checkpoint, cost-report, …)
│   ├── hooks/               4 universal safety hooks (bash-preflight, secrets-guard, session-summary, commit-message-guard)
│   ├── playbooks/           proven step-by-step protocols (ship-feature, triage-bug)
│   ├── quality-gates/       Stop-hook validators (tests-pass.sh — auto-detects bun/npm/pytest/cargo/go)
│   ├── evals/               structural eval scenarios for `cue eval-behavior`
│   ├── cli-recipes.json     per-tool install commands per OS (apt/brew/snap/pipx/npm/script/manual)
│   └── icons/               brand icons used in the optimizer dashboard
├── skill-md-lint-action/    drop-in GitHub Action for skill authors — runs lint-skill in CI
├── plugins/cue/             the Claude Code plugin: /cue, /cue switch, /cue reload, /cue current
├── src/                     the Bun CLI — commands/{optimizer,launch,eval,debug,cli,lint-skill,marketplace,discover,eval-behavior,failures,…}
├── setup/                   paste-into-agent install prompts (macos, linux, windows, parallel-agents)
├── .github/workflows/       discover-publish.yml (nightly per-profile SEO page generation)
└── docs/                    launch.md, shell-install.md, discovered/ (generated SEO pages), assets/ (the SVGs)

Full docs: docs/launch.md (resolve → materialize → exec flow) · docs/profiles/ (schema, inheritance, scan-to-profile, troubleshooting) · AGENTS.md (bootstrap contract for AI agents).

Built with / built on

cue glues together a small set of excellent open-source projects. Star counts are live from GitHub.

Runtime & dependencies (the CLI itself):

Project	What we use it for	Stars
oven-sh/bun	TypeScript runtime that ships `bin/cue`
natemoo-re/clack	`@clack/prompts` powers the TUI profile picker
ajv-validator/ajv	JSON Schema validation for `profile.yaml`
eemeli/yaml	YAML parsing for profile definitions

Built-in terminal integration:

Project	What we use it for	Stars
kovidgoyal/kitty	Kitty graphics protocol — inline brand logos & profile icons rendered directly in the terminal (see `src/lib/kitty-image.ts`, spec here). Auto-detected; falls back to emoji if you're not on Kitty.

Agents we shim:

Project	Role	Stars
anthropics/claude-code	The `claude` binary cue intercepts and re-launches with `CLAUDE_CONFIG_DIR`
openai/codex	The `codex` binary cue intercepts and re-launches with `CODEX_HOME`

Skill packs & sister tools:

Project	Role	Stars
mukul975/Anthropic-Cybersecurity-Skills	754 cybersecurity skills (red/blue team, forensics, DFIR) loaded by the `cybersecurity` profile
affaan-m/agentshield	🛡️ Security auditor for AI agent configs — scans `.claude/`, `settings.json`, `mcp.json`, hooks & agents for secrets, permission misconfigs, hook injection, MCP supply-chain risks, prompt-injection vectors. CLI / GitHub Action / ECC plugin. Loaded by `cybersecurity` and `backend` profiles.
recodeee/colony	Local-first MCP for multi-agent coordination — used by the `fleet-control` profile
recodeee/gitguardex	`gx` CLI for branch + worktree isolation when running 2+ agents on one repo
rtk-ai/rtk	Token-savings hook on shell output (60–90% reduction on `ls`/`git`/`cat`)
astral-sh/uv	Python venv manager used by `setup/<os>.md` to run uvx-based MCP servers (Excel / Word)

Plus the brand logos you see in the optimizer dashboard and hero come from each vendor's official press kit (OpenAI, NVIDIA, Hostinger, Coolify, Medusa, Stripe, Higgsfield, Obsidian) — see resources/icons/.

Who uses cue

Projects and teams using .cue-profile in production:

Project	Profile	What they do
opencue/cue	`full`, `readme-writer`	This repo — dogfooding cue on itself
recodeee/colony	`fleet-control`	Multi-agent coordination MCP
recodeee/gitguardex	`backend`	Branch + worktree isolation for parallel agents

Using cue? Add your project — open a PR or drop a link in Discussions.

Star History

Contributing

We welcome contributions! Here's how to get involved:

Add a skill

cue skills-new my-skill                       # scaffold template
# edit resources/skills/skills/<category>/my-skill/SKILL.md
cue skills-lint my-skill                      # check quality
cue skills-test my-skill                      # run tests

The frontmatter description is what the LLM matches against — write it as "when user says X, do Y". Copy an existing skill as a template.

Add a profile

cue new my-profile                            # scaffold profile.yaml
cue validate my-profile                       # check schema
cue score --profile my-profile                # verify efficiency

Other ways to contribute

Report bugs — open an issue
Share your profile — cue share publish --profile <name>
Add to the registry — PR to docs/registry/index.json
Improve docs — SVGs live in docs/assets/, edit XML directly
Add agent adapters — see src/lib/agent-adapters.ts

Development

git clone https://github.com/opencue/cue.git
cd cue && bun install
bun test                                      # 336 tests (lib + commands)
bun run src/index.ts --help                   # run locally

License: MIT.

Name		Name	Last commit message	Last commit date
Latest commit History 114 Commits
.claude/skills		.claude/skills
.github/workflows		.github/workflows
action		action
bin		bin
docs		docs
plugins/cue		plugins/cue
profiles		profiles
resources		resources
scripts		scripts
setup		setup
skill-md-lint-action		skill-md-lint-action
skills/cue-agent-profile-manager		skills/cue-agent-profile-manager
src		src
test		test
.cue-profile		.cue-profile
.gitignore		.gitignore
.gitmodules		.gitmodules
.npmignore		.npmignore
AGENTS.md		AGENTS.md
CITATION.cff		CITATION.cff
CLAUDE.md		CLAUDE.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
bun.lock		bun.lock
bunfig.toml		bunfig.toml
draft.md		draft.md
get.sh		get.sh
install.sh		install.sh
llms.txt		llms.txt
package.json		package.json
settings.json		settings.json
skills-lock.json		skills-lock.json

Folders and files

Latest commit

History

Repository files navigation

cue — Discover, install, and organize Claude Code skills, MCP servers, and AI agent plugins

⚡ 60-second quickstart

What is cue?

Use cue when you want to

cue by the numbers

Capabilities

Performance

Stack

🗂️ Then organize with profiles

🧠 Daily commands

📊 Before & After — token cost

Why a profile manager at all?

Profile inheritance

Skills are not just prompts

Profiles as expert agents, not toolboxes

The 5 dimensions

See it work

📦 System CLI installer

🌐 Discover + outreach

Find skills that didn't reach the front page

Publish per-profile pages for SEO + GEO

Open meaningful PRs (safely)

🔍 Quality control: SKILL.md linter + GitHub Action

Run locally on your own skills

Drop-in GitHub Action for skill authors

How cue compares

5 things only cue does

How it works

Agents cue supports

cue optimizer — see every loadout at a glance

Terminal output

A single profile, expanded

🎯 The 35-profile catalog

🐢 Foundation

🐻 Backend & Languages

🦋 Frontend & 3D

🧊 Infra & Ops

🔒 Security & Research

🎨 Media & Docs

💰 Growth & Career

🦊 Verticals

🐆 Modes

Uncategorized

🛠️ Create your own profile in 30 seconds

🌐 cue share — community profiles

Install

What ships with each profile (the lean stack)

💰 Token savings stack

FAQ

Repo layout

Built with / built on

Who uses cue

Star History

Contributing

Add a skill

Add a profile

Other ways to contribute

Development

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`cue optimizer` — see every loadout at a glance

🌐 `cue share` — community profiles

Packages