orchestra-agents 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kirk Kodre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# Orchestra
+
+A multi-agent system in one file. One conductor agent takes your goal, breaks it into independent tasks, fans out specialist sub-agents in parallel (scouts, analysts, writers), sends adversarial critics to attack their work, then synthesizes everything into one final deliverable.
+
+Built on the Claude API (`@anthropic-ai/sdk`). No framework. This is the "main agent talks to a bunch of sub-agents" pattern, owned end to end in plain JavaScript you can read in one sitting.
+
+## Install
+
+```
+git clone https://github.com/vyn-store/orchestra-agents.git
+cd orchestra-agents
+npm install
+```
+
+Auth: set the `ANTHROPIC_API_KEY` env var or copy `.env.example` to `.env` and paste your key.
+
+## Run it
+
+```
+node orchestra.mjs "your goal here"
+node orchestra.mjs "research the AI voice receptionist market for law firms and write me a one-page pitch" --agents 5 --web
+node orchestra.mjs "quick test" --cheap        # haiku everywhere, costs pennies
+```
+
+| Flag | What it does |
+|---|---|
+| `--agents N` | max sub-agents the conductor may cast (default 5) |
+| `--web` | scouts get live web search (server-side tool, Opus/Sonnet 4.6+) |
+| `--cheap` | haiku-4-5 for everything (smoke tests) |
+| `--model M` | conductor + synthesis model (default claude-opus-4-8) |
+| `--worker M` | sub-agent model (default: same as --model) |
+| `--no-critics` | skip the adversarial pass |
+
+## How it works (the 4 phases)
+
+1. **PLAN**: the conductor gets the goal and returns a structured JSON plan (enforced by the API's structured outputs, so it can never come back malformed): a strategy plus one self-contained prompt per sub-agent.
+2. **EXECUTE**: sub-agents run in parallel (concurrency-capped). Each gets ONE role system prompt from `roles.mjs`: scout finds facts, analyst reasons, writer produces the deliverable.
+3. **CRITIQUE**: one adversarial critic per result, prompted to assume the work is wrong until proven right. Returns a structured score + fixes.
+4. **SYNTHESIZE**: the conductor merges everything, applies the critics' fixes, drops anything scored under 5, and streams the final deliverable live to your terminal.
+
+Every run prints a cost meter (real token counts x current pricing) and saves a full transcript to `runs/`.
+
+## Why it's built this way
+
+- **Independent context per sub-agent**: critics that never saw the original reasoning refute better.
+- **Structured outputs, not prompt-and-pray**: the plan and verdicts are schema-enforced by the API.
+- **The orchestrator is plain code**: casting, thresholds, and loops live in JS; agents discover, code decides.
+- **Cost is visible**: you see every dollar as it happens.
+
+## Two engines, same orchestra
+
+| | `orchestra.mjs` | `orchestra-max.mjs` |
+|---|---|---|
+| Runs on | Anthropic API (your key) | **Your Claude subscription** (headless Claude Code) |
+| Costs | API credits per token | $0 credits; counts against your plan's usage limits |
+| Speed | Faster per agent | Slower per agent (each is a full Claude Code session) |
+| Web for scouts | Server-side web search | Claude Code's WebSearch/WebFetch tools |
+| When to use | Client demos / production | Your own daily runs, anything personal |
+
+Same flags on both. If your API credits are empty, `orchestra-max.mjs` keeps working. It needs [Claude Code](https://claude.com/claude-code) installed and logged in, nothing else.
+
+## Customize it
+
+The whole system is three small files:
+
+- `orchestra.mjs`: the conductor, the phases, the cost meter.
+- `orchestra-max.mjs`: same conductor, but every sub-agent is a `claude -p` session.
+- `roles.mjs`: the sub-agent system prompts. Add your own roles here (a coder, a translator, a fact-checker) and the conductor can cast them.
+
+## License
+
+MIT

package/orchestra-max.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+// ORCHESTRA MAX — the same multi-agent orchestra, running on your Claude
+// subscription instead of API credits. Every sub-agent is a headless Claude
+// Code session (`claude -p`), authenticated by your Claude Max login.
+// Zero API credits used. Usage counts against your Max plan limits instead.
+//
+//   node orchestra-max.mjs "your goal here"
+//   node orchestra-max.mjs "your goal" --agents 4 --web
+//   node orchestra-max.mjs "your goal" --cheap          (haiku everywhere)
+//
+// Flags:
+//   --agents N   max sub-agents the conductor may cast (default 5)
+//   --web        scouts may use WebSearch/WebFetch (Claude Code built-in tools)
+//   --cheap      haiku for everything (fast smoke tests)
+//   --model M    conductor + synthesis model (default: opus)
+//   --worker M   sub-agent model (default: sonnet - lighter on plan limits)
+//   --no-critics skip the adversarial pass
+//
+// Requires: the `claude` CLI logged in to your subscription. No API key needed
+// (an ANTHROPIC_API_KEY in the environment is deliberately stripped so runs
+// can never silently bill your credit balance).
+
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import { ROLES } from "./roles.mjs";
+
+const run = promisify(execFile);
+const DIR = path.dirname(fileURLToPath(import.meta.url));
+const AGENT_HOME = path.join(DIR, "agent-home"); // empty cwd so agents don't inherit a project CLAUDE.md
+fs.mkdirSync(AGENT_HOME, { recursive: true });
+
+// ---------- config ----------
+const args = process.argv.slice(2);
+const flag = (n) => args.includes(n);
+const opt = (n, d) => {
+  const i = args.indexOf(n);
+  return i !== -1 && args[i + 1] ? args[i + 1] : d;
+};
+const valueFlags = ["--agents", "--model", "--worker"];
+const GOAL = args.filter((a, i) => !a.startsWith("--") && !valueFlags.includes(args[i - 1])).join(" ").trim();
+
+const CHEAP = flag("--cheap");
+const CONDUCTOR_MODEL = CHEAP ? "haiku" : opt("--model", "opus");
+const WORKER_MODEL = CHEAP ? "haiku" : opt("--worker", "sonnet");
+const MAX_AGENTS = parseInt(opt("--agents", "5"), 10);
+const USE_WEB = flag("--web");
+const USE_CRITICS = !flag("--no-critics");
+const CONCURRENCY = 3;
+
+// ---------- helpers ----------
+const C = { dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", bold: "\x1b[1m", reset: "\x1b[0m" };
+const log = (color, tag, msg) => console.log(`${C[color]}${C.bold}[${tag}]${C.reset} ${msg}`);
+
+const usage = { calls: 0, in: 0, out: 0, nominal: 0 };
+
+// One headless Claude Code session = one agent. Retries once on transient
+// failures (the API SDK auto-retries overloads; execFile does not, so we do).
+async function claudeAgent({ prompt, system, model, tools = [] }, attempt = 1) {
+  const cliArgs = ["-p", prompt, "--output-format", "json", "--model", model];
+  if (system) cliArgs.push("--append-system-prompt", system);
+  if (tools.length) cliArgs.push("--allowedTools", tools.join(","));
+  const env = { ...process.env };
+  delete env.ANTHROPIC_API_KEY; // force subscription auth, never credits
+  try {
+    const { stdout } = await run("claude", cliArgs, { cwd: AGENT_HOME, env, maxBuffer: 32 * 1024 * 1024, timeout: 15 * 60 * 1000 });
+    const res = JSON.parse(stdout);
+    if (res.is_error) throw new Error(res.result || res.subtype || "agent errored");
+    usage.calls += 1;
+    usage.in += (res.usage?.input_tokens || 0) + (res.usage?.cache_creation_input_tokens || 0) + (res.usage?.cache_read_input_tokens || 0);
+    usage.out += res.usage?.output_tokens || 0;
+    usage.nominal += res.total_cost_usd || 0;
+    return res.result || "";
+  } catch (e) {
+    // Surface the REAL failure, not just "Command failed: <2000 chars of argv>"
+    const detail = [e.stderr, e.stdout].filter(Boolean).map((s) => String(s).slice(0, 400)).join(" | ");
+    const reason = detail || String(e.message || e).slice(0, 200);
+    if (attempt < 2) {
+      log("yellow", "retry", `agent call failed (${reason.slice(0, 120)}), retrying in 5s...`);
+      await new Promise((r) => setTimeout(r, 5000));
+      return claudeAgent({ prompt, system, model, tools }, attempt + 1);
+    }
+    throw new Error(reason);
+  }
+}
+
+// Tolerant JSON extraction (headless output is prompted JSON, not schema-enforced).
+function parseJson(text) {
+  const cleaned = text.replace(/```json|```/g, "").trim();
+  const start = cleaned.indexOf("{");
+  const end = cleaned.lastIndexOf("}");
+  if (start === -1 || end === -1) throw new Error("no JSON object in agent output");
+  return JSON.parse(cleaned.slice(start, end + 1));
+}
+
+async function pool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function runner() {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i).catch((e) => ({ error: String(e.message || e) }));
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runner));
+  return results;
+}
+
+// ---------- phases ----------
+async function plan(goal) {
+  const text = await claudeAgent({
+    model: CONDUCTOR_MODEL,
+    system: `You are the conductor of a multi-agent team. You never do the work yourself. You decompose the user's goal into at most ${MAX_AGENTS} INDEPENDENT tasks and assign each to a specialist (scout = finds facts, analyst = reasons and compares, writer = produces the deliverable). Tasks run in parallel and must not depend on each other. Every prompt must be fully self-contained.`,
+    prompt: `Goal: ${goal}\n\nReply with ONLY a JSON object, no prose, no code fences: {"strategy": "<one short paragraph>", "tasks": [{"role": "scout|analyst|writer", "title": "<max 6 words>", "prompt": "<complete self-contained prompt>"}]}`,
+  });
+  const p = parseJson(text);
+  p.tasks = (p.tasks || []).slice(0, MAX_AGENTS);
+  return p;
+}
+
+async function runWorker(task, i) {
+  const tools = USE_WEB && task.role === "scout" ? ["WebSearch", "WebFetch"] : [];
+  log("cyan", `agent ${i + 1}`, `${task.role}: ${task.title}${tools.length ? " (web on)" : ""}`);
+  const output = await claudeAgent({
+    model: WORKER_MODEL,
+    system: ROLES[task.role] || ROLES.analyst,
+    prompt: task.prompt,
+    tools,
+  });
+  log("green", `agent ${i + 1}`, `${task.title} done`);
+  return { ...task, output };
+}
+
+async function runCritic(result, i) {
+  const text = await claudeAgent({
+    model: WORKER_MODEL,
+    system: ROLES.critic,
+    prompt: `The team's goal: ${GOAL}\n\nA ${result.role} agent was asked: ${result.prompt}\n\nIt produced:\n\n${result.output.slice(0, 12000)}\n\nAttack this work. Reply with ONLY a JSON object, no prose, no code fences: {"score": <1-10>, "verdict": "<one sentence>", "fixes": ["<fix>", ...]}`,
+  });
+  const crit = parseJson(text);
+  const color = crit.score >= 7 ? "green" : crit.score >= 5 ? "yellow" : "red";
+  log(color, `critic ${i + 1}`, `${result.title}: ${crit.score}/10, ${crit.verdict}`);
+  return crit;
+}
+
+async function synthesize(goal, strategy, results) {
+  const dossier = results
+    .map((r, i) => `## Agent ${i + 1} (${r.role}): ${r.title}\nCritic verdict: ${r.crit ? `${r.crit.score}/10, ${r.crit.verdict} Fixes: ${(r.crit.fixes || []).join("; ") || "none"}` : "not critiqued"}\n\n${r.output}`)
+    .join("\n\n---\n\n");
+  return claudeAgent({
+    model: CONDUCTOR_MODEL,
+    system: ROLES.synthesizer,
+    prompt: `The goal: ${goal}\n\nThe strategy was: ${strategy}\n\nHere is everything the team produced, with critic verdicts:\n\n${dossier}\n\nProduce the final deliverable. Apply the critics' fixes. Drop anything scored under 5.`,
+  });
+}
+
+// ---------- main ----------
+if (!GOAL) {
+  console.log('Usage: node orchestra-max.mjs "your goal" [--agents N] [--web] [--cheap] [--model M] [--worker M] [--no-critics]');
+  process.exit(0);
+}
+
+console.log(`\n${C.bold}ORCHESTRA MAX${C.reset} ${C.dim}subscription-powered · conductor=${CONDUCTOR_MODEL} workers=${WORKER_MODEL} max-agents=${MAX_AGENTS}${C.reset}\n`);
+log("yellow", "goal", GOAL);
+
+const t0 = Date.now();
+log("cyan", "conductor", "planning...");
+const p = await plan(GOAL);
+log("green", "conductor", `strategy: ${p.strategy}`);
+log("green", "conductor", `casting ${p.tasks.length} sub-agents`);
+
+const slug = GOAL.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50).replace(/^-|-$/g, "");
+const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+const runFile = path.join(DIR, "runs", `${stamp}_${slug}.md`);
+let ok = [];
+let final = null;
+let runError = null;
+
+function saveRun() {
+  const header = `# ${GOAL}\n\n_${new Date().toISOString()} · ORCHESTRA MAX (subscription) · conductor ${CONDUCTOR_MODEL} · workers ${WORKER_MODEL} · ${usage.calls} calls · $0.00 credits (nominal value $${usage.nominal.toFixed(2)})_\n`;
+  const errNote = runError ? `\n> ⚠️ Run ended early: ${runError}\n` : "";
+  const finalSection = final ? `\n## Final deliverable\n\n${final}\n` : "";
+  const agents = ok.length
+    ? `\n## Agent outputs\n\n${ok.map((r, i) => `### Agent ${i + 1} (${r.role}): ${r.title}\n${r.crit ? `_Critic: ${r.crit.score}/10, ${r.crit.verdict}_\n` : ""}\n${r.output}`).join("\n\n")}\n`
+    : "";
+  fs.writeFileSync(runFile, `${header}${errNote}${finalSection}\n---\n\n## Strategy\n\n${p.strategy}\n${agents}`);
+}
+
+try {
+  const results = await pool(p.tasks, CONCURRENCY, runWorker);
+  ok = results.filter((r) => !r.error);
+  results.filter((r) => r.error).forEach((r) => log("red", "agent", `failed: ${r.error}`));
+  saveRun();
+
+  if (USE_CRITICS && ok.length) {
+    log("cyan", "critics", `attacking ${ok.length} results...`);
+    const crits = await pool(ok, CONCURRENCY, runCritic);
+    ok.forEach((r, i) => (r.crit = crits[i]?.error ? null : crits[i]));
+    saveRun();
+  }
+
+  log("cyan", "conductor", "synthesizing final deliverable...\n");
+  console.log(`${C.dim}${"-".repeat(60)}${C.reset}`);
+  final = await synthesize(GOAL, p.strategy, ok);
+  console.log(final);
+  console.log(`${C.dim}${"-".repeat(60)}${C.reset}`);
+} catch (e) {
+  runError = String(e.message || e);
+  log("red", "error", runError);
+}
+saveRun();
+
+const secs = ((Date.now() - t0) / 1000).toFixed(0);
+const status = runError ? `${C.red}${C.bold}ENDED EARLY${C.reset}` : `${C.bold}DONE${C.reset}`;
+console.log(`\n${status} ${usage.calls} agent calls · ${usage.in.toLocaleString()} in / ${usage.out.toLocaleString()} out tokens · ${C.bold}$0.00 API credits${C.reset} ${C.dim}(nominal value $${usage.nominal.toFixed(2)}, covered by your Max subscription)${C.reset} · ${secs}s`);
+console.log(`${C.dim}saved: ${runFile}${runError ? " (partial)" : ""}${C.reset}\n`);
+process.exit(runError ? 1 : 0);

package/orchestra.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+// ORCHESTRA — a multi-agent system in one file.
+// One conductor agent takes your goal, breaks it into tasks, fans out specialist
+// sub-agents in PARALLEL (scouts, analysts, writers), sends critics to attack
+// their work, then synthesizes everything into one final deliverable.
+//
+//   node orchestra.mjs "your goal here"
+//   node orchestra.mjs "your goal" --agents 4 --web
+//   node orchestra.mjs "your goal" --cheap            (haiku everywhere, for testing)
+//   node orchestra.mjs "your goal" --model claude-fable-5
+//
+// Flags:
+//   --agents N   max sub-agents the conductor may cast (default 5)
+//   --web        let scout agents search the live web (server-side web search)
+//   --cheap      use claude-haiku-4-5 for everything (pennies, for smoke tests)
+//   --model M    model for conductor + synthesis (default claude-opus-4-8)
+//   --worker M   model for sub-agents (default: same as --model)
+//   --no-critics skip the critic pass
+//
+// Auth: ANTHROPIC_API_KEY env var, or a .env file next to this script.
+
+import Anthropic from "@anthropic-ai/sdk";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ROLES } from "./roles.mjs";
+
+const DIR = path.dirname(fileURLToPath(import.meta.url));
+
+// ---------- config ----------
+const args = process.argv.slice(2);
+const flag = (name) => {
+  const i = args.indexOf(name);
+  return i === -1 ? null : true;
+};
+const opt = (name, dflt) => {
+  const i = args.indexOf(name);
+  return i !== -1 && args[i + 1] ? args[i + 1] : dflt;
+};
+const GOAL = args.filter((a, i) => !a.startsWith("--") && (i === 0 || args[i - 1] !== "--agents" && !["--model", "--worker"].includes(args[i - 1]))).join(" ").trim();
+
+const CHEAP = flag("--cheap");
+const CONDUCTOR_MODEL = CHEAP ? "claude-haiku-4-5" : opt("--model", "claude-opus-4-8");
+const WORKER_MODEL = CHEAP ? "claude-haiku-4-5" : opt("--worker", opt("--model", "claude-opus-4-8"));
+const MAX_AGENTS = parseInt(opt("--agents", "5"), 10);
+const USE_WEB = flag("--web");
+const USE_CRITICS = !flag("--no-critics");
+const CONCURRENCY = 4;
+
+// $/MTok input, output — for the cost meter
+const PRICES = {
+  "claude-fable-5": [10, 50],
+  "claude-opus-4-8": [5, 25],
+  "claude-opus-4-7": [5, 25],
+  "claude-opus-4-6": [5, 25],
+  "claude-sonnet-4-6": [3, 15],
+  "claude-haiku-4-5": [1, 5],
+};
+const supportsAdaptive = (m) => /fable-5|opus-4-[678]|sonnet-4-6/.test(m);
+const supportsWebSearch = (m) => /fable-5|opus-4-[678]|sonnet-4-6/.test(m);
+
+// ---------- auth ----------
+function loadApiKey() {
+  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
+  const envFile = path.join(DIR, ".env");
+  if (fs.existsSync(envFile)) {
+    const m = fs.readFileSync(envFile, "utf8").match(/ANTHROPIC_API_KEY\s*=\s*(\S+)/);
+    if (m) return m[1];
+  }
+  console.error("No API key. Set ANTHROPIC_API_KEY or create a .env file next to this script.");
+  process.exit(1);
+}
+const client = new Anthropic({ apiKey: loadApiKey() });
+
+// ---------- helpers ----------
+const C = { dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", bold: "\x1b[1m", reset: "\x1b[0m" };
+const log = (color, tag, msg) => console.log(`${C[color]}${C.bold}[${tag}]${C.reset} ${msg}`);
+
+const usage = { calls: 0, in: 0, out: 0, cost: 0 };
+function track(model, u) {
+  const [pin, pout] = PRICES[model] || [5, 25];
+  usage.calls += 1;
+  usage.in += u.input_tokens + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0);
+  usage.out += u.output_tokens;
+  usage.cost += (u.input_tokens / 1e6) * pin + (u.output_tokens / 1e6) * pout + ((u.cache_creation_input_tokens || 0) / 1e6) * pin * 1.25 + ((u.cache_read_input_tokens || 0) / 1e6) * pin * 0.1;
+}
+
+function textOf(msg) {
+  if (msg.stop_reason === "refusal") return "[This agent's request was declined by safety classifiers.]";
+  return msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+
+async function pool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function runner() {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i).catch((e) => ({ error: String(e.message || e) }));
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runner));
+  return results;
+}
+
+const maybeThinking = (model) => (supportsAdaptive(model) ? { thinking: { type: "adaptive" } } : {});
+
+// ---------- phase 1: PLAN (conductor, structured output) ----------
+const PLAN_SCHEMA = {
+  type: "object",
+  properties: {
+    strategy: { type: "string", description: "One short paragraph: how the team will attack this goal." },
+    tasks: {
+      type: "array",
+      description: "Independent tasks, one per sub-agent. Each must be self-contained (the sub-agent sees nothing else).",
+      items: {
+        type: "object",
+        properties: {
+          role: { type: "string", enum: ["scout", "analyst", "writer"] },
+          title: { type: "string", description: "Short label for progress display, max 6 words." },
+          prompt: { type: "string", description: "The complete prompt for this sub-agent, fully self-contained, including the goal context it needs." },
+        },
+        required: ["role", "title", "prompt"],
+        additionalProperties: false,
+      },
+    },
+  },
+  required: ["strategy", "tasks"],
+  additionalProperties: false,
+};
+
+async function plan(goal) {
+  const res = await client.messages.create({
+    model: CONDUCTOR_MODEL,
+    max_tokens: 8000,
+    ...maybeThinking(CONDUCTOR_MODEL),
+    system: `You are the conductor of a multi-agent team. You never do the work yourself. You decompose the user's goal into at most ${MAX_AGENTS} INDEPENDENT tasks and assign each to a specialist sub-agent (scout = finds facts, analyst = reasons and compares, writer = produces the deliverable). Tasks run in parallel, so they must not depend on each other. Prefer fewer, sharper tasks over many vague ones. Every prompt you write must be fully self-contained: the sub-agent sees only its own prompt.`,
+    messages: [{ role: "user", content: `Goal: ${goal}` }],
+    output_config: { format: { type: "json_schema", schema: PLAN_SCHEMA } },
+  });
+  track(CONDUCTOR_MODEL, res.usage);
+  const parsed = JSON.parse(textOf(res));
+  parsed.tasks = parsed.tasks.slice(0, MAX_AGENTS);
+  return parsed;
+}
+
+// ---------- phase 2: EXECUTE (sub-agents, parallel) ----------
+async function runWorker(task, i) {
+  const tools = [];
+  if (USE_WEB && task.role === "scout" && supportsWebSearch(WORKER_MODEL)) {
+    tools.push({ type: "web_search_20260209", name: "web_search", max_uses: 3 });
+  }
+  log("cyan", `agent ${i + 1}`, `${task.role}: ${task.title} ${tools.length ? "(web search on)" : ""}`);
+  const stream = client.messages.stream({
+    model: WORKER_MODEL,
+    max_tokens: 6000,
+    system: ROLES[task.role] || ROLES.analyst,
+    messages: [{ role: "user", content: task.prompt }],
+    ...(tools.length ? { tools } : {}),
+  });
+  const msg = await stream.finalMessage();
+  track(WORKER_MODEL, msg.usage);
+  log("green", `agent ${i + 1}`, `${task.title} done (${msg.usage.output_tokens} tokens)`);
+  return { ...task, output: textOf(msg) };
+}
+
+// ---------- phase 3: CRITIQUE (one critic per result, parallel) ----------
+const CRIT_SCHEMA = {
+  type: "object",
+  properties: {
+    score: { type: "integer", description: "1 (garbage) to 10 (ship it)" },
+    verdict: { type: "string", description: "One sentence: the biggest problem, or why it holds up." },
+    fixes: { type: "array", items: { type: "string" }, description: "Concrete fixes, empty if none needed." },
+  },
+  required: ["score", "verdict", "fixes"],
+  additionalProperties: false,
+};
+
+async function runCritic(result, i) {
+  const res = await client.messages.create({
+    model: WORKER_MODEL,
+    max_tokens: 2000,
+    system: ROLES.critic,
+    messages: [{ role: "user", content: `The team's goal: ${GOAL}\n\nA ${result.role} agent was asked: ${result.prompt}\n\nIt produced:\n\n${result.output.slice(0, 12000)}\n\nAttack this work. Return your structured verdict.` }],
+    output_config: { format: { type: "json_schema", schema: CRIT_SCHEMA } },
+  });
+  track(WORKER_MODEL, res.usage);
+  const crit = JSON.parse(textOf(res));
+  const color = crit.score >= 7 ? "green" : crit.score >= 5 ? "yellow" : "red";
+  log(color, `critic ${i + 1}`, `${result.title}: ${crit.score}/10, ${crit.verdict}`);
+  return crit;
+}
+
+// ---------- phase 4: SYNTHESIZE (conductor, streamed live) ----------
+async function synthesize(goal, strategy, results) {
+  const dossier = results
+    .map((r, i) => `## Agent ${i + 1} (${r.role}): ${r.title}\nCritic verdict: ${r.crit ? `${r.crit.score}/10, ${r.crit.verdict} Fixes: ${r.crit.fixes.join("; ") || "none"}` : "not critiqued"}\n\n${r.output}`)
+    .join("\n\n---\n\n");
+  const stream = client.messages.stream({
+    model: CONDUCTOR_MODEL,
+    max_tokens: 16000,
+    ...maybeThinking(CONDUCTOR_MODEL),
+    system: ROLES.synthesizer,
+    messages: [{ role: "user", content: `The goal: ${goal}\n\nThe strategy was: ${strategy}\n\nHere is everything the team produced, with critic verdicts:\n\n${dossier}\n\nProduce the final deliverable. Apply the critics' fixes. Drop anything scored under 5.` }],
+  });
+  stream.on("text", (t) => process.stdout.write(t));
+  const msg = await stream.finalMessage();
+  track(CONDUCTOR_MODEL, msg.usage);
+  return textOf(msg);
+}
+
+// ---------- main ----------
+if (!GOAL) {
+  console.log('Usage: node orchestra.mjs "your goal" [--agents N] [--web] [--cheap] [--model M] [--worker M] [--no-critics]');
+  process.exit(0);
+}
+
+console.log(`\n${C.bold}ORCHESTRA${C.reset} ${C.dim}conductor=${CONDUCTOR_MODEL} workers=${WORKER_MODEL} max-agents=${MAX_AGENTS}${C.reset}\n`);
+log("yellow", "goal", GOAL);
+
+const t0 = Date.now();
+log("cyan", "conductor", "planning...");
+const p = await plan(GOAL);
+log("green", "conductor", `strategy: ${p.strategy}`);
+log("green", "conductor", `casting ${p.tasks.length} sub-agents`);
+
+// Every phase saves to the run file as it completes, so a mid-run failure
+// (rate limit, empty credit balance, network drop) never loses paid-for work.
+const slug = GOAL.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50).replace(/^-|-$/g, "");
+const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+const runFile = path.join(DIR, "runs", `${stamp}_${slug}.md`);
+let ok = [];
+let final = null;
+let runError = null;
+
+function saveRun() {
+  const header = `# ${GOAL}\n\n_${new Date().toISOString()} · conductor ${CONDUCTOR_MODEL} · workers ${WORKER_MODEL} · ${usage.calls} calls · $${usage.cost.toFixed(4)}_\n`;
+  const errNote = runError ? `\n> ⚠️ Run ended early: ${runError}\n` : "";
+  const finalSection = final ? `\n## Final deliverable\n\n${final}\n` : "";
+  const agents = ok.length
+    ? `\n## Agent outputs\n\n${ok.map((r, i) => `### Agent ${i + 1} (${r.role}): ${r.title}\n${r.crit ? `_Critic: ${r.crit.score}/10, ${r.crit.verdict}_\n` : ""}\n${r.output}`).join("\n\n")}\n`
+    : "";
+  fs.writeFileSync(runFile, `${header}${errNote}${finalSection}\n---\n\n## Strategy\n\n${p.strategy}\n${agents}`);
+}
+
+try {
+  const results = await pool(p.tasks, CONCURRENCY, runWorker);
+  ok = results.filter((r) => !r.error);
+  results.filter((r) => r.error).forEach((r) => log("red", "agent", `failed: ${r.error}`));
+  saveRun(); // worker outputs are now on disk no matter what happens next
+
+  if (USE_CRITICS && ok.length) {
+    log("cyan", "critics", `attacking ${ok.length} results...`);
+    const crits = await pool(ok, CONCURRENCY, runCritic);
+    ok.forEach((r, i) => (r.crit = crits[i]?.error ? null : crits[i]));
+    saveRun();
+  }
+
+  log("cyan", "conductor", "synthesizing final deliverable...\n");
+  console.log(`${C.dim}${"-".repeat(60)}${C.reset}`);
+  final = await synthesize(GOAL, p.strategy, ok);
+  console.log(`\n${C.dim}${"-".repeat(60)}${C.reset}`);
+} catch (e) {
+  runError = String(e.message || e);
+  if (/credit balance is too low/i.test(runError)) {
+    log("red", "billing", "Anthropic API credit balance is empty. Top up at console.anthropic.com > Plans & Billing, then re-run.");
+  } else {
+    log("red", "error", runError);
+  }
+}
+saveRun();
+
+const secs = ((Date.now() - t0) / 1000).toFixed(0);
+const status = runError ? `${C.red}${C.bold}ENDED EARLY${C.reset}` : `${C.bold}DONE${C.reset}`;
+console.log(`\n${status} ${usage.calls} agent calls · ${usage.in.toLocaleString()} in / ${usage.out.toLocaleString()} out tokens · ${C.bold}$${usage.cost.toFixed(4)}${C.reset} · ${secs}s`);
+console.log(`${C.dim}saved: ${runFile}${runError ? " (partial: worker outputs preserved)" : ""}${C.reset}\n`);
+process.exit(runError ? 1 : 0);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "orchestra-agents",
+  "version": "1.0.0",
+  "description": "Multi-agent orchestrator on the Claude API: one conductor plans, sub-agents execute in parallel, adversarial critics attack, the conductor synthesizes one deliverable.",
+  "type": "module",
+  "bin": {
+    "orchestra": "./orchestra.mjs",
+    "orchestra-max": "./orchestra-max.mjs"
+  },
+  "scripts": {
+    "start": "node orchestra.mjs"
+  },
+  "files": [
+    "orchestra.mjs",
+    "orchestra-max.mjs",
+    "roles.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "claude",
+    "anthropic",
+    "agents",
+    "multi-agent",
+    "orchestrator",
+    "swarm",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vyn-store/orchestra-agents.git"
+  },
+  "author": "Kirk Kodre",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.109.1"
+  }
+}

