Mastering Multi-Agent Systems: Orchestrating AI Swarms with LangGraph and CrewAI

import { StateGraph, END } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, BaseMessage } from "@langchain/core/messages";

// 1. Define the State
interface AgentState {
  messages: BaseMessage[];
  code: string | null;
  feedback: string | null;
  iterations: number;
}

// 2. Define the Nodes (Agents)
const model = new ChatOpenAI({ modelName: "gpt-4-turbo" });

async function juniorCoder(state: AgentState) {
  const { messages, feedback, code } = state;
  let prompt = "Write a Python function to calculate Fibonacci numbers.";

  if (feedback) {
    prompt += `

Previous code: ${code}
Reviewer feedback: ${feedback}
Please fix the code.`;
  }

  const response = await model.invoke([new HumanMessage(prompt)]);
  return {
    code: response.content as string,
    iterations: state.iterations + 1
  };
}

async function seniorReviewer(state: AgentState) {
  const { code } = state;
  const prompt = `Review this code for efficiency and style:
${code}

  If it's good, say "APPROVED". Otherwise, provide critique.`;

  const response = await model.invoke([new HumanMessage(prompt)]);
  const content = response.content as string;

  return {
    feedback: content
  };
}

// 3. Define the Router (Conditional Edge)
function shouldContinue(state: AgentState) {
  if (state.feedback?.includes("APPROVED") || state.iterations > 3) {
    return "end";
  }
  return "retry";
}

// 4. Build the Graph
const workflow = new StateGraph<AgentState>({
  channels: {
    messages: { value: (x, y) => x.concat(y), default: () => [] },
    code: { value: (x, y) => y ?? x, default: () => null },
    feedback: { value: (x, y) => y ?? x, default: () => null },
    iterations: { value: (x, y) => y ?? x, default: () => 0 },
  }
});

workflow.addNode("coder", juniorCoder);
workflow.addNode("reviewer", seniorReviewer);

workflow.setEntryPoint("coder");
workflow.addEdge("coder", "reviewer");
workflow.addConditionalEdges(
  "reviewer",
  shouldContinue,
  {
    end: END,
    retry: "coder"
  }
);

export const app = workflow.compile();

from crewai import Agent, Task, Crew, Process
from langchain_community.tools import DuckDuckGoSearchRun

search_tool = DuckDuckGoSearchRun()

# 1. Define Agents
researcher = Agent(
  role='Senior Tech Researcher',
  goal='Uncover groundbreaking developments in AI Agents',
  backstory="""You are a veteran tech analyst with a knack for
  finding hidden gems in academic papers and GitHub repos.""",
  verbose=True,
  allow_delegation=False,
  tools=[search_tool]
)

writer = Agent(
  role='Tech Content Strategist',
  goal='Craft compelling content on tech advancements',
  backstory="""You are a famous tech blogger known for simplifying
  complex topics for a general audience.""",
  verbose=True,
  allow_delegation=True
)

# 2. Define Tasks
task1 = Task(
  description='Conduct a comprehensive analysis of the latest AI Agent frameworks in 2025.',
  agent=researcher,
  expected_output='A detailed report summarizing key frameworks like LangGraph and AutoGen.'
)

task2 = Task(
  description='Using the insights provided, write an engaging blog post about the future of AI Agents.',
  agent=writer,
  expected_output='A 1500-word blog post in markdown format.'
)

# 3. Form the Crew
crew = Crew(
  agents=[researcher, writer],
  tasks=[task1, task2],
  process=Process.sequential  # Execution flow
)

result = crew.kickoff()

@Service
public class EnterpriseAgentService {

    interface Assistant {
        @SystemMessage("You are a helpful banking assistant. Today is {{current_date}}.")
        String chat(@UserMessage String userMessage);
    }

    private final Assistant assistant;

    public EnterpriseAgentService(ChatLanguageModel chatLanguageModel) {
        this.assistant = AiServices.builder(Assistant.class)
                .chatLanguageModel(chatLanguageModel)
                .tools(new BankingTools()) // Register Java methods as tools
                .build();
    }

    public String processUserRequest(String userId, String request) {
        // In a real app, you'd load conversation history from a DB here
        return assistant.chat(request);
    }
}

// Define Tools that the Agent can call
public class BankingTools {

    @Tool("Check the account balance for a specific customer")
    public double getBalance(String customerId) {
        // Logic to query mainframe/database
        return 5000.00;
    }

    @Tool("Transfer money between accounts")
    public String transfer(String fromId, String toId, double amount) {
        // Transactional logic
        return "Transferred " + amount + " success.";
    }
}