Multi-agent systems in Rust, ready in 6 milliseconds

let workflow = ConcurrentWorkflow::builder()
    .name("ModelPanel")
    .agents(agents) // Vec<Box<dyn Agent>>, one model per agent
    .build();

let result = workflow
    .run("Should a new backend start as a monolith or microservices?")
    .await?;
for message in &result.history {
    println!("── {} ──\n{}\n", message.role, message.content);
}

let researcher = client
    .agent_builder()
    .agent_name("Researcher")
    .description("Looks up facts and returns a short, sourced summary")
    .system_prompt("You are a researcher. Answer with concise facts only.")
    .build();

let writer = client
    .agent_builder()
    .agent_name("Writer")
    .description("Writes the final, polished answer for the user")
    .system_prompt("Using the context you are given, write the final answer.")
    .build();

let coordinator = client
    .agent_builder()
    .agent_name("Coordinator")
    .system_prompt("Delegate fact-finding to the Researcher, then transfer to the Writer.")
    .add_sub_agent(researcher)
    .add_handoff(writer)
    .max_loops(4)
    .build();

let output = coordinator.run("Why did Rust adopt async/await?".to_string()).await?;

let mut workflow = DAGWorkflow::new("Graph Swarm", "Collect, process, summarize, analyze");

for agent in [collector, processor, summarizer, analyst] {
    workflow.register_agent(Box::new(agent));
}

workflow.connect_agents("Collector", "Processor", Flow::default())?;
workflow.connect_agents("Collector", "Summarizer", Flow {
    transform: Some(Arc::new(|out| format!("Summary request: {out}"))),
    condition: Some(Arc::new(|out| out.len() > 100)),
})?;
workflow.connect_agents("Processor", "Analyst", Flow::default())?;
workflow.connect_agents("Summarizer", "Analyst", Flow::default())?;

let results = workflow.execute_workflow("Collector", "How to build a graph database?").await?;

let mut rearrange = AgentRearrange::builder()
    .name("Research Pipeline")
    .agents(agents) // Researcher, Analyst, Reviewer, Summarizer
    .flow("Researcher -> Analyst, Reviewer, Summarizer")
    .max_loops(1)
    .output_type(OutputType::Final)
    .build();

let result = rearrange.run("Analyze the Bitcoin and Ethereum markets").await?;

let mut config = SwarmRouterConfig::with_agents(agents);
config.swarm_type = SwarmType::ConcurrentWorkflow;
config.rules = Some("Keep every answer under 100 words.".to_string());

let router = SwarmRouter::new_with_config(config)?;
let conversation = router.run("How should a small team version its API?").await?;
println!("{conversation}");