User Request
     │
     ▼
┌─────────────┐
│ Orchestrator │  ← Breaks task into subtasks, manages state
└──────┬──────┘
       │  spawns
  ┌────┴────┐
  ▼         ▼
[Agent A] [Agent B]   ← Subagents: one job each, run in parallel
  │         │
  └────┬────┘
       ▼
  [Integration]       ← Orchestrator merges results
       │
       ▼
  Final Output

typescriptimport Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Reusable helper for a single agent call
async function runAgent(
  systemPrompt: string,
  userMessage: string,
  model: string = "claude-haiku-4-5-20251001" // use Haiku for subagents to save cost
): Promise<string> {
  const response = await client.messages.create({
    model,
    max_tokens: 2048,
    system: systemPrompt,
    messages: [{ role: "user", content: userMessage }],
  });

  const content = response.content[0];
  if (content.type !== "text") throw new Error("Unexpected response type");
  return content.text;
}

typescriptconst ORCHESTRATOR_SYSTEM = `You are a task orchestration agent. 
Given a high-level goal, break it into 2-5 independent subtasks that can be executed in parallel.

Return ONLY a JSON array with this structure:
[
  {
    "id": "task_1",
    "role": "one-sentence description of this subagent's job",
    "systemPrompt": "detailed system prompt for this subagent",
    "input": "the specific input this subagent should process"
  }
]

Rules:
- Each subtask must be completable independently (no dependencies on other subtasks)
- Subtask inputs must be self-contained — don't reference 'the other agents'
- system prompts should be specific and role-focused`;

async function orchestrate(goal: string): Promise<SubTask[]> {
  const response = await runAgent(
    ORCHESTRATOR_SYSTEM,
    `Goal: ${goal}`,
    "claude-sonnet-4-6" // orchestrator needs stronger reasoning
  );

  // Parse the JSON plan
  const jsonMatch = response.match(/\[[\s\S]*\]/);
  if (!jsonMatch) throw new Error("Orchestrator did not return valid JSON");
  return JSON.parse(jsonMatch[0]) as SubTask[];
}

interface SubTask {
  id: string;
  role: string;
  systemPrompt: string;
  input: string;
}

typescriptinterface SubTaskResult {
  id: string;
  role: string;
  output: string;
  error?: string;
}

async function runSubagents(subtasks: SubTask[]): Promise<SubTaskResult[]> {
  const results = await Promise.all(
    subtasks.map(async (task): Promise<SubTaskResult> => {
      try {
        const output = await runAgent(task.systemPrompt, task.input);
        return { id: task.id, role: task.role, output };
      } catch (err) {
        // Don't let one failed subagent kill the whole pipeline
        const error = err instanceof Error ? err.message : "Unknown error";
        return { id: task.id, role: task.role, output: "", error };
      }
    })
  );
  return results;
}

typescriptconst INTEGRATOR_SYSTEM = `You are a synthesis agent. You receive outputs from multiple specialized agents
and integrate them into a single, coherent, well-structured response.

Do not simply concatenate. Find connections, resolve contradictions, and produce a unified whole.
Preserve factual specifics from each agent's output.`;

async function integrate(
  goal: string,
  results: SubTaskResult[]
): Promise<string> {
  const validResults = results.filter((r) => !r.error && r.output);

  if (validResults.length === 0) {
    throw new Error("All subagents failed — cannot integrate");
  }

  const agentOutputs = validResults
    .map((r) => `## ${r.role}\n${r.output}`)
    .join("\n\n");

  const prompt = `Original goal: ${goal}\n\nAgent outputs to integrate:\n\n${agentOutputs}`;

  return runAgent(INTEGRATOR_SYSTEM, prompt, "claude-sonnet-4-6");
}

typescriptasync function runMultiAgentPipeline(goal: string): Promise<string> {
  console.log("🎯 Orchestrating task:", goal);

  // 1. Plan
  const subtasks = await orchestrate(goal);
  console.log(`📋 Planned ${subtasks.length} subtasks`);
  subtasks.forEach((t) => console.log(`  - ${t.id}: ${t.role}`));

  // 2. Execute in parallel
  console.log("⚡ Running subagents in parallel...");
  const startTime = Date.now();
  const results = await runSubagents(subtasks);
  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);

  const succeeded = results.filter((r) => !r.error).length;
  console.log(`✅ ${succeeded}/${subtasks.length} subagents completed in ${elapsed}s`);

  // 3. Integrate
  console.log("🔀 Integrating results...");
  const finalOutput = await integrate(goal, results);

  return finalOutput;
}

// Example usage
const result = await runMultiAgentPipeline(
  "Write a competitive analysis of Claude Code vs GitHub Copilot vs Cursor for professional developers"
);
console.log(result);

typescript// Specialized subagent system prompts for content creation

const RESEARCH_AGENT_SYSTEM = `You are a research analyst. Given a topic, identify:
1. The 5 most important facts/statistics (with approximate sources)
2. The 3 main pain points the target audience has with this topic
3. The key terminology and concepts someone needs to understand
Return as structured markdown.`;

const OUTLINE_AGENT_SYSTEM = `You are a content strategist. Given a topic and keywords,
create a detailed article outline with:
- H1 title optimized for the primary keyword
- H2 sections with clear learning objectives
- Key points to cover in each section
- Suggested code examples or tables
Return as structured markdown.`;

const COMPETITOR_AGENT_SYSTEM = `You are an SEO analyst. Given a topic,
describe what angle and depth a strong-performing article on this topic would have.
Consider: search intent, what developers actually want to learn, common misconceptions to address.
Return 3-5 specific recommendations.`;

async function researchPipeline(topic: string, keywords: string[]) {
  const goal = `Create comprehensive research for an article on: "${topic}". Target keywords: ${keywords.join(", ")}`;

  // These three can run in parallel — they don't depend on each other
  const [research, outline, seoAngle] = await Promise.all([
    runAgent(RESEARCH_AGENT_SYSTEM, topic),
    runAgent(OUTLINE_AGENT_SYSTEM, `Topic: ${topic}\nKeywords: ${keywords.join(", ")}`),
    runAgent(COMPETITOR_AGENT_SYSTEM, topic),
  ]);

  return { research, outline, seoAngle };
}

typescriptasync function runAgentWithRetry(
  systemPrompt: string,
  userMessage: string,
  maxRetries: number = 3
): Promise<string> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await runAgent(systemPrompt, userMessage);
    } catch (err) {
      const isRateLimit =
        err instanceof Error && err.message.includes("rate_limit");
      const isLastAttempt = attempt === maxRetries;

      if (isLastAttempt) throw err;

      // Exponential backoff: 1s, 2s, 4s
      const waitMs = Math.pow(2, attempt - 1) * 1000;
      console.warn(`Attempt ${attempt} failed. Retrying in ${waitMs}ms...`);
      await new Promise((resolve) => setTimeout(resolve, waitMs));
    }
  }
  throw new Error("Unreachable");
}

typescriptfunction validateSubagentOutput(output: string, expectedFormat: "json" | "markdown" | "text"): boolean {
  if (expectedFormat === "json") {
    try {
      JSON.parse(output);
      return true;
    } catch {
      return false;
    }
  }
  return output.length > 50; // basic sanity check for text/markdown
}

typescriptimport pLimit from "p-limit";

const limit = pLimit(5); // max 5 concurrent calls

const results = await Promise.all(
  subtasks.map((task) =>
    limit(() => runAgent(task.systemPrompt, task.input))
  )
);