More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agentic Maestro

    1

    Delegate coding work to cheaper sub-agents without losing quality: precise briefs, independent review, one launcher for Claude Code, Codex and OpenCode.

    Free

    1 useSecurity scanned
    agentic-maestro

    agentic-maestro

    Example session with this skill installed

    Use agentic-maestro to add page-size limits to our export API. Delegate the build to a cheap executor on Codex, have Claude review it, and merge only if it passes.

    • Read your context and instructions
    • Compiled the agentic-maestro

    Plan — 1 lane, delegated (touches 3 files and needs tests, so a brief beats doing it inline)

    RulingExact semantics
    R1pageSize is an integer 1..500; anything else is refused with EXPORT_PAGE_TOO_LARGE (400), never clamped
    R2The bound is checked before the database query runs
    ContractexportRows(query) keeps its signature; existing error codes are unchanged

    Done means: 500 succeeds; 0 and 501 are refused; no query is issued for a refused request (counted with the query spy).

    Brief assembled and checked

    $ node scripts/brief.mjs F12.json --out .agent-briefs/F12-build-r1.md
    brief.mjs: wrote .agent-briefs/F12-build-r1.md (5.2 KB)
    

    It carries the shared rules, the two quoted conventions that apply, the Input and Tests checklist areas, one pattern excerpt (packages/import/src/limits.ts), the 3-file map and the per-package gates.

    Executor (Codex, cheap model, own worktree)

    $ node scripts/spawn.mjs --harness codex --effort high --brief .agent-briefs/F12-build-r1.md --dir ../wt-F12 --out .agent-runs/F12-build-r1
    spawn.mjs: codex ok exit=0 41s session=01a1539a-…
    

    Report block

    STATUS: done
    FILES: packages/export/src/limits.ts, packages/export/src/handler.ts, packages/export/test/limits.test.ts
    R1: done
    R2: done
    GATE pnpm --filter @app/export test: exit=0 passed=48 failed=0
    GATE pnpm --filter @app/export typecheck: exit=0
    CHECKLIST: ok
    BLOCKED: none
    

    Scope check before review: scope-check.sh ../wt-F12 3f2c1ab 'packages/export/' → exit 0, nothing outside the map. Committed as 9c41e07.

    Independent review (Claude, read-only) on 9c41e07: 1 finding.

    • P2 — limits.test.ts:31 tests 501 but not 0 →

    AGREE. Fix ruling: add the lower-bound test asserting EXPORT_PAGE_TOO_LARGE and zero queries.

    Fix round 1 (fresh executor, fix brief with the finding quoted): 1 test added, gates exit 0.

    Re-review in the reviewer's own session: PASS.

    Merged 9c41e07..b18d2aa into main. Ledger: 2 executor runs, 1 review + 1 re-review, 0 blocked questions.

    Next steps: regenerate docs/CODEMAP.md (a file was added), and add the clamping finding's category (input/clamp) to the project checklist if it shows up in a second feature.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Your strongest model shouldn't write every line. agentic-maestro turns it into a conductor: it plans, writes exact rulings, arbitrates review findings and merges, while cheaper sub-agents execute precise briefs and an independent reviewer checks every result.

    What you get:

    • When to spawn at all. A rule for when delegation pays and when the orchestrator should just do it inline.
    • Briefs instead of context. Templates for build, fix and integration briefs: exact rulings, a "done means" list, one pattern to copy, only the conventions that apply, and a fixed report block you can scan in seconds.
    • Fail-closed tooling. brief.mjs refuses a brief with a missing value or a convention keyword that matches nothing; scope-check.sh flags files changed outside the brief's map, even ones hidden by renames or git index flags.
    • One launcher for every agent. spawn.mjs runs Claude Code, Codex or OpenCode (v1 and v2) headless in write or read-only mode, resumes exact sessions, and records session id, exit code, tokens and cost per run.
    • A pipeline that converges. Independent review from a different model family, arbitration of every finding, a fresh executor per fix round, a structural ruling after three rounds on the same component, and a checklist that learns from recurring findings.
    • Parallel lanes on one machine. File ownership per lane, a lock for heavy checks, stacked branches and small merge batches.

    Measured on one large TypeScript monorepo (field notes, not a benchmark): 65–70% fewer tokens re-read by executors, about half the build time per feature, and fix rounds down from ~74 min to 10–25 min. Lean headless mode cut a one-line Claude Code run from $0.15 to $0.06.

    Works with Claude Code, Codex, OpenCode and any Agent Skills host. Requires Node.js 18+ and bash. Source and docs: https://github.com/Akramovic1/agentic-maestro

    Needs git and Node.js 18+; give each writing executor its own git worktree. Semantic merge conflicts between lanes are reported to the orchestrator, never auto-resolved. The code map lists exports only for JS/TS workspaces (other languages get a file-level map). The measured gains are field notes from one TypeScript monorepo, not a benchmark.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    Node.js 18+
    Bash
    Git
    Claude Code or Codex CLI or OpenCode
    Config MCP
    macOS
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Terminal: the scripts run git, node and the agent CLI you choose (claude, codex or opencode) in a working directory you pass. Read/Write files: briefs, run logs and reports are written inside your project (.agent-briefs, .agent-runs, .agent-logs), and executors edit only the files in their brief's map, ideally in a disposable git worktree. Network: the scripts make no network calls of their own; the agent CLIs they start talk to their own model providers with your existing login. No secrets read, nothing installed.

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    Each executor gets a brief with the exact files it may touch, works in its own git worktree, and reports anything the brief does not decide instead of guessing. Before any review, scope-check.sh lists every changed path outside that file map (including renames and files hidden by git index flags), so out-of-scope edits are caught and reverted or ruled on before they cost a review or reach main.

    The skill is fully compatible with Claude Code, Codex, and OpenCode. It requires a Node.js 18+ environment and a bash-compatible shell to execute the orchestration scripts and manage the parallel lanes.

    The SKILL.md playbook (when to spawn, writing briefs, running build -> review -> fix -> merge), three references (spawning on each harness, a pre-review checklist and how to grow it, operations for parallel lanes), brief templates for build, fix and integration rounds plus a Claude Code sub-agent definition, and helper scripts: brief.mjs (assembles and validates briefs), spawn.mjs (runs claude, codex or opencode headless and records each run), scope-check.sh, codemap.mjs, excerpt.sh, conv.sh and gate.sh. It is free and MIT-licensed.

    While the skill handles the parallelization and isolation of tasks, it does not automatically resolve semantic merge conflicts. If two sub-agents modify overlapping logic, the orchestrator will flag the conflict for manual intervention to ensure architectural integrity.

    After the executor's work is committed, a reviewer from a different model family reviews that exact commit with the original requirements, the brief's rulings, read access to the repository and explicit permission to challenge a ruling. It returns P1/P2/P3 findings with file:line and a verdict. The orchestrator agrees with each finding (with an exact fix ruling) or rejects it with a reason; a fresh executor applies the fixes, and the re-review resumes the reviewer's own session. Merges need passing gates on the exact commit and no open P1/P2 findings.

    New in Agents & Orchestration