Crate agent_kernel 

Agent kernel crate — minimal orchestration primitives for multi-agent discussion.

Design Principles (pi-mono)

• Extreme minimalism: discuss() is the ONLY orchestration primitive
• Full trust: caller controls rounds, no internal policy
• Observability first: AgentEvent is a first-class output via mpsc::Sender
• Late binding: Message stays internal until provider converts at the boundary

Phase 2 additions (independent repo)

• evolution module: EvolutionContext + EvolutionRuntime trait
• AgentEvent::Evolved variant in event module

Quick Start

use agent_kernel::{Agent, AgentRuntime, BoxFuture, discuss};
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;

struct MyRuntime;

impl AgentRuntime for MyRuntime {
    fn respond<'a>(
        &'a self,
        agent: &'a Agent,
        _history: &'a [agent_kernel::Message],
    ) -> BoxFuture<'a, anyhow::Result<String>> {
        Box::pin(async move {
            Ok(format!("[{}] My response", agent.name))
        })
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let runtime = MyRuntime;
    let agents = vec![
        Agent { name: "alice".into(), soul_md: "You are Alice.".into(), model: "gpt-4o".into() },
        Agent { name: "bob".into(), soul_md: "You are Bob.".into(), model: "gpt-4o".into() },
    ];
    let (tx, mut rx) = mpsc::channel(64);
    let cancel = CancellationToken::new();
    let summary = discuss(&runtime, &agents, "What is Rust?", 2, cancel, tx).await?;
    while let Ok(event) = rx.try_recv() {
        println!("{event:?}");
    }
    println!("Summary: {summary}");
    Ok(())
}

Re-exports

pub use agent::Agent;

pub use event::AgentEvent;

pub use evolution::EvolutionContext;

pub use evolution::EvolutionRuntime;

pub use message::Message;

pub use message::Role;

pub use runtime::AgentRuntime;

pub use discuss::discuss;

Modules

agent

discuss

event

evolution

message

runtime

Type Aliases

BoxFuture

Boxed future used as AgentRuntime::respond return type.