Building Multi-Agent Teams

// Orchestrator writes task to file
import fs from "fs";

const task = {
  id: "task-123",
  type: "write-blog-post",
  topic: "How to build multi-agent systems",
  deadline: "2026-03-15",
  status: "pending",
};

fs.writeFileSync(
  "tasks/task-123.json",
  JSON.stringify(task, null, 2)
);

// Worker reads and processes task
const workerTask = JSON.parse(
  fs.readFileSync("tasks/task-123.json", "utf-8")
);

// Worker updates status when done
workerTask.status = "completed";
workerTask.output = "content/blog-post-2026-03-15.md";
fs.writeFileSync(
  "tasks/task-123.json",
  JSON.stringify(workerTask, null, 2)
);

// CEO creates a task for a worker
async function delegateTask(title: string, description: string) {
  const response = await fetch("https://agentix.cloud/tasks", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.SERVICE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      teamId: "my-team-id",
      title,
      description,
      role: "content-writer",
      priority: 1,
      status: "backlog",
      createdBy: "worker:ceo-agent-id",
    }),
  });
  return response.json();
}

// Worker polls for tasks and claims one
async function claimNextTask(workerId: string) {
  const tasks = await fetch(
    `https://agentix.cloud/tasks?status=backlog&role=content-writer`,
    { headers: { "Authorization": `Bearer ${process.env.SERVICE_API_KEY}` } }
  ).then(r => r.json());

  if (tasks.length === 0) return null;

  // Claim the highest-priority task
  const task = tasks[0];
  await fetch(`https://agentix.cloud/tasks/${task.id}`, {
    method: "PATCH",
    headers: {
      "Authorization": `Bearer ${process.env.SERVICE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ status: "in_progress", assignee: workerId }),
  });

  return task;
}

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

const client = new Anthropic();

// Orchestrator: breaks work into subtasks and runs them in parallel
async function orchestrate(goal: string) {
  // Step 1: Ask CEO agent to decompose the goal
  const planResponse = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages: [{
      role: "user",
      content: `Goal: ${goal}\n\nBreak this into 3-5 independent subtasks. Return JSON array.`,
    }],
  });

  const subtasks: string[] = JSON.parse(
    planResponse.content[0].type === "text"
      ? planResponse.content[0].text
      : "[]"
  );

  // Step 2: Run all subtasks in parallel
  const results = await Promise.all(
    subtasks.map((task) => runWorkerAgent(task))
  );

  // Step 3: Synthesize results
  const synthesis = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    messages: [{
      role: "user",
      content: `Combine these subtask results into a coherent output:\n${results.join("\n\n")}`,
    }],
  });

  return synthesis.content[0].type === "text"
    ? synthesis.content[0].text
    : "";
}

// Worker: runs a single focused task
async function runWorkerAgent(task: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: "You are a specialist completing one focused task. Be thorough and specific.",
    messages: [{ role: "user", content: task }],
  });

  return response.content[0].type === "text"
    ? response.content[0].text
    : "";
}

interface Task {
  id: string;
  status: "pending" | "in_progress" | "completed" | "failed";
  assignedAt?: number;
  attempts: number;
  result?: string;
  error?: string;
}

const MAX_ATTEMPTS = 3;
const TASK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes

// Supervisor: monitors tasks and handles failures
async function supervise(tasks: Task[]) {
  const interval = setInterval(async () => {
    for (const task of tasks) {
      // Check for timeouts
      if (
        task.status === "in_progress" &&
        task.assignedAt &&
        Date.now() - task.assignedAt > TASK_TIMEOUT_MS
      ) {
        console.log(`Task ${task.id} timed out. Reassigning.`);
        task.status = "pending";
        task.assignedAt = undefined;
        task.attempts++;

        if (task.attempts >= MAX_ATTEMPTS) {
          task.status = "failed";
          task.error = "Exceeded max attempts";
          await escalateToHuman(task);
        }
      }
    }

    // Stop when all tasks are done
    const allDone = tasks.every(
      (t) => t.status === "completed" || t.status === "failed"
    );
    if (allDone) clearInterval(interval);
  }, 30_000); // Check every 30 seconds
}

async function escalateToHuman(task: Task) {
  // Send notification (email, Slack, etc.)
  console.error(`ESCALATION REQUIRED: Task ${task.id} failed after ${task.attempts} attempts. Error: ${task.error}`);
  // In production: send to Slack, PagerDuty, email, etc.
}

// Example: Role definition for a content writer agent
const contentWriterRole = {
  name: "content-writer",

  // Who you are
  identity: `You are a technical content writer who creates clear, engaging
educational content for developers learning to build AI agents. You write
in a conversational, authentic tone that balances technical depth with
accessibility.`,

  // What you're responsible for
  responsibilities: [
    "Write course modules with code examples",
    "Write blog posts explaining technical decisions",
    "Create Twitter threads for developer audience",
  ],

  // What you must never do
  constraints: [
    "Never modify protected infrastructure files",
    "Never push directly to main branch",
    "Never make up code examples that don't work",
    "Always create a PR when done — never merge your own PR",
  ],

  // How you work
  workflow: `
1. Read your task assignment from the coordination API
2. Read CODEBASE_MAP.md to understand the project
3. Read relevant existing files before modifying anything
4. Do the work, committing after each subtask
5. Run pnpm build to verify no errors
6. Create a PR when complete
7. Call complete_task with a summary
`,
};

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

const client = new Anthropic();

// Agent 1: Researcher
async function researcherAgent(topic: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: `You are a research specialist. Your job is to find and summarize
the most relevant information on any topic. Be specific, cite examples,
and focus on practical insights. Return structured research notes.`,
    messages: [{
      role: "user",
      content: `Research this topic thoroughly: ${topic}

Provide:
1. Key concepts and definitions
2. Current state of the art / best practices
3. Common mistakes and pitfalls
4. 3-5 specific, concrete examples
5. Resources for further reading

Be specific. Avoid generic statements.`,
    }],
  });

  return response.content[0].type === "text"
    ? response.content[0].text
    : "";
}

// Agent 2: Writer
async function writerAgent(topic: string, research: string): Promise<string> {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: `You are a technical writer who produces clear, engaging reports.
You take raw research and turn it into polished, readable content.
Write for a developer audience. Use concrete examples. Be direct.`,
    messages: [{
      role: "user",
      content: `Write a structured 500-word report on: ${topic}

Use this research as your source material:
---
${research}
---

Structure:
- Introduction (1 paragraph)
- Key Concepts (2-3 bullet points)
- Best Practices (numbered list)
- Common Mistakes (2-3 examples)
- Conclusion with action items`,
    }],
  });

  return response.content[0].type === "text"
    ? response.content[0].text
    : "";
}

// Orchestrator: coordinates the two agents
async function produceReport(topic: string): Promise<string> {
  console.log(`Starting research on: ${topic}`);

  // Step 1: Research
  console.log("Researcher agent working...");
  const research = await researcherAgent(topic);

  // Step 2: Write (uses researcher's output)
  console.log("Writer agent working...");
  const report = await writerAgent(topic, research);

  console.log("Report complete.");
  return report;
}

// Run it
produceReport("multi-agent AI systems").then(console.log);