# Everruns - Build capable AI agents in Rust

**Navigation:** [Vision](/vision/) | [Products](/products/) | [Use Cases](/use-cases/) | [Blog](/blog/) | [Docs](https://everruns.com/docs/) | [GitHub](https://github.com/everruns/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.

```bash
cargo add everruns
```

## Three ways to run Everruns

- **01 Framework** - A Rust crate inside your own binary. No database, no server, no services to run. [Framework quickstart](https://everruns.com/docs/framework/quickstart/)
- **02 Self-hosted** - The shared runtime in your infrastructure, on your PostgreSQL, with the control plane and UI. [Docker Compose quickstart](https://everruns.com/docs/getting-started/docker-compose/)
- **03 Everruns Cloud** - The same runtime and production operations, managed for you. Built-in model access with $5 of starter credit, or bring your own keys. [How Cloud works](/cloud/)

### main.rs

```rust
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-6.1-sol")
        .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.

---

## 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](https://everruns.com/docs/framework/)

---

## 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.

### In your process

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

### On the platform

```bash
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"
```

[Portable and hosted capabilities](https://everruns.com/docs/framework/capability-boundaries/)

---

## 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

### 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](https://app.everruns.com) | [Architecture](https://everruns.com/docs/explanation/architecture/)

---

## 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: https://github.com/everruns/everruns

### A family of tools, not a single repository.

Everruns is the durable core, and the tools built around it stand on their own. Each is MIT-licensed and useful without adopting the platform.

- **[Bashkit](/products/bashkit/)**: A virtual Bash interpreter with a virtual file system, so agents can run shell workflows in a multi-tenant sandbox without touching a real machine.
- **[Yolop](/yolop/)**: A terminal coding agent in one binary: plans, edits, runs, and verifies code in your repository, with durable sessions from the embedded runtime.
- **[Mira](/mira/)**: A code-first evaluation framework for agents, for measuring whether a change actually made the agent better.
- **[Fetchkit](https://github.com/everruns/fetchkit)**: AI-friendly web fetching as a CLI, an MCP server, and a library.

---

## Start with the crate.

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

[Framework quickstart](https://everruns.com/docs/framework/quickstart/) | [View on GitHub](https://github.com/everruns/everruns)

---

## Stay updated

Subscribe for occasional email about new releases and features using the subscribe form in the footer of any page on https://everruns.com/. For updates about the managed edition, subscribe on https://everruns.com/cloud/.

---

## About

With love from Ukraine

(c) 2026 Everruns. MIT License.

Website: https://everruns.com

---

## Machine-readable entry points

- [/llms.txt](https://everruns.com/llms.txt): index of this site written for language models.
- [/llms-full.txt](https://everruns.com/llms-full.txt): every page on this site as one document.
- [/auth.md](https://everruns.com/auth.md): how an agent obtains Everruns API credentials.
- [/.well-known/ai-catalog.json](https://everruns.com/.well-known/ai-catalog.json): ARD capability manifest.
- [/.well-known/mcp/server-card.json](https://everruns.com/.well-known/mcp/server-card.json): MCP server card for Everruns Cloud.
- [/.well-known/agent-skills/index.json](https://everruns.com/.well-known/agent-skills/index.json): agent skills for working with Everruns.

Any page on this site serves Markdown to `Accept: text/markdown`.