Skip to main content
skill CX Codex

cross-agent-delegation — Claude Code skill: what it does

cross-agent-delegation routes coding tasks across Claude, Kimi, and Codex using iCPG graph complexity metrics and Mnemos checkpoints.

MIT 122 installs ★ 713 updated 2026-10-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add alinaqi/maggy --skill cross-agent-delegation -a claude-code
Open on GitHub

What cross-agent-delegation does

This skill positions Claude Code as the central orchestrator for terminal AI utilities. You work strictly with Claude, while secondary CLI tools operate silently in the background. Task handoffs rely on a 0 to 10 complexity scale built across five axes: cyclomatic depth, consumer blast radius, security boundaries, transactional concurrency, and domain invariants.

Low-scoring work from 0 to 3 runs under headless Kimi. Mid-tier tasks scored 4 to 6 trigger Kimi followed by an automated Codex diff inspection. Any task landing between 7 and 10 stays inside Claude due to systemic risk. Modifications touching fewer than two files without sensitive tokens take an express shortcut straight to Kimi.

Context persistence relies on external mnemos and icpg binaries. Claude dumps the execution snapshot via mnemos checkpoint --force, invokes Kimi via Bash, and picks up changes via git diff and mnemos resume. Without kimi, codex, mnemos, and icpg present in your environment, the delegation pipeline halts.

What it helps with

  • Hand off bounded implementation tasks to headless Kimi
  • Run automated diff inspections via Codex stop hooks
  • Score code modification complexity against call graphs and security tags
  • Bridge task context across different CLI agents using Mnemos snapshots

Example prompts for the agent

  • Fix the typo in our utility helper and record the symbol updates in iCPG
  • Inspect the uncommitted diff with Codex auto-review after unit tests pass
  • Create a Mnemos checkpoint and route this isolated bugfix to Kimi

How to install cross-agent-delegation

1Skills CLI (Vercel)

npx skills add alinaqi/maggy --skill cross-agent-delegation -a claude-code

2Manually: put the files in place

~/.claude/skills/cross-agent-delegation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cross-agent-delegation/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cross-agent-delegation

How to install cross-agent-delegation in Claude Code?

Run npx skills add alinaqi/maggy --skill cross-agent-delegation -a claude-code in your terminal. The configuration installs to ~/.claude/skills/cross-agent-delegation/SKILL.md.

What does cross-agent-delegation do?

It orchestrates task handoffs between Claude Code, Kimi, and Codex. Claude evaluates work difficulty using structural code signals and delegates safe tasks to auxiliary CLI engines.

When does the system bypass delegation to keep tasks in Claude Code?

Work stays in Claude whenever you request direct handling, during cross-service updates, on production hotfix branches, or when any single risk dimension scores at high severity.

Source text

SKILL.md · MIT
---
name: cross-agent-delegation
description: Cross-agent task routing — Codex auto-review, Kimi delegation by complexity score (iCPG + Claude reasoning), iCPG + Mnemos mandatory for all agents
when-to-use: Always loaded when multiple AI CLI tools are available (Claude, Kimi, Codex)
user-invocable: false
effort: medium
---

# Cross-Agent Delegation

Claude Code orchestrates task routing to Kimi and Codex. The user interacts with Claude only — delegation happens behind the scenes.

---

## Tool Detection

At session start, detect available tools:

```bash
command -v kimi &>/dev/null && HAS_KIMI=true || HAS_KIMI=false
command -v codex &>/dev/null && HAS_CODEX=true || HAS_CODEX=false
```

---

## Codex Auto-Review (Stop Hook — Automatic)

When Codex is installed, a Stop hook reviews code after tests pass:

1. TDD loop check runs tests
2. `codex-auto-review.sh` runs Codex on the diff
3. Critical/High findings feed back to Claude (exit 2)
4. Clean reviews pass through (exit 0)

**Fully automatic.** No user or Claude action needed.

---

## Kimi Delegation (Claude Orchestrates)

When Kimi is installed and the task complexity is bounded, Claude delegates directly — the user does not need to run anything.

### Step 1: Score complexity, not file count

File count is a poor proxy for delegation risk. A 1-file change to an authz path is harder than a 12-file rename. Score the task on five dimensions, each 0-2, sourced from iCPG signals plus Claude's semantic reasoning:

