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, Engine, OpenAI};

let agent = Agent::builder()
    .instructions("Answer in one short sentence.")
    .provider(OpenAI::from_env()?)
    .model("gpt-5.6-terra")
    .build()?;

let engine = Engine::new();
let turn = engine.create(agent).send_and_wait("Say hello.").await?;
println!("{}", turn.response);

No database, server or worker is required — an agent runs inside your process. A model provider is: pick one from Supported providers, or use the test simulator when writing tests.

Choose the right surface

Surface	Use it for
Framework	Rust applications that build and run agents in process through everruns
Advanced host crates	Low-level execution-host composition through everruns-host and focused siblings
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. Hosts that must replace storage or orchestration cross into custom backends.

Start here

• Quickstart, install the crate and run an offline agent.
• Architecture, understand Agent, Engine, Session, and the shared immediate/durable execution kernel.
• Agents, instructions, files, workspaces, MCP, plugins, and context inspection.
• Workspace security, configure portable read and write scopes with secure defaults.
• Workspaces and Environments, bind sessions to isolated or explicitly shared backend-owned heads.
• Models and providers, the model/provider split and the open provider boundary.
• Supported providers, every driver that ships today and what each one supports.
• Direct model calls, one prompt and one answer without an agent.
• Direct decision, a calibrated number rather than prose, without an agent.
• Model catalogs, ask a provider which models it offers and what each supports.
• Credentials, each driver’s own vendor-standard environment variables.
• 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.
• Answer agent questions, implement AskUser so your application answers the agent’s structured questions.
• Canonical events, render or record bounded canonical event envelopes.
• Persistence, Engine-lifetime memory and crash-durable local state.

Extend and operate

• Custom providers, attach a custom ChatDriver without changing a closed enum.
• Capabilities, configure the optional standard policy bundle and open references, or package typed tools with stable metadata and lifecycle context.
• Capability integrations, opt into filesystem, shell, web, Lua, and MCP implementation boundaries.
• Portable and hosted capabilities, understand the Framework/Platform implementation boundary.
• Custom backends, cross into low-level host composition deliberately.
• Testing and simulation, deterministic tests without credentials.
• Runnable examples, complete programs maintained with the crate.
• Serve (experimental), attribute macros, file-layout discovery and a manifest, served over the Everruns server /v1 API.