claudeers.
// Claude Skills

alethe-orchestrate-skill

Agent skill that orchestrates Codex, Claude Code, Antigravity, Kimi and custom CLI workers with playbooks that save context and quota, and reports what each…

// Claude Skills[ cli ][ api ][ claude ]#claude#skills◷ MIT$open-sourceupdated 26 days ago
Actively maintained
98/100
last commit 17 days ago
last release none
releases 0
open issues 2

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up alethe-orchestrate-skill (claude-plugin project) into my current project.
Found on https://claudeers.com/alethe-orchestrate-skill
Repo: https://github.com/Kc1t/alethe-orchestrate-skill
Homepage/docs: —
Detected install method: claude-plugin → /plugin install alethe-orchestrate-skill@Kc1t/alethe-orchestrate-skill
Category: skills. Platforms: cli, api.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
active; community-verified: false. Confirm the source before running anything.
// or install directly (claude-plugin)
/plugin marketplace add Kc1t/alethe-orchestrate-skill
/plugin install alethe-orchestrate-skill@Kc1t/alethe-orchestrate-skill
// or clone
git clone https://github.com/Kc1t/alethe-orchestrate-skill

// compatibility

Platformscli, api
Operating systems—
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguagePython

Get your FREE $2.50 API credits to access TickAtlas financial data ↗


Alethe logo

alethe-orchestrate

Orchestrate coding agents, and prove it was worth it.

English · Português (BR)

Install

npx skills add Kc1t/alethe-orchestrate-skill
Claude Code plugin, Codex plugin or by hand
/plugin marketplace add Kc1t/alethe-orchestrate-skill
/plugin install alethe-orchestrate@alethe
codex plugin marketplace add Kc1t/alethe-orchestrate-skill
codex plugin add alethe-orchestrate@alethe

Or copy skills/alethe into ~/.claude/skills/, ~/.codex/skills/ or ~/.agents/skills/.

Getting Started

  1. Install with the command above.
  2. /alethe setup checks which agent CLIs you have and whether they are logged in, lists their models, and proposes three profiles: base, savings and aggressive. Nothing is saved until you approve.
  3. /alethe always (optional) keeps it on in every project, so you never type /alethe again.
  4. Ask for the work: /alethe move the billing endpoints to v2, or just ask in plain words while it is on. The lead picks a playbook, previews the plan and runs the workers.
  5. /alethe status while it runs, /alethe stop to stop it.
  6. /alethe report when it is done: what each worker did, why, and what it cost. /alethe mark <worker> used records what you kept.

You ask your agent to orchestrate a refactor. The lead agent picks a playbook, writes the briefs and dry-runs the plan, then orchestrate.py runs one wave of workers: Claude Code on haiku, read-only; Codex at low effort, writing in its own worktree; Antigravity, read-only. They leave result.md, diff.patch and outcome.json while full transcripts stay on disk. The lead reads only the results, checks, integrates and marks them, runs the next wave, and finally writes the orchestration report

Commands

Type them after /alethe.

CommandWhat it does
setupChecks your CLIs and sets everything up
<task>Orchestrates the task
alwaysKeeps it on in every project
statusWhere it stands
stopStops the workers
reportWhat each worker did and cost
offTurns it off here

/alethe help lists the rest.

Keep It On

With always or on, every prompt reminds the lead of your goal and rules, and it decides per request whether to hand work off.

A conversation. The first message says /alethe from now on, be careful with the database, and the lead turns the mode on with careful and keeps the words as a rule. The next messages need no /alethe: a hook reminds the lead of the goal, care and rules each time. It fixes a typo itself because it is too small to hand off, orchestrates moving 40 endpoints with cheap scouts and writers in worktrees, and answers how is it going with a short status. It stays on for the project until /alethe off or 12 hours without a prompt

Join Mid-Task

It joins halfway through another skill's workflow: the spec and the diff so far become the plan.

A tasks.md from a spec-driven workflow with tasks 1 to 3 done. /alethe joins at task 4. The lead takes the spec and the diff so far as the plan and sends tasks 4 and 5 out: four Codex writers with one worktree per group, two Claude haiku workers fixing the tests, and the coupled part stays with the lead. Task 6, the review gate, stays with the original workflow, whose checks become the gates

Change Course

A playbook is a starting point. skip, add, switch and freeform change it between waves, and the report lists every change with its reason.