package/roles.mjs

@@ -0,0 +1,26 @@
+// Sub-agent role definitions. Each worker gets ONE of these as its system prompt.
+// The conductor decides which roles to cast for each task.
+
+export const ROLES = {
+  scout: `You are a research scout in a multi-agent team. Your only job is to FIND things.
+Return concrete findings: facts, numbers, names, sources. No opinions, no recommendations, no fluff.
+If you can search the web, cite where each fact came from. If you cannot verify something, say so explicitly.
+Your output goes to an orchestrator that will synthesize it with other agents' work, so return raw, dense findings, not a polished essay.`,
+
+  analyst: `You are an analyst in a multi-agent team. Your job is to REASON: compare options, run the numbers, find the tradeoffs, stress-test assumptions.
+Show your working. Be specific and quantitative wherever possible.
+Your output goes to an orchestrator that will synthesize it with other agents' work, so lead with your conclusions, then the reasoning behind them.`,
+
+  writer: `You are a writer in a multi-agent team. Your job is to PRODUCE the actual deliverable: copy, script, plan, document.
+Write tight and concrete. No em-dashes (use colons, periods, commas). No filler phrases.
+Your output goes to an orchestrator and then a critic, so produce the best complete draft you can, not an outline.
+Start directly with the deliverable. Never mention your tools, skills, process, or that you are an AI agent.`,
+
+  critic: `You are an adversarial critic in a multi-agent team. Your job is to try to BREAK the work you are given.
+Assume it is wrong until proven right. Find factual errors, weak reasoning, missing pieces, and anything that would embarrass the team if shipped.
+Be specific: point at the exact sentence or claim that fails and say why. If the work genuinely holds up, say so, but you must earn that verdict.`,
+
+  synthesizer: `You are the synthesizer in a multi-agent team. You receive the outputs of several specialist agents plus critic verdicts.
+Merge them into ONE coherent final deliverable. Resolve contradictions. Drop anything the critics killed. Keep the strongest material.
+Write the final answer directly for the human who asked, complete and ready to use. No meta-commentary about the agents or the process.`,
+};