// multi-agent-review.ts
import { StateGraph, Annotation, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
 
// Define shared state across all agents
const ReviewState = Annotation.Root({
  code: Annotation<string>,
  securityReview: Annotation<string>,
  performanceReview: Annotation<string>,
  finalReport: Annotation<string>,
  currentStep: Annotation<string>,
});
 
const model = new ChatOpenAI({ model: "gpt-4o" });
 
// Agent 1: Security Reviewer
async function securityAgent(
  state: typeof ReviewState.State
) {
  const response = await model.invoke([
    {
      role: "system",
      content: `You are a senior security engineer. Analyze code
        for vulnerabilities: injection attacks, auth issues,
        data exposure, insecure dependencies. Be specific
        about line numbers and severity.`,
    },
    {
      role: "user",
      content: `Review this code for security issues:\n\n${state.code}`,
    },
  ]);
 
  return {
    securityReview: response.content as string,
    currentStep: "security_complete",
  };
}
 
// Agent 2: Performance Reviewer
async function performanceAgent(
  state: typeof ReviewState.State
) {
  const response = await model.invoke([
    {
      role: "system",
      content: `You are a performance optimization expert.
        Analyze code for: N+1 queries, memory leaks,
        unnecessary re-renders, missing indexes, blocking
        operations. Suggest concrete fixes.`,
    },
    {
      role: "user",
      content: `Review this code for performance:\n\n${state.code}`,
    },
  ]);
 
  return {
    performanceReview: response.content as string,
    currentStep: "performance_complete",
  };
}
 
// Agent 3: Supervisor synthesizes reviews
async function supervisorAgent(
  state: typeof ReviewState.State
) {
  const response = await model.invoke([
    {
      role: "system",
      content: `You are a lead engineer. Synthesize security
        and performance reviews into a unified report.
        Prioritize issues by severity: critical, high,
        medium, low. Remove duplicates.`,
    },
    {
      role: "user",
      content: `
Security Review:
${state.securityReview}
 
Performance Review:
${state.performanceReview}
 
Produce a final prioritized code review report.`,
    },
  ]);
 
  return {
    finalReport: response.content as string,
    currentStep: "complete",
  };
}
 
// Build the graph
const workflow = new StateGraph(ReviewState)
  .addNode("security", securityAgent)
  .addNode("performance", performanceAgent)
  .addNode("supervisor", supervisorAgent)
  // Run security and performance reviews in parallel
  .addEdge("__start__", "security")
  .addEdge("__start__", "performance")
  // Both feed into supervisor
  .addEdge("security", "supervisor")
  .addEdge("performance", "supervisor")
  .addEdge("supervisor", END);
 
const app = workflow.compile();
 
// Execute the multi-agent review
const result = await app.invoke({
  code: `
    app.get('/users/:id', async (req, res) => {
      const user = await db.query(
        "SELECT * FROM users WHERE id = " + req.params.id
      );
      const orders = await db.query(
        "SELECT * FROM orders WHERE user_id = " + req.params.id
      );
      for (const order of orders) {
        order.items = await db.query(
          "SELECT * FROM items WHERE order_id = " + order.id
        );
      }
      res.json({ user, orders });
    });
  `,
});
 
console.log(result.finalReport);

# content_crew.py
from crewai import Agent, Task, Crew, Process
 
researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive, accurate information on the given topic",
    backstory="""You are an expert researcher with 15 years of
    experience in technology analysis. You excel at finding
    primary sources and synthesizing complex information.""",
    verbose=True,
    allow_delegation=False,
)
 
writer = Agent(
    role="Technical Content Writer",
    goal="Create engaging, technically accurate content",
    backstory="""You are a senior technical writer who has
    written for major tech publications. You make complex
    topics accessible without dumbing them down.""",
    verbose=True,
    allow_delegation=False,
)
 