Top row, dashed: the scout-then-build playbook, scout, plan, build, review. Bottom row, what ran: scout, plan, a freeform wave to fix the build script because the bug was there, build, and review crossed out because the diff was three lines. The journal.jsonl records each change with its reason, and the report shows them under Changes to the plan

Playbooks

PlaybookUse it whenWhat it saves
directThe task is narrow and clear, up to about 3 filesAll orchestration overhead
cascadeA mechanical change with an automatic checkMost of the cost, while retries stay rare
scout-then-buildUnfamiliar code with much to read and little to writeYour context: scouts return summaries, not files
plan-big-execute-smallUp to about 10 independent reads, audits or checksThe strong tier only decomposes and synthesizes
audit-at-scaleDozens or hundreds of similar itemsThe volume runs on the cheap tier
parallel-worktreesIndependent modules with disjoint filesWall time, not tokens
plan-executeOne feature built in sequential stepsThe strong tier is billed only for planning
advisor-escalationA long mechanical task with a few hard callsA strong advisor only at decision points
best-of-nA hard, high-stakes fix worth several attemptsNothing: it buys reliability
review-gateA finished diff before mergeStrong review only on diffs worth reviewing
completeAnything else; the conditions decide per unitEach unit runs on the cheapest role that fits

Agents

AgentCLIRead-only workWritingResumeReports
alethe-orchestrate-skill
Claude Code
claudeplan permission modeacceptEdits✓Tokens and cost
alethe-orchestrate-skill
Codex
codexread-only sandboxworkspace-write sandbox✓Tokens
alethe-orchestrate-skill
Antigravity
agyplan modeaccept-edits mode✓Tokens
alethe-orchestrate-skill
Kimi Code
kimiContract, checked afterwardsPrompt mode, in its own worktree✓Nothing
alethe-orchestrate-skill
Any other CLI
your adapterContract, checked afterwardsIts narrowest write flagWhatever its output carries

Any other CLI with a non-interactive mode, such as Kiro, Copilot CLI or Gemini CLI, runs as a custom worker.

Why It's Different

  • Real spend, never estimated: tokens and cost as each CLI reported them, split between used and discarded results.
  • Enforced limits: budgets per wave and per orchestration, a hard cost cap on Claude workers, no subagents.
  • Never runs your quota dry: it reads Claude and Codex usage before every wave, refuses to start workers past a stop line, and asks you, with options, before it would spend past it.
  • Lean, checked workers: no MCP servers in Codex and Claude workers, and git catches a read-only worker that wrote.
  • Easy to audit: Python's standard library only, no shell, no network, no install scripts.

Two hand-drawn bar charts. Left: one Claude haiku worker on the same one-line task used 76,160 tokens and $0.16 with version 11, and 38,157 tokens and $0.08 with version 12. Right: in a real two-worker run, 5.0 KB of worker transcripts stayed on disk while the lead read 595 bytes of results

The Report

/alethe report html opens the same report as a page: a routing map from each wave through the lead to the providers it used, with each one's share of the tokens, then the workers and what is left to do.

Orchestration report

Check the report on real CLIs, playbook research, 1 wave, 2026-10-18 21:20 to 21:20

  • Result: 2 of 2 workers succeeded
  • Time: 16s running, 29s of worker time
  • Tokens: 108,820 reported, 65,836 of them from cache
  • Cost: $0.16 reported by claude; codex reports no cost
  • Lead context: 5.0 KB of worker transcripts stayed on disk, 595 B of results to read
WorkerRoleRan onModeStatusTimeTokensCost
claude-haikucheapest Claude model for a one-line answerclaude, haikureadsucceeded12s76,160$0.16
codex-lowdefault Codex model at low effortcodex, default model, lowreadsucceeded16s32,660-
Runner commands and files

Your agent runs these for you, from skills/alethe/scripts/orchestrate.py:

StageCommandWhat it does
Setupdoctor, playbook, editor, policy, modeChecks the CLIs, prints, shows or edits the playbooks and preferences, keeps it on
Planscaffold, validate, dry-runStarts, checks and previews a plan
Runnew, run --in current, budget, note, stopRuns the waves of one orchestration
Afterstatus, mark, report, list, useExplains and values what ran

The policy and your playbooks live in %APPDATA%\Alethe\ on Windows and ~/.config/alethe/ elsewhere, with one folder per orchestration under orchestrations/:

<folder>/
├── budget.json              limits for every wave, optional
├── 01-explore/
│   ├── state.json           the batch at a glance, live while it runs
│   ├── plan.json            the resolved plan, without task text
│   └── workers/<id>/
│       ├── prompt.txt       the brief the worker received
│       ├── result.md        its final answer
│       ├── outcome.json     status, failure kind, metrics, tripwire
│       ├── diff.patch       what a writer changed
│       ├── mark.json        used, partial or discarded, optional
│       └── stdout.log, stderr.log
└── 02-build/

Video

VideoWhat you will see
Stop Using One AI Agent at a Time: Orchestrate AI Agents Stop Using One AI Agent at a Time: Orchestrate AI Agents

A practical introduction to coordinating several AI coding agents, and to the git worktree isolation that keeps them out of each other's way.

Kauã Miguel - Dev · Portuguese

Example Playbook

scout-then-build: cheap read-only scouts map the code, then one worker writes the change. /alethe editor opens your own playbooks this way, as one offline page where you can switch profiles, simulate quota and edit a step, then copy the YAML back. It works without Python too.

The scout-then-build playbook as a flow: planner, four scouts, a checker when they disagree, planner, builder, and a fixer when checks fail

The YAML behind it
playbooks:
  scout-then-build:
    name: Scout, then build
    goal: Cheap read-only scouts map the code; one standard worker writes the change.
    pickWhen: Unfamiliar code with much to read and little to write.
    saves: Scouts hand back short summaries instead of raw files filling your context.
    avoidWhen: You already know which files change.
    next: review-gate
    phases:
      - id: brief
        role: planner
        who: lead
        tier: strong
        readOnly: true
        does: Name the areas to map and send one scout per area.
      - id: scout
        role: scout
        tier: cheap
        readOnly: true
        workers: 4
        runner: research
        does: One area per scout; keep each slice well under 100K tokens.
        returns: A summary under 1.5K tokens with file:line pointers.
        gate: The scout reports agree.
      - id: settle
        role: checker
        tier: standard
        effort: high
        readOnly: true
        runner: economy
        after: scout
        if: conflict
        then: recheck
        does: Settle only the contradiction, from the cited lines.
      - id: plan
        role: planner
        who: lead
        tier: strong
        readOnly: true
        does: Turn the summaries into one concrete change plan.
      - id: build
        role: builder
        tier: standard
        readOnly: false
        runner: economy
        does: Implement the plan.
        returns: Changed files, checks run, failures and risks.
        gate: Checks pass.
      - id: fix
        role: fixer
        tier: strong
        readOnly: false
        runner: economy
        after: build
        if: checks-failed
        then: recheck
        does: Fix from the failure excerpt and the diff.

License

MIT, see LICENSE. The Alethe name and logo and the vendor marks belong to their owners. Part of Alethe · Changelog · Issues

(back to top)

// faq

What is alethe-orchestrate-skill?

Agent skill that orchestrates Codex, Claude Code, Antigravity, Kimi and custom CLI workers with playbooks that save context and quota, and reports what each run did and cost.. It is open-source on GitHub.

Is alethe-orchestrate-skill free to use?

alethe-orchestrate-skill is open-source under the MIT license, so it is free to use.

What category does alethe-orchestrate-skill belong to?

alethe-orchestrate-skill is listed under skills in the Claudeers registry of Claude-compatible tools.

6 views
★ 135 stars
unclaimed
updated 26 days ago

// embed badge

alethe-orchestrate-skill on Claudeers
[![Claudeers](https://claudeers.com/api/badge/alethe-orchestrate-skill.svg)](https://claudeers.com/alethe-orchestrate-skill)

// retro hit counter

alethe-orchestrate-skill hit counter
[![Hits](https://claudeers.com/api/counter/alethe-orchestrate-skill.svg)](https://claudeers.com/alethe-orchestrate-skill)

// reviews

// guestbook

0/500

// related in Claude Skills

🔓

An agentic skills framework & software development methodology that works.

// skillsobra/⟨Shell⟩★ 314,126◷ MIT[ claude ]
🔓

Public repository for Agent Skills

// skillsanthropics/⟨Python⟩★ 188,182[ claude ]
🔓

AI coding assistant skill (Claude Code, Codex, OpenCode, Cursor, Gemini CLI, and more). Turn any folder of code, SQL schemas, R scripts, shell scripts, docs,…

// skillsGraphify-Labs/⟨Python⟩★ 149,064◷ MIT[ claude ]
🔓

💫 Toolkit to help you get started with Spec-Driven Development

// skillsgithub/⟨Python⟩★ 148,200◷ MIT[ claude ]
→ see how alethe-orchestrate-skill connects across the ecosystem