Agent Collab Skills

English ・ 繁體中文

Pipeline overview: agent-task-splitter → codex-delegate / gemini-delegate / claude-in-session → agent-output-reconciler → agent-acceptance-gate, with agent-shared-memory and agent-debate as cross-cutting chips

6 Claude Code skills for context-safe multi-agent collaboration — task splitter, context budget, output reconciler, adversarial debate, shared memory, acceptance gate. Designed to compose with codex-delegate and gemini-delegate-skill.

📚 Part of the agentic AI learning roadmap — a 7-stage curated path for building agentic AI, multilingual (zh-TW · zh-CN · English). Multi-agent orchestration is covered in Stage 7.

A focused marketplace for the orchestration layer above delegation. Existing delegate skills solve "Claude → Codex / Gemini handoff." This catalog solves what comes next: how to split a goal across agents, how to reconcile their outputs, how to remember decisions across sessions, and how to gate merges.

Sister marketplace: ai-research-skills (13 skills for the research workflow).

⏱ Where the skills help most

Three high-leverage scenarios where these skills clearly pay off:

• Multi-locale mirror sync — delegate reads/writes the bulk, main session only consumes a short result summary. Largest saving in our usage.
• Mechanical sweeps in parallel — Codex handles batch edits / renames / refactors; the reviewer pattern catches drift before merge.
• Acceptance gate before commit — structured verdict from a subagent replaces hand-rolled grep × N checks, and the YAML presets have caught real drift the human audit missed.

Token measurements and incident logs are in docs/measured-benefits.md for the curious — but the practical takeaway is just the three scenarios above.

📋 When should I actually invoke which skill / preset? See docs/when-to-invoke.md — has the trigger rules, YES / NO / judgment-call scenarios, decision flowchart, and a copy-paste CLAUDE.md template you can drop into your own project to codify the rules.

Install

Prerequisite: Claude Code (https://claude.ai/code). Recommended (but not required): codex-delegate and gemini-delegate already installed via ai-research-skills, plus their CLI binaries on PATH.

claude plugin marketplace add WenyuChiou/agent-collab-skills
claude plugin install agent-collab-workspace@agent-collab-skills

This installs all 7 skills as one bundle. Verify:

claude plugin list
ls ~/.claude/skills/   # should include agent-task-splitter, etc.

Or use the helper script:

bash scripts/install-all.sh        # macOS / Linux / git-bash
pwsh scripts/install-all.ps1       # Windows PowerShell

Do I need to modify CLAUDE.md?

No. Claude Code's built-in skill matching reads each SKILL.md's description field and auto-routes user prompts. Plugin install is the only setup step — saying "split this across Claude, Codex, and Gemini" triggers agent-task-splitter without any extra configuration.

You may optionally add explicit routing rules to your ~/.claude/CLAUDE.md if you:

• already have a delegation protocol there that competes with these skills (e.g., a long-standing "always hand-write codex task files" rule that would otherwise win the routing race)
• want to enforce hard behaviors (e.g., "always run `agent-acceptance-gate` before merging any multi-agent round")

Otherwise leave CLAUDE.md alone — the skills are designed to work via description-based discovery.

The 7 skills

Numbering <NNN> matches the round field in plan.yml so artifacts trace back to the run that produced them.

How they compose

goal
  ↓ agent-task-splitter
.coord/plan.yml + .ai/codex_task_*.md / .ai/gemini_task_*.md
  ↓ agent-context-budget
.coord/context_<NNN>.md + .coord/session_primer.md
  ↓ codex-delegate / gemini-delegate (existing)
.ai/codex_log_*.txt + .result.json + codex_result_*.md
  ↓ agent-output-reconciler
.coord/reconciliation_<NNN>.md
  ↓ agent-acceptance-gate
.coord/acceptance_<NNN>.md → merge or retry

agent-shared-memory runs alongside the whole pipeline and stores accepted decisions, open questions, artifacts, and session outcomes. agent-context-budget keeps handoffs bounded so the main session does not absorb raw logs or full memory. agent-debate is invoked on consequential decisions (architecture, design choice), not in the main loop.

See docs/example-walkthrough.md for a worked example with real .coord/ sample artifacts produced by running the pipeline end-to-end against actual Codex + Gemini CLI invocations.

Why these 6 specifically

The pain points each one solves, in order:

1. Task splitting is mental load. You currently classify "is

this Codex-shaped or Gemini-shaped?" in your head every time. The splitter encodes the heuristics.

1. Context explodes during large runs. The context-budget skill

turns memory, logs, and agent outputs into bounded packets and a session primer.

1. Multi-agent output is hard to compare. When 3 Codex jobs come

back in parallel, you read 3 result.json files and merge them manually. The reconciler does the diff.

1. Consensus-driven LLM output hides trade-offs. When you ask one

agent for a design, you get one answer. The debate skill forces two agents to argue opposing positions.

1. Agent sessions don't share memory. Codex resume works

per-session; nothing persists across Claude session A → Codex session B → Gemini session C. Shared-memory makes .coord/memory.yml the cross-session blackboard.

1. No standardized merge gate. You currently eyeball the diff +

run pytest manually. The gate runs all success_criteria from plan.yml + cost budget + cross-agent consistency check.

Composes with

• codex-delegate —

consumes splitter output, produces input for reconciler.

• gemini-delegate-skill

— same.

• academic-writing-skills

— acceptance gate optionally calls its banned-word audit on prose changes.

• agentmemory —

optional recall cache only. .coord/memory.yml remains canonical; see docs/agentmemory-integration.md.

Known issues

• Gemini-cli refuses to read gitignored files. The .ai/

directory is conventionally gitignored to keep transient task files out of commits, but gemini -p "Read .ai/gemini_task_*.md" fails with file ignored by configured ignore patterns. Workaround: invoke gemini with the task content inlined into the prompt:

  TASK=$(cat .ai/gemini_task_<NNN>_<slug>.md)
  gemini -p "$TASK" --yolo \
    < /dev/null > .ai/gemini_log_<NNN>_<slug>.txt 2>&1

Side effect: gemini doesn't have file-system context for paths the task file references — make sure the prompt body itself contains all critical context, not just paths to read. The splitter skill's step 6b documents this.

• Both `codex` and `gemini` hang at startup if stdin is open.

When launching from a script or non-interactive shell, codex-cli ≥ 0.121.0 prints "Reading additional input from stdin..." and waits forever. Same for gemini-cli. Workaround: redirect stdin to /dev/null on every direct invocation:

  codex exec --full-auto -m <model> "<prompt>" \
    < /dev/null > .ai/codex_log_<NNN>_<slug>.txt 2>&1

The codex-delegate wrapper script handles this internally; only direct codex exec / gemini -p calls need the explicit redirect.

• Codex reads gitignored files normally — only gemini has the

gitignore conflict.

• Worked example with sample .coord/ artifacts and honest

documentation of what real multi-agent runs look like: docs/example-walkthrough.md.

Status & License

MIT. Early-stage — the SKILL.md prompt scaffolding is complete and tested in real workflows; please file issues if a skill misfires or the .coord/ schema breaks under your use case.

Contributions welcome — see CONTRIBUTING.md for the catalog ↔ delegate-skill interop rules.