| Dimension | 0 (low) | 1 (medium) | 2 (high) | Source |
|---|---|---|---|---|
| **Cyclomatic / surface depth** | <10 LOC, no branches | 10-50 LOC, ≤3 branches | 50+ LOC or nested control flow | iCPG `query_graph` over function bodies |
| **Fan-out (consumer blast radius)** | 0-2 callers | 3-10 callers | 11+ callers | iCPG `trace_path(<symbol>, mode=callers)` |
| **Crosses a security boundary** (SEC-006, auth, PII, RLS, org-scope, billing, payments) | None | Tangential | Direct read or write | iCPG SEC-* / R-063 tags + grep for `org_id`, `user_id`, `auth`, `pii` |
| **Concurrency / transactional** | Pure / sync | Async only | Locks, transactions, atomic claims, `FOR UPDATE`, `asyncio.Lock`, `session.begin` | iCPG concurrency flags + grep |
| **Domain invariants required** | None / well-documented inline | Some implicit (need to read 1-2 files) | Heavy (cross-doc, ADR-bound, RFC-bound) | Claude reasoning + iCPG ADR linkage |

```bash
# Auto-collect signals
icpg query blast <scope> --format json    # fan-out, async flags, sec tags
grep -rE "org_id|user_id|auth|pii"  <file>  # cheap sec heuristic if iCPG flags absent
grep -rE "asyncio.Lock|FOR UPDATE|session.begin" <file>  # concurrency heuristic
```

### Step 2: Sum → routing

| Total score | Route | Rationale |
|---|---|---|
| **0-3** | Kimi solo | Bounded surface, no security/concurrency/cross-doc concerns |
| **4-6** | Kimi → Codex auto-review (no user prompt) | Real risk, but not so high that we need full Claude context — Codex catches what Kimi might miss |
| **7-10** | Claude handles directly | Cross-cutting / security-critical / concurrency-heavy — needs full context |

### Step 3: Floor — trivial-case shortcut

To skip iCPG-query cost on truly trivial work:

```bash
# If <2 files changed AND no SEC/auth/PII/concurrency keyword in diff,
# → auto-Kimi without scoring.
FILES=$(git diff --name-only | wc -l)
HAS_RISK_KEYWORDS=$(git diff | grep -ciE "org_id|auth|pii|asyncio|FOR UPDATE|transaction|session\.begin" || true)
if [ "$FILES" -lt 2 ] && [ "$HAS_RISK_KEYWORDS" -eq 0 ]; then
  AUTO_KIMI=true
fi
```

This handles the trivial-rename / typo-fix case without paying the iCPG round-trip.

### When NOT to Delegate (overrides scoring)

- User explicitly asked Claude to do it
- Cross-service changes (API + frontend + database) — needs full context regardless of score
- Production hotfix on a release branch — cross-tool review latency is too high
- Score 7+ in any single dimension (one critical axis is enough to keep Claude in the loop)

### Step 4: Delegate via Bash

Claude writes a mnemos checkpoint, then runs Kimi headless:

```bash
# 1. Save current context to disk
mnemos checkpoint --force

# 2. Get context summary for Kimi
CONTEXT=$(mnemos resume 2>/dev/null)

# 3. Get constraints for target files
CONSTRAINTS=$(icpg query constraints <target-file> 2>/dev/null)

# 4. Run Kimi headless with full context
kimi --print -y -w . -p "
## Context (from mnemos checkpoint)
$CONTEXT

## Constraints (from iCPG)
$CONSTRAINTS

## Task
<specific task description>

## Rules
- Run tests after changes
- Record changes: icpg record --base main
- Write checkpoint when done: mnemos checkpoint --force
"
```

### Step 4: Read Results

After Kimi finishes, Claude:

```bash
# Read what Kimi did
mnemos resume          # Kimi's checkpoint
icpg status            # Kimi's recorded symbols
git diff               # Kimi's file changes
```

### When NOT to Delegate

- Security-sensitive code (auth, crypto, payments)
- Cross-service changes (API + frontend + database)
- Refactors that touch shared interfaces
- User explicitly asked Claude to do it

---

## iCPG — Mandatory for All Agents

Before ANY code change, Claude runs these (and includes results when delegating):

### Pre-Task Queries

