Announcing cmux Skills for agent-skills — fork, delegate & second-opinion for Multi-Agent Orchestration
Introduction
We have released three new skills for agent-skills, designed for the cmux terminal:
- cmux-fork — Fork your conversation with full context
- cmux-delegate — Delegate tasks to other AI agents
- cmux-second-opinion — Get independent reviews from different models
Key Takeaways
- Three new cmux skills added to agent-skills
- Solves the pain points of going from single-agent to multi-agent workflows
- cmux-fork / cmux-delegate / cmux-second-opinion — when to use which
- All install instantly via
npx skills add
Why We Built cmux Skills
Using a single AI coding agent works fine — until it doesn't. Once you start pushing for real productivity, three problems surface:
- Context fragmentation: Opening a new terminal means re-explaining everything from scratch
- Agent switching overhead: You want Claude Code for implementation, Codex for tests, Gemini CLI for review — but setting each up is tedious
- Review blind spots: Having the same model write and review code risks missing model-specific biases
agent-skills was originally released as a spec-driven development toolkit. These three new skills extend it into multi-agent orchestration, leveraging cmux's terminal CLI to solve the problems above.
How Does cmux-fork Enable Parallel Exploration?
cmux-fork splits your current Claude Code session into a new cmux pane or workspace, preserving the entire conversation context.
During development, you often want to explore an alternative approach without abandoning your current direction. Traditionally, this meant opening a new terminal and re-explaining all the context from scratch. With cmux-fork, it takes one command.
Usage
# Install
npx skills add anyoneanderson/agent-skills --skill cmux-fork -g -yAfter installation, simply use natural language in Claude Code:
> Fork this conversation
> Fork down
> Fork to a new workspace
By default, the pane splits to the right. You can specify downward splits or new workspaces:
| Command | Action |
|---|---|
Fork this conversation | Split right (default) |
Fork down | Split below |
Fork to a new workspace | Create new workspace and fork |
Forked sessions launch with --dangerously-skip-permissions by default, so you don't need to re-approve every tool. Say "fork with permissions" for interactive mode.
What Can cmux-delegate Do for Task Delegation?
cmux-delegate launches an AI agent in a separate cmux pane, sends it a task, monitors completion, and collects results. The key difference from cmux-fork is that you can delegate to different agents — Codex, Gemini CLI, not just Claude Code.
Supported Agents
| Agent | Auto-Approve Command | Interactive |
|---|---|---|
| Claude Code | claude --dangerously-skip-permissions | claude |
| Codex | codex --dangerously-bypass-approvals-and-sandbox | codex |
| Gemini CLI | (no auto-approve) | gemini |
Practical Example: Backend on Codex, Frontend on Claude Code
The real power of cmux-delegate is running different agents on their strengths simultaneously. For example, you keep implementing the frontend in Claude Code while delegating backend API work to Codex in a separate pane:
> Have Codex implement the /api/users CRUD
> Delegate test writing to Claude Code in another pane
> Have Gemini CLI review this design doc
How Is This Different from Built-in Multi-Agent Features?
Claude Code's Agent Teams and Codex's multi-agent both have sub-agent capabilities. However, they run in the background — you can't see what they're doing.
cmux-delegate is fundamentally different in two ways:
1. Visibility — Watch agents work in real time
Each delegated agent runs in a visible cmux pane or workspace. You can see the code being written, files being read, errors occurring — everything is happening right in front of you. No black boxes.
2. Interruptibility — Humans can intervene mid-task
Background sub-agents run to completion with no way to course-correct. Agents launched via cmux-delegate are independent terminal sessions. If you see things going sideways, you can switch to that pane, give corrective instructions, or Ctrl+C to stop it entirely.
The core advantage of cmux-delegate is "delegation with oversight." Instead of full autonomy, you maintain the ability to intervene — which is what makes it trustworthy in production workflows.
cmux-delegate automatically handles the full lifecycle:
- Creates a new workspace
- Launches the specified agent
- Sends the task prompt
- Polls for completion (graduated intervals: 5s → 10s → 30s)
- Collects results and reports back to the parent agent
Agents launched via cmux-delegate are fresh sessions — they don't inherit your conversation context. Use cmux-fork if you need context preservation.
How Does cmux-second-opinion Provide Cross-Model Reviews?
cmux-second-opinion sends your code or specifications to a different AI agent for an independent review.
Why Cross-Model Review Matters
Relying on a single AI model for code review risks missing that model's blind spots. cmux-second-opinion enables workflows like: develop with Claude Code → review with Codex or Gemini CLI — creating genuine diversity of perspective.
> Get a second opinion on this diff
> Have Codex review this code
> Second opinion on the specs
Review Modes
cmux-second-opinion supports three review criteria modes:
- Free review — Agent uses its own judgment
- coding-rules.md based — Review against project coding rules
- review_rules.md based — Review against dedicated review criteria
Installation & Prerequisites
Prerequisites
- macOS 14.0 or later
- cmux installed
- Running Claude Code inside a cmux session (
CMUX_SOCKET_PATHmust be set)
Install All Three Skills
npx skills add anyoneanderson/agent-skills --skill cmux-fork -g -y
npx skills add anyoneanderson/agent-skills --skill cmux-delegate -g -y
npx skills add anyoneanderson/agent-skills --skill cmux-second-opinion -g -yVerify Setup
# Run inside a cmux session
echo $CMUX_SOCKET_PATH
# → Should show a path like /tmp/cmux-xxxFAQ
Q. What's the difference between cmux-fork and cmux-delegate?
A. cmux-fork preserves your full conversation context in the forked session. cmux-delegate starts a fresh agent session for independent tasks. Use fork when you want shared context; use delegate for standalone tasks.
Q. Can I use these without cmux?
A. No. All three skills depend on cmux's CLI commands (cmux new-split, cmux send, etc.). You must run Claude Code inside a cmux session.
Q. Can I delegate to Codex or Gemini CLI?
A. Yes. cmux-delegate supports Claude Code, Codex, and Gemini CLI. cmux-second-opinion automatically selects a different agent from the parent for genuine cross-model review.
Q. Does this work on Windows or Linux?
A. Currently, cmux is macOS-only. These skills will work on other platforms when cmux adds support for them.
Summary
cmux-fork, cmux-delegate, and cmux-second-opinion transform multi-agent development on the cmux terminal.
- cmux-fork: Branch conversations for parallel exploration
- cmux-delegate: Offload tasks to different agents for parallel work
- cmux-second-opinion: Cross-model review for catching blind spots
Moving from "using one agent well" to "orchestrating multiple agents" is the next step in AI-powered development. agent-skills is open source — give it a try.