Build capable AI agents in Rust. Run them where they belong.
Everruns is an open-source framework for building AI agents directly in Rust applications. Define agents, attach models and typed tools, run multi-turn sessions, and observe execution through one application-facing API.
Use the framework in your application. When you need a shared runtime and production operations, run the Everruns platform yourself or use Everruns Cloud.
Build with the framework · Read the docs · Use Everruns Cloud
Add the application-facing crate:
cargo add everruns --features openai
cargo add tokio --features macros,rt-multi-thread
export OPENAI_API_KEY=sk-...Then define a typed tool, give it to an agent, and run a turn:
use std::time::{SystemTime, UNIX_EPOCH};
use everruns::{Agent, Engine, OpenAI};
#[everruns::tool]
async fn current_time() -> Result<String, String> {
let seconds = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|error| error.to_string())?
.as_secs();
Ok(format!("{seconds} seconds since the Unix epoch"))
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let agent = Agent::builder()
.name("assistant")
.instructions("Use current_time when asked about time. Be concise.")
.provider(OpenAI::from_env()?)
.model("gpt-5-mini")
.tool(current_time())
.build()?;
let session = Engine::new().create(agent);
let turn = session.send_and_wait("What time is it?").await?;
println!("{}", turn.response);
Ok(())
}Everruns derives the tool schema from the Rust function, lets the model call it during the turn, and returns the result before producing the final response. Continue the framework quickstart.
Note: Everruns is under active development. Expect rapid changes and experimental features.
The everruns crate keeps the application-facing agent
loop explicit and embeddable:
- Agents and sessions — describe an agent once, then create independent,
multi-turn conversations through an
Engine. - Models and providers — start offline, use OpenAI, or attach a custom provider without coupling application code to a closed provider enum.
- Typed tools and capabilities — give agents function tools and opt into filesystem, shell, web, Lua, and MCP boundaries deliberately.
- Events, cancellation, and lifecycle hooks — observe a live turn, add application behavior at execution boundaries, and stop work cooperatively.
- Persistence and execution choices — begin with engine-lifetime memory, add local crash-durable state, or cross deliberately into a distributed host.
| Framework | Self-hosted platform | Everruns Cloud |
|---|---|---|
| Start here. Embed Everruns in the Rust application you are building; you own the process, deployment, integrations, and data path. Framework quickstart → |
Run the shared runtime in infrastructure you manage when you need a control plane, server, workers, UI, remote API, and durable execution. Docker Compose quickstart → · Architecture → |
Use the shared runtime and production operations without operating the platform yourself. Everruns Cloud quickstart → · Open app.everruns.com → |
The Platform, self-hosted or on Everruns Cloud, adds durable execution, a stateless worker pool, a web UI, and a remote API. It also publishes agents to Slack, web chat, A2A, webhooks, schedules, voice, HTTP, and MCP; manages organizations and permissions; and supports observation, budgeting, and evaluation.
Platform capabilities · Channels · Durable execution · Observability
Full documentation lives at everruns.com/docs.
- Everruns Framework — build and run agents inside a Rust application
- Framework quickstart — install the crate and configure a provider
- Docker Compose quickstart — run the full platform stack
- How-to guides — give agents tools, stream events, publish to Slack, and enforce budgets
- API reference — OpenAPI 3.0
- SDKs — Rust, Python, and TypeScript clients
- Docs as text —
llms.txtindex, per-topic Markdown sets, and the OpenAPI schema for agents
Everruns runs untrusted agent and tool code for multiple tenants, so security is a core design goal. Threats are tracked with stable IDs across authentication, tenant isolation, permissions, tool execution, LLM integration, sandboxes, durable execution, and channel integrations, each with a documented mitigation and, where feasible, test coverage.
- Threat model — full analysis, mitigation status, and accepted risks
- Security testing — threat-model tests, failure injection, DeepSec scanning, and supply-chain checks
- Security policy — report a vulnerability
See CONTRIBUTING.md for local development setup and AGENTS.md for the conventions used by both human and AI contributors.
The crate layout describes ownership and the guards that keep database connections in the server and durable crates.
MIT