Agent framework and durable runtime · MIT

cargo add everruns

Build capable AI agents in Rust. Run them where they belong.

Agents, typed tools, multi-turn sessions, and durable execution behind one application-facing API. Pick how much of it you want to operate.

FrameworkFramework quickstart →
A Rust crate inside your own binary. No database, no server, no services to run.
Self-hostedDocker Compose quickstart →
The shared runtime in your infrastructure, on your PostgreSQL, with the control plane and UI.
Everruns CloudHow Cloud works →
The same runtime and production operations, managed for you. Free during early access.

main.rs

use everruns::{Agent, Engine, OpenAI};

/// Look up the delivery status of an order.
#[everruns::tool]
async fn order_status(id: String) -> Result<String, String> {
    Ok(format!("Order {id} ships on Tuesday."))
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let agent = Agent::builder()
        .instructions("Answer order questions. Be concise.")
        .provider(OpenAI::from_env()?)
        .model("gpt-5.6-terra")
        .tool(order_status())
        .build()?;

    let session = Engine::new().create(agent);
    let turn = session.send_and_wait("Where is A-417?").await?;

    println!("{}", turn.response);
    Ok(())
}

The whole program. Everruns derives the tool schema, including the argument, from the Rust signature. The model calls it mid-turn and the result goes back before the final response.

The framework

What you get in the crate.

The agent loop stays explicit and embeddable. Default features are offline: a simulated model runs a full turn with no database, server, worker, network connection, or provider credential.

Agents and sessions

Describe an agent once, then create independent multi-turn conversations through an Engine.

Models and providers

Start offline with a simulated model, use OpenAI, or attach your own ChatDriver. No closed provider enum in your application code.

Typed tools and capabilities

Function tools with schemas derived from the signature. Filesystem, shell, web, Lua, and MCP boundaries are opt-in, one feature at a time.

Events, cancellation, and hooks

Observe a live turn as it streams, add awaited behavior at execution boundaries, and stop work cooperatively.

Persistence you choose

Begin with Engine-lifetime memory, add local crash-durable state, or cross deliberately into a distributed host.

One binary, MIT licensed

Rust, no runtime services required, and the same engine that powers the self-hosted and managed platform.

Framework overview →

Framework and Platform

One programming model, two execution boundaries.

Agents, typed tools, sessions, and events are the same objects on both sides. What changes when you move to the shared runtime is where execution and state live, and which capabilities are available.

Portable in the Framework

Files, session storage, current time, compaction, tool search, skills, and any capability your application writes itself with the tool and capability macros.

Hosted by the Platform

Knowledge bases and indexes, memories, subagents and handoff, background tasks and schedules, user hooks, model scouting, and citations need hosted persistence or orchestration. The Framework advertises none of them, rather than promising tools whose stores are absent.

Portable and hosted capabilities →

In your process

                  
                    let session = Engine::new().create(agent);
let turn = session
    .send_and_wait("Where is A-417?")
    .await?;

On the platform

                  
                    curl -X POST "$EVERRUNS/api/v1/sessions" \
  -H "Authorization: Bearer $EVERRUNS_API_KEY" \
  -d '{"agent_id":"agent_..."}'

curl -N "$EVERRUNS/api/v1/sessions/$SESSION_ID/sse" \
  -H "Authorization: Bearer $EVERRUNS_API_KEY"

The platform

What the shared runtime adds.

A control plane, a stateless worker pool, durable execution, a remote API, and a web console. Agents publish to Slack, AG-UI, webhooks, and A2A, with agent triggers for scheduled runs, plus organizations, permissions, budgets, and evaluation.

Durable execution
Stateless worker pool
Remote API and SSE
Apps and channels
Organizations and permissions
Budgets
Evaluation
Web console

The Everruns web console showing the agent registry for an organization

Durability is what makes long work survivable.

Every step is persisted, so nothing depends on a process staying alive. Sessions have no wall-clock ceiling: work can run for days, pause, and resume when infrastructure moves underneath it.

Service restart

Sessions resume from stored workflow state instead of replaying from scratch.

Worker loss

Execution continues because workers are stateless and progress already lives in PostgreSQL.

Long tool run

Event history and in-flight state stay observable over extended tasks.

Open Everruns Cloud Architecture

Open source

Open source core, built for real systems.

MIT licensed and built in Rust. Everruns runs wherever your PostgreSQL does, and the framework runs wherever your binary does. Start with the repo, then follow the docs into the framework, architecture, API, and operations.

github.com/everruns/everruns

Start with the crate.

One dependency and no services. The path to a shared runtime is there when you need it.

Framework quickstart View on GitHub