Open-source agent runtime

Durable AI agents on the Postgres you already run.

Everruns is an MIT-licensed runtime and operator console for long-running AI agents. Sessions, tool calls, and event streams persist as readable rows in your own PostgreSQL, so agents can run for days or pause for weeks on infrastructure you own.

Read the docs View on GitHub

License MIT — runtime and console

State Your PostgreSQL, readable rows

Sessions No wall-clock ceiling

Platform signals

Durable execution is the foundation.

Everruns is headless by design: everything works through the API and event streams, with provider management and operator workflows in the same system. The console is part of the package, never a requirement.

Harnesses, a layer most platforms skip

The durable execution loop an agent runs on is a first-class, reusable object. Agents are configuration on top of it.

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.

Architecture

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.

Product surface

Built as a platform, not just a runtime.

Agents are configuration. Harnesses — the durable execution loops they run on — are first-class objects too, alongside skills, capabilities, MCP servers, apps, and the operator console.

Harnesses

Reusable durable execution loops with their own surface in the product. Define how agents reason and act once, then run many agents on it.

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

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.

Execution

Daytona

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

Evaluation

Braintrust

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

Model interface

Open Responses

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

Tool bridge

MCP servers

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

Local setup

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.

Download the published Docker Compose example.
Start the control plane, workers, UI, and database with local secrets configured.
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 try locally

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

Reliability

Durability keeps long-running work resumable.

Sessions have no wall-clock ceiling: work can run for days, pause for weeks, and resume when infrastructure moves underneath it. Every step is persisted, so nothing depends on a process staying alive.

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.

Operator console

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. The operator console ships with the open-source core, not as a paid add-on.

Create agent

Name and descriptionOptional model overrideCapability attachmentMarkdown 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

Open source core, built for real systems.

MIT licensed and built in Rust as a single low-footprint service. Everruns is infrastructure you own: it runs wherever your PostgreSQL does and outlives vendor platform churn. Start with the repo, then follow the docs into architecture, API, and operations.

github.com/everruns/everruns