Everruns Framework

The Everruns Framework is the application-facing everruns crate. Use it to describe agents, attach models and tools, run multi-turn sessions, observe events, and embed agent execution directly in a Rust process.

use everruns::{Agent, Model};

let agent = Agent::builder()
    .instructions("Answer in one short sentence.")
    .model(Model::simulated("Hello from Everruns."))
    .build()?;

let turn = agent.session().run("Say hello.").await?;
assert_eq!(turn.response, "Hello from Everruns.");
# Ok::<(), Box<dyn std::error::Error>>(())

The default build runs this example offline. A database, server, worker, network connection, and provider credential are not required.

Choose the right surface

Surface	Use it for
Framework	Rust applications that build and run agents in process through everruns
Runtime	Low-level execution-host composition and existing everruns-runtime 0.17.x applications
SDKs	Remote clients that call a running Everruns server
Platform	The control plane, server, workers, UI, and durable deployment

Normal library users should start with the Framework. See Runtime compatibility before importing everruns-runtime directly.

Start here

• Quickstart — install the crate and run an offline agent.
• Agents — instructions, files, workspaces, MCP, plugins, and context inspection.
• Workspace security — configure portable read and write scopes with secure defaults.
• Models and providers — simulation, OpenAI, and the open provider boundary.
• Tools and macros — typed function tools through everruns::tool.
• Sessions — independent, multi-turn conversations.
• Session work and wakes — immediate and scheduled work with explicit delivery and restart semantics.
• Session History and Resume — bounded transcript pages and typed continuation.
• Events and cancellation — observe a live turn and stop work cooperatively.
• Lifecycle hooks — run awaited application behavior at execution boundaries.
• Canonical events — render or record the lossless event protocol.
• Persistence — Agent-lifetime memory and crash-durable local state.

Extend and operate

• Custom providers — attach a custom ChatDriver without changing a closed enum.
• Advanced capabilities — package typed tools with stable metadata and lifecycle context.
• Custom backends — cross into low-level host composition deliberately.
• Testing and simulation — deterministic tests without credentials.
• Runnable examples — complete programs maintained with the crate.