borg

use borg::prelude::*;

#[derive(BorgAgentDerive)]
#[borg(id = "reviewer", model = "anthropic/claude-haiku-5-5",
       max_tokens = 800, system = "Review code quality.")]
struct Reviewer;

impl Reviewer {
    fn user_prompt(&self, ctx: &AgentContext) -> Option<String> {
        ctx.handoff.get_as("code")
    }
}

let suggestions: Vec<Suggestion> =
    run_one_typed("review", Reviewer, ctx, handoff).await?;

A derive replaces the trait boilerplate; you write user_prompt. run_one_typed parses the verdict into your type.

use borg::prelude::*;

let app = seq([
    step(Planner),
    par([step(Coder), step(TestWriter), step(DocWriter)]),
    repeat(8, |v: &Verdict| v.token == "PASS", || seq([
        step(Builder),
        step(BuildFixer),
    ])),
    step(Reviewer),
    step(Deployer),
]);

let outcome = execute(app, ctx).await?;

Plan; write code, tests and docs in parallel; build and fix until PASS, at most eight times; deploy. A stop reaches every nested call.

#[derive(BorgToolDerive)]
#[tool(name = "read_file", description = "Read a file from disk.",
       context = EditCtx,
       input_schema = serde_json::json!({
           "type": "object",
           "properties": { "path": { "type": "string" } },
           "required":   ["path"],
       }))]
struct ReadFile;

impl ReadFile {
    async fn execute(&self, input: serde_json::Value, ctx: &mut EditCtx)
        -> Result<ToolCallResult, BorgError>
    {
        let path = input["path"].as_str().unwrap_or_default();
        let text = tokio::fs::read_to_string(path).await
            .map_err(|e| BorgError::Internal { message: e.to_string() })?;
        ToolCallResult::ok(text)
    }
}

let registry = Registry::<EditCtx>::new()
    .with(ReadFile).with(WriteFile).with(RunTests);

let dispatcher: Arc<dyn ToolDispatch> =
    Arc::new(MutexDispatcher::new(registry, my_ctx));

let coder = agent_loop(MainCoder, dispatcher, /* max_steps */ 40);

Schemas reach the model in its provider's shape. Each tool call is supervised and draws on the same budget. MCP tools use the same path.

use borg::{prelude::*, GuardrailHarness, GuardrailEngine};
use borg::guardrails::rules::*;

let harness = Arc::new(GuardrailHarness::new(
    GuardrailEngine::new()
        .with_rule(MaxContinuationsRule::new(30))
        .with_rule(TextOnlyEndTurnRule::new(3))
        .with_rule(RepeatedToolCallRule::new("read_file", 3, 5, 8))
        .with_rule(ConsecutiveFailureRule::new("build_project", 3, 6)),
));

let ctx = ExecCtx::new(llm, budget, emitter, cancel, "session-1")
    .with_guardrails(harness);

Rules watch model behaviour at turn boundaries. Verdicts merge by severity, Ok to Halt, and the executor enforces them.

use borg::{BorgError, StreamEvent};
use borg_loop::*;
use futures::stream::BoxStream;

#[async_trait]
impl StreamingActorAgent for Chat {
    type Message = Msg;
    type Snapshot = ChatSnap;

    async fn handle_streaming(&mut self, msg: Msg, ctx: &ActorCtx)
        -> Result<(BoxStream<'static, StreamEvent>, StreamingHandleOutcome), BorgError>
    {
        let events = self.reply(msg, ctx).await?;   // your model's event stream
        Ok((events, StreamingHandleOutcome::Park))  // wait for the next message
    }
    fn checkpoint(&self) -> ChatSnap { ChatSnap { history: self.history.clone() } }
    fn restore(s: ChatSnap) -> Self   { Chat::from_history(s.history) }
}

let h = spawn_streaming_actor("session-42", Chat::default(),
                              ActorConfig::for_streaming(), store.clone(), None);

match h.run_session_loop(Msg::user("hi"), || Msg::Continue, |ev| {
    if let StreamEvent::TextDelta(t) = ev { print!("{t}") }
}).await {
    SessionOutcome::Parked => { /* alive, waiting for the next user message */ }
    SessionOutcome::Suspended { request } => { /* ask a human, resume later */ }
    _ => { /* terminal: spawn again for the next message */ }
}

// After a restart: the same session, from its snapshot.
let h = resume_streaming_actor("session-42", Chat::default, Chat::restore,
                               ActorConfig::for_streaming(), store, None).await?;

A streaming actor streams each turn's events live and checkpoints to your store. Dropping a TurnHandle mid-stream parks it. Full example: borg-loop/examples/streaming_session.rs.

use borg::suspend::{Decision, SuspendKind, SuspendRequest};
use borg_loop::*;

// In the actor: pause for a human before deploying.
Msg::Deploy { release } => HandleOutcome::Suspended {
    request: SuspendRequest::new(
        format!("Deploy {release} to production?"),
        SuspendKind::Approval,
    ),
},

// The runtime persists a snapshot and exits.
let ActorExit::Suspended { request } = handle.join().await else { unreachable!() };

// Later, when the human answers: restore, then deliver the decision.
let resumed = resume_actor(session, fresh, Deployer::restore,
                           ActorConfig::default(), store, None).await?;
resumed.send(Msg::Decision(Decision::Approve)).await?;

Suspend, persist, resume with a Decision. Full example: borg-loop/examples/human_in_the_loop.rs.