orchestrator-bootstrap

An Agent Skill that turns any repository into a multi-agent workspace, adapted to that repository.

It scans the project first (stack, existing skills, agents, MCP servers, test and lint commands, conventions), then generates project-local Orchestrator, Planner, Coder and Designer agents for the AI tool you are using: Claude Code, Codex, GitHub Copilot, or a generic fallback. After that, the same skill runs day-to-day work through those agents.

Why

Copy-pasted agent prompts drift away from the codebase they are meant to serve. They list tools that aren't installed, run test commands that don't exist, and pin model names that are already outdated. This skill takes the opposite approach:

• Evidence over assumption. Versions come from lockfiles, conventions come from real files, and model names come from the live host. Anything that can't be verified is reported, not guessed.
• Reuse before generating. Existing agents, skills and MCP servers are wired into the orchestration instead of being duplicated or shadowed.
• Regenerable. Every generated file records its source, date and models. Re-running bootstrap refreshes the files and keeps your edits below a <!-- LOCAL CUSTOMIZATIONS (preserved) --> marker.

How it works

Bootstrap mode

1. Detect the host tool (Claude Code, Codex, Copilot/VS Code, other) and verify its current file formats.
2. Scan the project, read-only, and produce a scan report: stack, existing AI assets, MCP servers, conventions, parallelization capabilities, and anything it could not determine.
3. Plan the adaptation: what to reuse, which roles the project actually needs (a backend-only repo may skip the Designer), which model each role gets, and where the files go.
4. Generate the agents from the bundled templates, filling in the project's real stack and its test and lint commands.
5. Report the files created, adapted and skipped, plus open questions.

Orchestrate mode

For a feature or bug request, the Orchestrator gets a plan from the Planner, splits it into phases by file overlap, and runs independent tasks in parallel by default. Sequential execution needs a stated reason: file overlap, a data dependency, or an approval gate. Each phase picks the lightest execution backend that fits:

Situation	Backend
Non-overlapping files	Parallel subagents
Research, docs, impact analysis	Parallel subagents (always)
Test suites, builds, lint	Background tasks
Independent features that touch the same files	One git worktree and one agent per task
Deterministic pipelines	The project's existing CI

Safety rails: one writer per file per phase, a concurrency cap (3 by default), no parallel lockfile, codegen or schema changes, and a mandatory verification phase with the project's real test and lint commands.

Model policy

No model names are hardcoded. At bootstrap time the skill lists the models the host actually offers and assigns them by role: the strongest reasoning model goes to the Orchestrator and Planner, the strongest coding model to the Coder, and the strongest multimodal model to the Designer. "Refresh" lists them again.

Install

Claude Code (personal skill):

git clone https://github.com/chicojunior/orchestrator-bootstrap.git
cp -r orchestrator-bootstrap/orchestrator-bootstrap ~/.claude/skills/

Then, inside any project, ask: "bootstrap this project with the orchestration skill". Claude Code gets subagents in .claude/agents/ and a project skill in .claude/skills/orchestrator/.

Codex, GitHub Copilot and other tools: agent-file formats change often, so the skill checks the host's current documentation at bootstrap time (see references/tool-adapters.md). The universal fallback is an AGENTS.md or agents/ORCHESTRATION.md at the repository root, with each role as a section.

Structure

orchestrator-bootstrap/
├── SKILL.md                         # entry point: bootstrap + orchestrate modes
└── references/
    ├── project-scan.md              # read-only scan checklist
    ├── tool-adapters.md             # where files go for each host tool
    ├── orchestration-protocol.md    # phases, parallel-first rules, worktrees, safety rails
    └── agent-templates/
        ├── orchestrator.template.md
        ├── planner.template.md
        ├── coder.template.md
        └── designer.template.md

Credits

Inspired by Burke Holland's Ultralight Orchestration agents for GitHub Copilot. This project generalizes that idea into a bootstrap step that scans the project, works across several host tools, resolves models at runtime, and adds parallel execution backends.

License

MIT © 2026 Francisco Vale