```bash
# 1. Duplicate check — already done?
icpg query prior "<goal>"

# 2. Constraints — what invariants apply?
icpg query constraints <file-path>

# 3. Risk — is this symbol fragile?
icpg query risk <symbol-name>
```

### After Code Changes

```bash
icpg record --reason <id> --base main
icpg drift check
```

---

## Mnemos — Mandatory for All Agents

### At Task Start

```bash
mnemos add goal "<task description>"
```

### At Sub-Goal Boundaries

```bash
mnemos checkpoint
```

### At Task End (auto-handled by Stop hook)

```bash
mnemos checkpoint --force
```

### Context Transfer Between Tools

The checkpoint is the bridge. Claude writes it, Kimi reads it:

```bash
# Claude saves state
mnemos checkpoint --force

# Kimi (or Codex) reads state
mnemos resume
```

The checkpoint contains: goal, constraints, recent files, git state, fatigue level.

---

## Full Orchestration Flow

```
TASK ARRIVES (user tells Claude)
    |
    v
[1] Claude: icpg query prior "<goal>"     ← Already done?
[2] Claude: trivial-case shortcut         ← <2 files & no risk keywords?
    |
    +-- YES + Kimi installed -----> AUTO-KIMI (no scoring)
    |
    +-- NO ↓
    v
[3] Claude: score complexity (5 dims × 0-2, iCPG + reasoning)
    |
    +-- score 0-3   ----> KIMI SOLO PATH
    |   [a] mnemos checkpoint --force
    |   [b] kimi --print -y -p "..."
    |   [c] mnemos resume + git diff
    |   [d] Continue in Claude
    |
    +-- score 4-6   ----> KIMI + CODEX REVIEW PATH
    |   [a] mnemos checkpoint --force
    |   [b] kimi --print -y -p "..."
    |   [c] codex review --uncommitted    ← Auto-review the diff
    |   [d] If P0/P1 findings: re-prompt Kimi with findings
    |   [e] Once clean: continue in Claude
    |
    +-- score 7-10  ----> CLAUDE DIRECT PATH (full context)
    |
    v
[4] icpg query constraints <files>         ← Invariants
[5] icpg query risk <symbols>              ← Fragility
[6] mnemos add goal "<task>"               ← Track in memory
    |
    v
[7] IMPLEMENT (TDD: RED -> GREEN)
    |
    v
[8]  Stop: tdd-loop-check.sh               ← Tests pass?
[9]  Stop: codex-auto-review.sh            ← Codex reviews diff
[10] Stop: icpg-stop-record.sh             ← Record symbols
[11] Stop: mnemos-checkpoint.sh            ← Save memory
```

© alinaqi · MIT · alinaqi/maggy

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set61

The whole set →
shopify-apps shopify-apps guides Shopify app work with Remix, the Admin GraphQL API, and checkout extensions. Use it when building an app or extension for a Shopify store. CX Codex +1 273installs azure-cosmosdb Skill for Azure Cosmos DB work: partition key selection, consistency levels, change feed, and SDK patterns with TypeScript examples. Adds CRUD templates, hierarchical keys, and cross-partition query patterns to your IDE. CX Codex +1 269installs workspace Discovers workspace topology across multi-repo and monorepo setups, tracking API contracts and shared types for coding agents. CX Codex +1 198installs cpg-analysis cpg-analysis uses Joern CPG and CodeQL to inspect control flow, data flow, and taint paths. Built for deep refactoring work and security audits. CX Codex +1 175installs icpg icpg — a skill that tracks WHY code exists via a reason graph (ReasonNodes) backed by Design by Contract. Helps agents avoid duplicate work, understand code constraints, and detect when symbols drift from their original purpose. CX Codex +1 156installs mnemos mnemos — a skill that prevents data loss when the context window fills up and compacts. Structures working memory as a typed graph where goals and decisions persist, while less critical information compresses by policy. CX Codex +1 134installs maggy maggy is a Claude Code skill that brings GitHub Issues and Asana tickets into one inbox, starts a TDD run from a ticket, and prepares a daily competitor briefing. CX Codex +1 131installs polyphony polyphony gives every AI agent a separate Docker container and git branch, so parallel agents never step on each other's files. CX Codex +1 116installs

Project sponsors

Companies that keep this analytics open