editor = Agent(
    role="Senior Editor",
    goal="Ensure content is polished, accurate, and publication-ready",
    backstory="""You are a meticulous editor with an eye for
    factual accuracy, logical flow, and reader engagement.
    You catch errors others miss.""",
    verbose=True,
    allow_delegation=False,
)
 
# Define sequential tasks
research_task = Task(
    description="Research {topic} thoroughly. Cover current state, key players, recent developments, and future outlook.",
    expected_output="A detailed research brief with citations",
    agent=researcher,
)
 
writing_task = Task(
    description="Write a 1500-word article based on the research brief. Use clear headings, include examples, and maintain technical depth.",
    expected_output="A complete article draft in markdown",
    agent=writer,
)
 
editing_task = Task(
    description="Edit the article for accuracy, clarity, flow, and grammar. Verify all technical claims against the research.",
    expected_output="A polished, publication-ready article",
    agent=editor,
)
 
# Assemble the crew with sequential processing
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True,
)
 
result = crew.kickoff(inputs={"topic": "Edge AI deployment patterns"})
print(result)

// typed-agents.ts
import { Agent } from "pydantic-ai";
import { z } from "zod";
 
// Define typed schemas for agent communication
const ResearchOutput = z.object({
  findings: z.array(
    z.object({
      claim: z.string(),
      evidence: z.string(),
      confidence: z.enum(["high", "medium", "low"]),
    })
  ),
  sources: z.array(z.string()),
});
 
const AnalysisOutput = z.object({
  summary: z.string(),
  recommendations: z.array(
    z.object({
      action: z.string(),
      priority: z.enum(["critical", "high", "medium", "low"]),
      rationale: z.string(),
    })
  ),
});
 
// Typed research agent
async function runResearchAgent(topic: string) {
  const agent = new Agent(
    "openai:gpt-4o",
    {
      systemPrompt: `You are a research specialist. Analyze
        the given topic and return structured findings with
        confidence levels.`,
      resultType: ResearchOutput,
    }
  );
 
  return await agent.run(`Research: ${topic}`);
}
 
// Typed analysis agent that consumes research output
async function runAnalysisAgent(
  research: z.infer<typeof ResearchOutput>
) {
  const agent = new Agent(
    "openai:gpt-4o",
    {
      systemPrompt: `You are a strategic analyst. Given
        research findings, produce actionable recommendations
        prioritized by impact and confidence.`,
      resultType: AnalysisOutput,
    }
  );
 
  return await agent.run(
    `Analyze these findings and recommend actions:\n${JSON.stringify(research, null, 2)}`
  );
}
 
// Pipeline orchestration
async function researchPipeline(topic: string) {
  const research = await runResearchAgent(topic);
  const analysis = await runAnalysisAgent(research.data);
 
  return {
    research: research.data,
    analysis: analysis.data,
  };
}

// task-decomposer.ts
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";
 
const SubTask = z.object({
  id: z.string(),
  description: z.string(),
  agentType: z.enum([
    "researcher",
    "coder",
    "reviewer",
    "writer",
  ]),
  dependencies: z
    .array(z.string())
    .describe("IDs of tasks that must complete first"),
  estimatedComplexity: z.enum(["low", "medium", "high"]),
});
 
const DecompositionPlan = z.object({
  subtasks: z.array(SubTask),
  executionOrder: z
    .array(z.array(z.string()))
    .describe("Groups of task IDs that can run in parallel"),
});
 
async function decomposeTask(
  task: string
): Promise<z.infer<typeof DecompositionPlan>> {
  const model = new ChatOpenAI({ model: "gpt-4o" });
 
  const response = await model.invoke([
    {
      role: "system",
      content: `Decompose the given task into subtasks for
        a multi-agent system. Identify which agent type
        should handle each subtask, what dependencies exist,
        and which tasks can run in parallel. Return valid JSON
        matching the schema.`,
    },
    {
      role: "user",
      content: task,
    },
  ]);
 
  return DecompositionPlan.parse(
    JSON.parse(response.content as string)
  );
}