# Everruns - Durable Runtime for Long-Running AI Agents

**Navigation:** [Vision](/vision/) | [Use Cases](/use-cases/) | [Blog](/blog/) | [Docs](https://docs.everruns.com/) | [GitHub](https://github.com/everruns/everruns)

---

> The durable runtime for long-running AI agents.

Everruns combines durable execution, a clear system shape, integration surfaces, and an operator console for teams running long-lived AI workflows.

Primary CTA: Read the docs (https://docs.everruns.com/)
Secondary CTA: View on GitHub (https://github.com/everruns/everruns)

Platform signals:

- **Platform shape:** Harnesses / Agents / Apps
- **Execution:** Persisted in PostgreSQL
- **Interfaces:** API / SDK / CLI / UI

## Durable execution is the foundation.

Everruns brings together an API-first control plane, extension surfaces, provider management, and operator workflows in one system.

### REST API and SSE events

Create agents and sessions, then stream events back to clients in real time.

### Capabilities, skills, MCP servers, apps

Execution behavior, tool bridges, and deployment surfaces are first-class parts of the system.

### Provider, member, and API key management

The settings layer covers the provider, member, and API key controls teams expect from a real platform.


---

## A system shape teams can reason about.

State, execution, and interfaces are separated cleanly so teams can understand how the platform behaves under real load.

### Control plane

REST API, agent definitions, session lifecycle, secrets, and event fan-out.

### Workers

Stateless executors running the reason to act loop from persisted state.

### Storage

PostgreSQL stores workflow state, events, configuration, and encrypted secrets.

### Interfaces

Use the API, SDKs, CLI, or the management UI depending on the team and task.

---

## Built as a platform, not just a runtime.

Everruns spans harnesses, agents, skills, capabilities, MCP servers, apps, and the operator console around them.

### Harnesses

Reusable durable execution units with their own dedicated surface in the product.

### Agents

Configurable AI workers with optional model overrides, capabilities, and markdown prompts.

### Skills

Instruction packages discovered from the workspace filesystem and activated per session.

### Capabilities

A registry of tools and behaviors spanning execution, browser, network, storage, UI, and session control.

### MCP Servers

Dedicated surface for external model-context providers and tool bridges.

### Apps

Deployment layer that connects agents to channels such as Slack.

---

## Integrations belong in the core story.

Execution sandboxes, evaluation tooling, model interfaces, and MCP bridges make Everruns useful inside real stacks. This matters more than local setup.

### Daytona

Category: Execution

Use isolated cloud sandboxes for code execution without changing the durable runtime model.

### Braintrust

Category: Evaluation

Connect observability and evaluation workflows to agent traces and real runs.

### Open Responses

Category: Model interface

Use a vendor-neutral model layer instead of rewriting integrations for every provider.

### MCP servers

Category: Tool bridge

Attach external tools and context providers through a platform-level integration surface.

---

## Try the stack locally in a few minutes.

Docker Compose is useful for evaluation and onboarding. Production deployments still depend on your own topology, providers, and operational model.

1. Download the published Docker Compose example.
2. Start the control plane, workers, UI, and database with local secrets configured.
3. Create an agent, open a session, and stream events back to the client.

A good way to understand the stack quickly before wiring it into a larger environment.

Quick local try: https://docs.everruns.com/getting-started/docker-compose/

API shape:

```bash
curl -X POST http://localhost:9300/api/v1/agents \
  -H "Content-Type: application/json" \
  -d '{"name":"Assistant","system_prompt":"You are helpful."}'

curl -X POST http://localhost:9300/api/v1/sessions \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"{agent_id}"}'

curl -N http://localhost:9300/api/v1/sessions/{session_id}/events
```

For most teams, the faster signal is the API: create an agent, start a session, and stream events.

---

## Durability keeps long-running work resumable.

Durability matters because long-running work stays observable and resumable 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 remain observable over extended tasks.

---

## Operate the platform with the same clarity you build on it.

Create agents with prompts and capabilities, then manage providers, API keys, members, and connections from the same system.

Create agent fields:

- Name and description
- Optional model override
- Capability attachment
- Markdown system prompt editor

### LLM Providers

Configure providers first, then manage the models available to agents.

### API Keys

Programmatic access is managed inside the operator console, not hidden in separate tooling.

### Members

Membership management lives in settings alongside providers, API keys, and connections.

### Connections

Personal auth and integration surfaces are part of the real operator workflow.

---

## Open source core, built for real systems.

MIT licensed and built in Rust. Start with the repo, then follow the docs into architecture, API, and operations.

GitHub: https://github.com/everruns/everruns

---

## About

With love from Ukraine

(c) 2026 Everruns. MIT License.

Website: https://everruns.com