Explanation: architecture and design rationale
---
# Explanation
> Background on Everruns, why durable execution, why events are the primary store, how the agentic loop and capability layering fit together.
Source:
These pages discuss *why* Everruns is shaped the way it is. They don’t tell you how to do anything (see [How-to guides](https://everruns.com/docs/how-to/)) and they aren’t lookup tables (see [Reference](https://everruns.com/docs/api/)). They’re here to give you a mental model so the other docs make sense. Read these when: * You’re evaluating Everruns and want to understand the design. * A reference page tells you *what* something is but you want to know *why* it exists. * You’re about to make an architectural decision and want to know which guarantees you can rely on. ## Topics * [Concepts](https://everruns.com/docs/getting-started/concepts/), a glossary of the entity model: harnesses, agents, sessions, capabilities, and how they compose into a runtime. * [The agentic loop](https://everruns.com/docs/explanation/agentic-loop/), the reason–act cycle, execution phases, and why turns are bounded. * [Architecture](https://everruns.com/docs/explanation/architecture/), control plane, workers, and the API-first design. * [How Everruns differs](https://everruns.com/docs/explanation/how-everruns-differs/), where Everruns sits next to hosted agent services, graph frameworks, TypeScript frameworks and general durable execution engines. * [Durable execution](https://everruns.com/docs/explanation/durable-execution/), why agents survive crashes, and the trade-offs of a PostgreSQL-backed engine. * [Events as the primary store](https://everruns.com/docs/explanation/events/), why an append-only event log is the source of truth, not a side-channel. * [Command path](https://everruns.com/docs/explanation/command-path/), how the REST API, CLI, MCP and agents all reach the same platform commands, and where they differ.
---
# The agentic loop
> Why agent execution is a bounded reason–act cycle, what execution phases mean, and how multi-step tool flows stay coherent across turns.
Source:
An “agent” is a loop, not a function call. This page explains the loop Everruns runs and why it’s shaped the way it is. ## Reason, then act  Each **turn** runs a bounded cycle: 1. **Reason.** Build the model context from the system prompt, conversation history and tool results, applying context limits and compaction when needed, then call the LLM. The model either produces text or requests tool calls. 2. **Act.** If the model requested tool calls, execute them in parallel. The results become new messages in the conversation. 3. **Loop.** If there were tool calls, go back to step 1. A response without tool calls can finish the turn, unless pending input or a configured completion check continues it. A turn is capped at **500 iterations** by default. That cap exists for one reason: a misbehaving prompt can drive the model into an infinite tool-calling spiral, and an unbounded loop costs real money in tokens. The cap is `max_iterations`, set on the agent and overridable per session (session overrides agent, agent overrides the default). ## Why parallel act? The model often emits several tool calls in one response, “read these three files” or “fetch these two URLs”. Executing them sequentially would serialize independent work for no reason. Everruns runs all tool calls from a single reason step concurrently and only re-enters reason once every call has completed (or failed). This means tool implementations cannot assume ordering between calls within a single act phase. If two tools must run in order, the model has to emit them across two reason steps (iterations). ## Execution phases When an assistant message includes tool calls, the model hasn’t given a final answer yet, it’s just narrating its plan. A message without tool calls is a candidate final answer; pending steering or a completion check can still continue the turn. Everruns labels each assistant message with an **execution phase**: `Commentary` (intermediate, before/between tool calls) or `FinalAnswer` (completed response). Two consumers care: * **The model.** Some providers (OpenAI Responses API on the GPT-5.4 and GPT-5.5 families) accept and return phase annotations on replayed history. Without them, models can mistake earlier commentary for completed answers and stop early on long flows. * **The UI.** Phase tells the chat surface whether to keep the “thinking” indicator on or render the message as a final response. Phases are derived from message state (presence of tool calls) and stored on the message. Providers that don’t accept phases on the wire still get accurate internal tracking. ## Turn lifecycle A normal turn follows this lifecycle (waiting, budget and recovery events can appear between these steps):
```plaintext
turn.started
reason.started → reason.completed (one LLM call)
act.started → act.completed (zero or more tool calls)
... (repeat reason/act until the model produces a final answer or max iterations) ...
turn.completed | turn.failed | turn.cancelled | turn.sealed
```
Streaming text and tool calls produce `output.message.delta` and `tool.started` / `tool.completed` events in between. The full event catalog is in the [Event Reference](https://everruns.com/docs/event-reference/). ## How the Platform resumes a turn The Platform runs each session as a **leased actor**, not as a queue of separate reason and tool tasks. Sending a message stores it and marks its session runnable in one PostgreSQL transaction. A worker leases the session and drives the whole reason–act loop, recording the outcomes needed for recovery in its event log. If the worker dies, its lease expires and another worker folds the recorded turn history to continue. Recorded model responses and tool results are reused. An unfinished tool call is retried only when its declared side-effect class permits it or it never started; otherwise its outcome is recorded as interrupted and unknown. Recovery does not make an external side effect exactly-once. Lease fencing rejects writes from a displaced holder. It cannot undo an external request already in flight. A turn waiting for a human approval, question answer or client-side tool releases its worker until a result makes the session runnable again. The embeddable Framework shares the execution loop, but durability depends on its hosting profile: an in-memory Engine does not survive process exit. See [Durable execution](https://everruns.com/docs/explanation/durable-execution/) and [Framework Architecture](https://everruns.com/docs/framework/architecture/) for the recovery boundaries. ## What happens when the loop “gets stuck” Four failure modes show up in practice: * **Runaway tool calls.** The model keeps calling tools without converging. Mitigated by the iteration cap. Once the cap is reached the engine stops scheduling tool calls and the turn ends with `turn.completed` (the `iterations` field shows the count), not `turn.failed`. * **A tool that hangs.** Tool calls have configurable timeouts. The act phase reports the failure as a tool result so the model can recover on the next reason step. * **The provider stream breaks.** A dropped connection, a stall or a provider server error is retried with backoff, also after the model has streamed part of its answer, as long as it has not called a tool. The retry emits `output.message.started` again for the same message and streams the answer from the beginning, so render `accumulated` rather than the sum of deltas. * **The model rejects the prompt as too large.** Context [compaction](https://everruns.com/docs/advanced/compaction/) runs reactively and the request is retried. The conversation continues with older messages compressed. In all four cases the session stays usable. You don’t lose the conversation; you lose at most one turn.
---
# Architecture
> How Everruns is structured, control plane, workers, REST API, and the design choices behind the API-first, horizontally-scalable, headless approach.
Source:
Everruns is **API-first** and **headless**. The web UI is optional, the SDKs are optional, and the entire platform is reachable through a documented REST API. This page explains why. ## Two processes, one database A running Everruns deployment is two kinds of process plus PostgreSQL: * The **control plane** exposes the REST API, owns auth, serves SSE event streams, and persists all state in PostgreSQL. * **Workers** execute the agentic loop. They lease runnable sessions, call LLMs, run tools, and report results through the control plane. Session state is durable rather than worker-local: another worker can recover a turn after lease expiry, subject to the tool recovery rules.  The control plane can run as several instances behind a load balancer (set `EXPECTED_INSTANCES` so per-instance SSE connection limits are divided across them). Workers scale horizontally: add more for throughput, remove some to save cost. PostgreSQL is the only required piece of stateful infrastructure for a single control-plane instance. Running several needs NATS, which carries live chat events between them; without it they fall back to polling PostgreSQL and report themselves degraded. Valkey is optional. [Physical Architecture](https://everruns.com/docs/advanced/physical-architecture/) describes each deployable component, which ones are required, and how they connect. ## Why a separate worker tier? You could run the agentic loop in the API server process and avoid the extra hop. Everruns doesn’t, for three reasons: 1. **LLM calls are long.** A single turn easily spends 10–60 seconds in network I/O. Tying that to the request thread caps API throughput and makes deploys painful. 2. **Failure isolation.** A misbehaving tool that hangs the worker process should not take down the API. They’re separate concerns and they get separate processes. 3. **Durability.** Workers can crash and the session lease can be reclaimed by another worker. Tying execution to a request would lose the work the moment the connection drops. The control plane and workers talk over gRPC inside your VPC. End users only ever see the REST API. ## Why headless Most agent platforms ship a chat UI and treat the API as a side-channel. Everruns inverts this: the API is the product, and the UI is one client among many (the SDK, the CLI, customer-built apps, and the bundled management UI all consume the same endpoints). The consequences: * Every feature has to land in the API before it lands in the UI. There are no “UI-only” features. * You can ship Everruns as backend infrastructure for a product whose UI looks nothing like ours. * Multitenancy, auth, and quotas are enforced at the API layer, so you cannot accidentally bypass them by using a different client. The [management UI](https://everruns.com/docs/features/ui/) exists for operators, configuring providers, browsing sessions, debugging events, not as the primary interaction surface. It is not required in production. ## Why REST + SSE, not WebSockets Sessions need a bidirectional flow: the client posts messages, the server streams events. WebSockets would be a natural fit, but Everruns uses **REST for writes and SSE for reads**. * REST is cacheable, debuggable with `curl`, and works through ordinary reverse proxies. * SSE is a one-way streaming protocol that works through HTTP/1.1, HTTP/2, and HTTP/3 with no special infrastructure. * The events you’d want to push to the server (cancel, new message) are infrequent enough that a `POST` is the right shape. Combined with `since_id` resumption and 5-minute connection cycling, clients reconnect routinely and resume without missing events. ## Multitenancy and isolation Everruns is organization-scoped end-to-end: * All resources (agents, sessions, capabilities, providers) belong to exactly one organization. * API keys carry an org membership; the API enforces the boundary on every request. * Sessions are isolated at the database row level, there is no cross-session filesystem or key-value access. * Secrets are encrypted at rest with envelope encryption: each value gets its own data key, wrapped by a rotatable deployment-wide key. ## Where the boundaries are Things the control plane owns: auth, session actor leases and runnable index, background task queue, event log, virtual filesystem, key-value storage, capability registry, MCP catalog. Things workers own: nothing persistent. They access session state through control-plane gRPC, drive leased turns, and report back; they do not connect to PostgreSQL directly. Things your application owns: the agent definitions, the prompt design, and the channel-specific glue (Slack apps, webhooks, schedules). The platform is intentionally neutral about *what* you build with it. The platform is also neutral about the model vendor: agents can use OpenAI, Anthropic, Gemini, and the other [providers](https://everruns.com/docs/providers/), and switching one does not change the agent definition. ## Further reading * [Physical Architecture](https://everruns.com/docs/advanced/physical-architecture/): PostgreSQL, NATS, Valkey, workers, and how they connect. * [Concepts](https://everruns.com/docs/getting-started/concepts/): the entities the API exposes. * [Durable execution](https://everruns.com/docs/explanation/durable-execution/): how workers recover a crashed turn. * [API Reference](https://everruns.com/docs/api/): every endpoint.
---
# Command Path
> How the REST API, the CLI, MCP, the Platform capability and workers all reach the same platform commands, and where each surface differs.
Source:
Everruns has one set of platform commands, such as `create_agent`, `update_harness` or `list_sessions`, and several ways to reach them: the REST API, the `everruns` CLI, the `/mcp` endpoint, the [Platform capability](https://everruns.com/docs/capabilities/platform/), and the `everruns` command inside an agent’s shell. This page shows how each of those surfaces gets to a command, so you can tell what behaves the same everywhere and what does not.  ## One command, one run path Each operation is one command with a name, a parameter schema, an HTTP method and path, and an authorization policy. Every command registers itself in the server’s command registry, and every surface ends at the same `Command::run`. That is where the policy check, tracing and metrics happen, so authorization works the same whichever way a caller arrived. There are two ways into `Command::run`: * **Typed, from a REST route.** A handler under `/v1/agents`, `/v1/sessions` and so on builds the command from the request and runs it directly. * **By name.** Everything else looks the command up by its name and turns the JSON parameters into the typed command, using the schema the command registered. Unknown names, unknown parameters and wrong types fail here, before anything runs. ## Surfaces | Surface | Who uses it | How it reaches a command | | ------------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | REST API (`/v1/...`) | UI, SDKs, scripts | Typed, from the route | | `POST /v1/commands/{name}` | the CLI, any HTTP client | By name, with optional `Idempotency-Key` | | `everruns` CLI | people in a terminal | Parses the command line locally, then calls `POST /v1/commands`; a few commands that need local files or streaming (`login`, `files`, `chat`, `agents create -f`) call REST directly | | `/mcp` `execute` and `query` | external MCP clients | Runs a shell script in which `everruns ` and the flat names (`create_agent`) are commands; `query` refuses anything that changes state | | Platform capability | agents with the `discover`, `query`, `execute` tools | The same scripted toolset as `/mcp`, called from the worker over gRPC | | `everruns` in the agent’s shell | agents in a shell-only harness | Parses the command line in the worker, then sends the command name and parameters over gRPC | Workers never read the database. When an agent on a worker runs a platform command, the worker sends it to the control plane, which reloads the session, checks again that the session really has the Platform capability, and runs the command as the session’s owner in the session’s organization. It never trusts an identity the worker sends. ## One grammar The CLI, the scripted toolset and the agent’s shell all parse `everruns --flags` with the same parser, built from a command contract that the server generates from its registry. That is why `everruns agents list --limit 10` means the same thing typed in a terminal and in an agent’s shell: the same flags, the same short options, the same help, and the same errors for an unknown flag or a missing required one. See [CLI](https://everruns.com/docs/features/cli/#platform-commands) for the commands and [Platform](https://everruns.com/docs/capabilities/platform/) for the agent-facing tools. ## Where the surfaces differ * **Hand-written CLI commands.** A few CLI commands do local work no server command can, such as reading a definition file or syncing files, so they keep their own flags. Every other CLI command comes from the contract. * **Flat names.** `/mcp` and the Platform capability also accept flat names like `create_agent --name ...`, for scripts written before the noun-verb spelling existed. * **Read-only mode.** `query` accepts only commands that do not change state; `execute` accepts any command the caller is allowed to run. * **Retries.** Only `POST /v1/commands` takes an `Idempotency-Key`, because it is the surface a network sits in front of. The CLI sends one on every command and retries dropped connections with the same key. See [CLI retries](https://everruns.com/docs/features/cli/#retries). On every surface, a command that changes an entity saves the change, its entry in the entity’s history and, over `POST /v1/commands`, the response a retry with the same `Idempotency-Key` gets back, all together. If any of them cannot be saved, the command fails with a server error and nothing changes, so a retry is safe. A few commands that call other services while they run, such as creating a provider (which discovers its models) or installing a plugin, save the change first and its history after.
---
# Durable execution
> Why Everruns persists every step of agent execution to PostgreSQL and runs each session as a leased actor: the guarantees that gives, and the trade-offs.
Source:
The word “durable” in “durable agentic harness engine” means a specific thing: **recorded execution state survives a process restart, so a turn can recover from its log**. This page explains why that matters, how it works, and what it costs. ## The problem An agent turn looks simple from the outside, send a message, get a streamed response. Internally it’s a chain of network calls that each take seconds: 1. Call the LLM provider. 2. Parse tool calls, dispatch them. 3. Wait for each tool to return. 4. Call the LLM again with the results. 5. …repeat… Anywhere in that chain, the worker process can crash, the container can be reaped, the network can blip. A naïve implementation loses all the work done so far and forces the user to retry. For a 30-second turn that already burned tokens, this is unacceptable. ## The mechanism Everruns treats each session as an **actor** whose state is its event log. Every message, model response, tool call and tool result is appended to the session’s log in PostgreSQL before anything acts on it. A turn is never held anywhere else: the log is enough to pick it up again. * Sending a message stores it and marks the session runnable, in one transaction. * A worker leases the runnable session and runs the whole turn: reason, act, reason again, until the model answers or the turn waits on a person. * The worker renews its lease every few seconds while the turn runs, and gives it back when the turn ends.  Messages that arrive while a turn runs reach that turn before its next model call. A message that arrives just as the turn ends starts the next turn. A turn waiting on a person (a client-side tool, an approval, a question) holds no worker: the answer is recorded in the log and the session becomes runnable again. When a worker crashes mid-turn, its lease stops being renewed and expires after about ten seconds. Another worker leases the session, reads the turn’s part of the log and continues the turn where it stopped. The application sees a momentary stall in the SSE stream, then it continues.  Each lease has a fence number. The control plane rejects authoritative writes from a holder whose lease expired or was taken over. The displaced worker stops when it observes lease loss; fencing cannot revoke an external request that was already sent. ## Why a custom engine The obvious alternative is Temporal (or Cadence, or Restate). Everruns deliberately built its own minimal durable execution instead: session leases and the event log for turns, and `everruns-durable`, a generic, published Rust crate (task queue, event log, schedules, retries, dead letter queue, circuit breakers) with no agent concepts, for the background work around them. The reasoning: 1. **Single dependency.** PostgreSQL is the only required stateful infrastructure for a single control-plane instance. Multiple control-plane instances need NATS for live event delivery; without it they report degraded polling. Valkey is optional. Operators don’t need to run a second cluster with its own ops story. 2. **Co-located with the rest of the platform.** Workflow events and session events live in the same database, in the same transaction when needed. There’s no eventual consistency between “what happened” and “what was reported.” 3. **Tight scope.** Everruns runs agentic workflows specifically, limited fan-out, short-to-medium duration, well-understood failure modes. We don’t need the full Temporal feature set, and the operational surface area of a tightly-scoped engine is much smaller. The trade-off: no multi-region replication beyond what PostgreSQL itself offers, no language-agnostic SDK (the engine is a Rust library), no visual workflow designer. For agent execution these are not missed. ## Guarantees What durable execution gives you: * **Recorded outcomes survive a crash.** If a worker dies, another worker resumes the turn from its log. A model response already recorded is not requested again, and an answer already recorded is not given twice. * **Persisted tool results.** Tool calls are persisted by their result, not their attempt, so a tool whose result was recorded is not re-run. A call cut off before its result was recorded runs again only when that is safe: its tool declares it read-only or idempotent, or the call never started. A call that must run at most once does not start until its `tool.started` event is stored, so a call without one never ran. Any other unfinished call is recorded as interrupted and the model is told its outcome is unknown. Each call also carries an idempotency key that stays the same when it runs again, sent to MCP servers in the request’s `_meta` as `io.everruns/idempotency-key`, so a server or gateway that honors it can drop the repeat. * **One authoritative lease holder per session.** Fenced writes prevent a displaced worker from committing turn events. In-flight external effects still require the tool-specific safeguards below. * **Authoritative history.** Reloading a session reads back the same persisted message sequence, which makes traces and exports authoritative. What it doesn’t give you: * **Idempotence of side effects.** A tool that declares itself idempotent is run again after a crash, so if it POSTs to an external API it must make the repeat harmless, for example by forwarding the call’s idempotency key (`ToolContext::idempotency_key`). An unfinished tool call with the default at-most-once declaration is not automatically replayed after a recorded start, but a crash after it acted and before its result was recorded leaves its outcome unknown. * **Real-time latency guarantees.** Persisting durable events adds storage latency and load; ephemeral streaming deltas can bypass PostgreSQL. LLM latency often dominates a turn, but that does not make storage overhead negligible under every workload. ## Durability in the Framework Rust applications that embed the [Framework](https://everruns.com/docs/framework/) share the execution kernel, but must choose a hosting profile that provides the required recovery boundary. `Engine::new()` retains sessions only for that Engine’s lifetime. Native `hosting::SqliteHosting` persists admission and session state; register the exact agent builds and environment factories and run its supervisor for independent recovery. External hosting supplies its own durable authority and activation. Legacy `LocalConfig` storage has a weaker recovery boundary and is not equivalent to native durable Engine hosting. See [Framework Architecture](https://everruns.com/docs/framework/architecture/). ## When the database becomes the bottleneck Everruns is designed to run on a single PostgreSQL primary. Read replicas help for reporting; write-heavy session loads are kept manageable by keeping event payloads compact. In practice, LLM provider rate limits tend to cap throughput long before the database does. ## Further reading * [The agentic loop](https://everruns.com/docs/explanation/agentic-loop/), what each step inside a turn looks like. * [Architecture](https://everruns.com/docs/explanation/architecture/), how the control plane and workers interact.
---
# Events as the primary store
> Why Everruns uses an append-only event log as the source of truth for sessions instead of a conventional message table.
Source:
Most chat systems store messages in a `messages` table and emit events as a side-channel. Everruns inverts this: the **event log is the source of truth**, and messages are derived from events. This page explains why. ## What an event is An **event** is an immutable record of something that happened in a session. Examples: * A user submitted a message. * The LLM produced a token of streaming output. * A tool was called. * A tool completed. * A turn started, completed, failed, or was cancelled. An event has a stable ID (UUID v7), a type in dot notation (`turn.completed`, `output.message.delta`), and a typed payload. Persisted events receive a session-local monotonic sequence number; clients must tolerate events without one. Persisted events are append-only during normal execution. Retention archival and explicit session deletion can remove stored rows. Streaming deltas can be ephemeral, as described below. The full catalog is in the [Event Reference](https://everruns.com/docs/event-reference/). ## Why not a `messages` table? A conventional design has: * A `messages` table for the conversation. * A separate change-feed (Kafka, NATS, a `pg_notify` channel) for real-time updates. * A traces table for observability. This gives you three sources of truth that can disagree. When the SSE stream and the messages table disagree, which one is right? When a message is edited mid-stream, what does the change-feed say? When a tool call is observed but no resulting message is persisted, did it happen? Everruns avoids the question by making the event log authoritative for all three concerns: * **Conversation history** is reconstructed from events. A `Message` is a projection of a contiguous range of `output.*` and `input.*` events. * **The real-time stream** combines persisted events with live streaming deltas. Resumption with `since_id` reads persisted history; ephemeral deltas are not a durable replay contract. Completed-message events carry the full content. * **Tracing and replay** consume the log directly. Every LLM call, tool execution, and state transition is there. One log, one ordering, one source of truth. ## Consequences This design has visible consequences in the API: * **You can’t UPDATE a message.** What you can do is append a new event that supersedes part of the projection. Messages can’t be edited because they don’t exist as rows. * **Ordering is by sequence number, not timestamp.** Two events with the same wall-clock time still have a strict order. Timestamps are informational. * **Resumption uses stored history.** `since_id` resumes persisted events after a cursor. Retention and session deletion bound what remains available; clients must not rely on replaying ephemeral deltas. * **Audit shares the execution record.** Persisted lifecycle events and outcomes are ordered in the session log; they are not a record of every transient token or external effect. ## Compatibility guarantees Because events are the API contract, Everruns treats them like a public protocol. The compatibility rules are: | Change | Allowed | | ------------------------------------------ | ------------------------------------------- | | Add a new event type | yes | | Add an optional field to an existing event | yes | | Add a new enum value to an existing field | yes | | Remove a field | no, breaking change | | Change the type of a field | no, breaking change | | Reuse a sequence number | no, sequence numbers are atomic per session | Consumers must follow the dual: ignore unknown fields, ignore unknown event types, and treat optional fields as optional. The SDK clients do this automatically. ## What about volume? A long agent session can produce thousands of events, streaming deltas alone can be hundreds per turn. Two things keep this manageable: * **Streaming deltas can bypass PostgreSQL.** With NATS configured, designated text, thinking, tool-output and voice-transcript deltas are ephemeral; their completed events retain the final content. Without NATS these deltas are persisted. * **Delta events are batched** at \~100ms. The model produces tokens faster than that, but consumers don’t need every token as a separate event. * **Sessions are bounded by intent, not duration.** Even busy sessions rarely exceed five-figure event counts. PostgreSQL handles that easily. For very long-running sessions, [context compaction](https://everruns.com/docs/advanced/compaction/) reduces the *prompt* size but does not modify the event log. The full history remains available via [Infinity Context](https://everruns.com/docs/capabilities/infinity-context/) and the event API. ## Further reading * [Event Reference](https://everruns.com/docs/event-reference/), every event type and payload. * [The agentic loop](https://everruns.com/docs/explanation/agentic-loop/), what produces events during a turn. * [How-to: stream events](https://everruns.com/docs/how-to/stream-events/), practical patterns.
---
# How Everruns differs from other agent runtimes
> Where Everruns sits next to other agent runtimes and frameworks, what it shares with them, where it differs, and when another tool is the better fit.
Source:
People often ask how Everruns compares with other ways to run agents. This page answers that plainly. It describes design choices, not winners: several of these tools are good choices for problems Everruns does not try to solve. Facts about other projects were checked against their own documentation in July 2026 and can change; follow the links for the current state. ## What Everruns is * **A Rust framework and a durable runtime, MIT licensed end to end.** The `everruns` crate runs agents inside your own binary. The platform adds a control plane, stateless workers, a remote API and a web console on your own PostgreSQL. There is no paid edition and no feature held back. * **Durable Platform execution.** The Platform resumes turns from persisted session history after worker loss, with explicit handling of uncertain tool outcomes. The embedded Framework defaults to volatile memory; choose durable hosting when it must recover across process exit. See [Durable execution](https://everruns.com/docs/explanation/durable-execution/). * **Provider neutral.** OpenAI, Anthropic, Gemini, Bedrock, OpenRouter and others, plus your own driver. See [Providers](https://everruns.com/docs/providers/). * **A community project.** A free, non-commercial project by [Mykhailo Chalyi](https://chaliy.name) and contributors, pre-1.0, so APIs still change. ## Hosted agent services Examples: [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview). These run the agent harness for you on the vendor’s infrastructure. Sessions are stateful and resume after pauses, and you operate nothing. * **Where it differs:** Everruns runs on your infrastructure and keeps session state in your database. A hosted service keeps state with the vendor and is usually tied to that vendor’s models. * **Choose the hosted service when** you are committed to one model vendor and want no infrastructure at all. ## Graph frameworks with a deployment platform Examples: [LangGraph and LangSmith Deployment](https://www.langchain.com/langsmith/deployment). The framework is open source and models an agent as a graph; a separate deployment platform adds durable execution, an API and tracing. That platform is proprietary, and self-hosting it is part of a commercial tier. * **Where it differs:** the Everruns runtime and console are open source and self-hostable without a license tier. Everruns models a session as a reason-act loop with tools rather than an explicit graph. * **Choose a graph framework when** you want explicit control over each step as a graph, or you already build on LangChain. ## TypeScript agent frameworks Examples: [Mastra](https://mastra.ai). A TypeScript framework with workflows, memory and model routing, deployed mostly on serverless platforms. Workflows suspend and resume, and session length follows the hosting platform’s limits. * **Where it differs:** Everruns is Rust, runs as long-lived workers on PostgreSQL, and ships a multi-tenant control plane with organizations, permissions, budgets and a console instead of leaving them to the application. * **Choose a TypeScript framework when** your application is TypeScript and serverless, and agents fit inside a request or a short workflow. ## General durable execution engines Examples: Temporal, Restate, Inngest. These make arbitrary code durable. You can build an agent on them, and you write the agent loop, tool handling, model calls and the UI yourself. * **Where it differs:** Everruns is narrower. It is an agent runtime with the loop, tools, sessions, channels and a console built in. * **Choose a general engine when** agents are a small part of a larger set of durable workflows you already run on it. ## Talk to us If a comparison here is wrong or out of date, tell us on [Discord](https://everruns.com/discord) or open an issue.