Eleven weeks since the [July roundup](/blog/whats-new-july-2026/), and thirty-three platform releases, [v0.17.8](https://github.com/everruns/everruns/releases/tag/v0.17.8) through [v0.31.0](https://github.com/everruns/everruns/releases/tag/v0.31.0). Most are steady, incremental work. One change is not: Everruns is now a library you add to your own program. The [**Everruns Framework**](/products/framework/), the `everruns` crate, went from a first commit in early August to the thing the home page leads with, and a good share of the platform work in this window was done to make that possible.

So this roundup starts there, and then covers the rest: Everruns Cloud opening its doors, agents that can stop and ask a person something, and the reliability work that keeps long runs alive.

![A diagram of what shipped since the July roundup, grouped into four themed cards: The Everruns Framework (the everruns crate, a neutral kernel, direct model calls and catalogs, decisions with Jev), Everruns Cloud (open in early access), Agents that reach people (Ask User, Slack, agent-owned endpoints), and Long runs that hold up (interrupted-turn recovery, cost-aware checkpoints, async tools on durable workers).](/blog/whats-new-september-2026-feature-map.svg)

## The Everruns Framework

### One crate: `everruns`

Until August, using Everruns meant running Everruns: a server, a worker, PostgreSQL, and an API between your code and the agent. That is the right shape for a hosted agent platform and the wrong one for a CLI, a desktop app, or a test suite that just wants an agent loop. The [`everruns`](https://crates.io/crates/everruns) crate ([v0.17.24](https://github.com/everruns/everruns/releases/tag/v0.17.24)) is the other shape: agents as ordinary Rust values, running inside your process.

```rust
use std::time::{SystemTime, UNIX_EPOCH};

use everruns::{Agent, Engine, OpenAI};

/// Return the current Unix time in seconds.
#[everruns::tool]
async fn current_time() -> Result<u64, String> {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| duration.as_secs())
        .map_err(|error| error.to_string())
}

#[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.6-terra")
        .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::tool]` derives the tool's schema from the function signature. An `Agent` is an immutable description, an `Engine` owns runtime resources and the session catalog, and a `Session` is where the work happens. Within days, sessions became [live and steerable](https://docs.everruns.com/framework/sessions/): you can subscribe to [canonical events](https://docs.everruns.com/framework/canonical-events/), steer or cancel a running turn, read [history and resume](https://docs.everruns.com/framework/session-history/), and hook into the lifecycle with [typed hooks](https://docs.everruns.com/framework/lifecycle-hooks/) ([v0.17.26](https://github.com/everruns/everruns/releases/tag/v0.17.26)). The opt-in `local` feature adds a durable event log, scheduled work, and Git-backed [workspace heads](https://docs.everruns.com/framework/workspaces-and-environments/), so a session can reopen the exact workspace it had after a restart.

The [Framework page](/products/framework/) and the [quickstart](https://docs.everruns.com/framework/quickstart/) are the places to start.

### A neutral kernel underneath

A library is only honest if it does not drag a control plane in with it. [v0.18.0](https://github.com/everruns/everruns/releases/tag/v0.18.0) drew that line: `everruns-core` became a neutral execution kernel, and hosted-platform records (sessions, agent versions, evals, connectors, credentials) moved out to `everruns-platform`. Engines now own the session lifecycle, and one execution path serves both in-process and durable runs. Outbound A2A moved behind an opt-in feature so the default build no longer pulls in a second HTTP stack ([v0.20.0](https://github.com/everruns/everruns/releases/tag/v0.20.0)).

The practical result is that the agent loop in the Framework is the same one the platform runs, not a port of it. It also retired `everruns-runtime`, the crate from our [May post on embedding](/blog/embedding-the-runtime/): ordinary applications now depend on `everruns`, and custom execution hosts add `everruns-host` alongside it.

### More than an agent loop

Not every call needs an agent. September added the smaller pieces that sit next to one, all behind the same provider credentials ([v0.29.0](https://github.com/everruns/everruns/releases/tag/v0.29.0)):

- [**Direct model calls**](https://docs.everruns.com/framework/direct-model-calls/): `Model::new(...).complete(...)` for one prompt and one answer, no loop.
- [**Model catalogs**](https://docs.everruns.com/framework/model-catalogs/): ask a provider which models it has before you pick one.
- [**Credentials from your vendor's own variables**](https://docs.everruns.com/framework/credentials/): every driver declares the environment variables its vendor's SDK already reads, so a shell that works with OpenAI, Anthropic, or Bedrock already configures Everruns.
- **Harness sessions**: a Framework session can run a harness, and since [v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0) the generic harness is the same one the platform runs.

Around those, the Framework picked up an [in-process Ask User](https://docs.everruns.com/framework/ask-user/) strategy, a kernel-contained [Host Shell](https://docs.everruns.com/capabilities/host-shell/) that runs real compilers and test runners under Landlock or Seatbelt, and [caller-owned backends](https://docs.everruns.com/framework/custom-backends/) for applications that want to own persistence ([v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0)). There is now a [catalog of runnable examples](https://docs.everruns.com/framework/examples/), from a research agent to an incident commander.

### Decisions, and Jev

The most fun addition of the window. A lot of agent code asks a model a yes-or-no question and then parses prose: _is this spam, is this claim supported, how severe is this ticket_. The answer comes back as a sentence, and the decision hides inside whatever the parser makes of it.

[Direct decisions](https://docs.everruns.com/framework/direct-decisions/) ask for a number instead ([v0.29.0](https://github.com/everruns/everruns/releases/tag/v0.29.0)). The first service behind them is [TypeSafe](https://docs.everruns.com/integrations/typesafe/)'s **Jev**, a model that answers typed questions with calibrated probabilities, selected options, or graded levels:

```rust
use everruns::{Decisions, TypeSafeAI};

let judge = Decisions::new("jev-latest", TypeSafeAI::from_env()?);
let spam = judge.probability("Is this message spam?", text).await?;
```

The threshold stays in your code, so there is no written verdict to misparse. The same model is available to agents as the `jev` capability, and to the platform as a [guardrail](https://docs.everruns.com/capabilities/guardrails/) engine that answers every check on a stage in one request with a probability, instead of asking a text model for a JSON verdict and parsing it back.

The best demonstration is [Foreman](https://docs.everruns.com/framework/examples/foreman-agent/) ([v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0)): a coding agent works while a supervisory loop watches its canonical events, asks Jev nine questions about the work in one request, and lets a plain Rust policy decide whether to intervene. The worker never stops to be watched.

## Everruns Cloud is open

In July we said a managed Everruns was coming. On September 11 [Everruns Cloud](/cloud/) opened in early access: create an account at [app.everruns.com](https://app.everruns.com) and run durable agents without operating PostgreSQL, a worker, or a queue. It runs the same MIT-licensed core you can self-host, so you can move between the two whenever you want. Expect rough edges, and [tell us what breaks](mailto:contact@everruns.com).

That makes three ways to run the same agent: in your process with the Framework, on your own infrastructure, or on Cloud.

## Agents that reach people

### Ask User

An agent that guesses at intent is expensive to correct; one that ends its turn with a paragraph of questions and hopes for answers is not much better. [Ask User](https://docs.everruns.com/capabilities/ask-user/) gives the agent one tool to ask one to four structured questions and wait ([v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0)). In Platform Chat the questions show up as an inline card; unanswered questions expire to the defaults the agent declared, and credential questions never enter the log or the agent's context. As of [v0.31.0](https://github.com/everruns/everruns/releases/tag/v0.31.0) the same questions reach clients over MCP, as form-mode elicitation, and over A2A. It is on by default for the Generic and Platform Chat harnesses.

### Agents in Slack

Agents now [run natively in Slack](https://docs.everruns.com/integrations/slack/) ([v0.27.0](https://github.com/everruns/everruns/releases/tag/v0.27.0)): replies stream into the thread token by token, a stop button cancels the running turn, thread context is kept between messages, and replies post as proper markdown blocks. Installing the Slack app is now [one click](https://docs.everruns.com/how-to/publish-to-slack/), with credentials taken straight from OAuth ([v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0)).

### Agent-owned endpoints

Behind Slack sits a simpler model for how agents are exposed. The old App abstraction is gone; an agent now owns its endpoints and triggers directly, and a new Exposures view lists what every agent exposes, with the ability to suspend it ([v0.27.0](https://github.com/everruns/everruns/releases/tag/v0.27.0), [v0.28.0](https://github.com/everruns/everruns/releases/tag/v0.28.0)). Sessions and budgets are attributed to the endpoint they arrived through, so a Slack endpoint can have its own spending limit, now settable from the UI.

## Long runs that hold up

### Interrupted-turn recovery

The failure that ends most long runs is not a bug in the agent, it is an overloaded provider, a dropped stream, or a 5xx in the middle of a tool-heavy turn. Turns now classify provider failures and recover from the transient ones within bounded retry budgets, keeping the effects of tools that already completed, and surface permanent failures as precise, resumable errors ([v0.17.22](https://github.com/everruns/everruns/releases/tag/v0.17.22)).

### Cost-aware context checkpoints

[Compaction](https://docs.everruns.com/advanced/compaction/) used to wait for context-window pressure. Long tool trajectories now checkpoint earlier when cumulative uncached input or raw tool output gets expensive, while keeping full history queryable ([v0.17.21](https://github.com/everruns/everruns/releases/tag/v0.17.21)), and those checkpoints are durable across compaction ([v0.17.16](https://github.com/everruns/everruns/releases/tag/v0.17.16)). In the same release, deferred tools started carrying compact schemas until they are revealed, cutting the production tool-list payload by 65%.

### Async tools on durable workers

Long-running tool calls now execute natively on durable workers instead of holding a turn open ([v0.26.0](https://github.com/everruns/everruns/releases/tag/v0.26.0)), and agent startup-to-ready latency dropped by roughly 3.5x ([v0.24.0](https://github.com/everruns/everruns/releases/tag/v0.24.0)).

## Also since July

- **Models.** Claude Opus 5 ([v0.17.17](https://github.com/everruns/everruns/releases/tag/v0.17.17)) and then Opus 5.5 as the recommended Opus, GPT-6 Sol and Luna with Luna as the default chat and utility model ([v0.30.0](https://github.com/everruns/everruns/releases/tag/v0.30.0)), plus GPT-6 Astra, Claude Fable 5.1, Kimi K3, and Muse Spark. [Meta](https://docs.everruns.com/providers/meta/) is a new first-class provider, and connecting a provider is now a one-click grid.
- **MCP.** The final 2026-07-28 specification ([v0.17.18](https://github.com/everruns/everruns/releases/tag/v0.17.18)), [URL-mode elicitation](https://docs.everruns.com/features/mcp-url-elicitation/) with an explicit consent pause ([v0.24.0](https://github.com/everruns/everruns/releases/tag/v0.24.0)), [secure credential bindings](https://docs.everruns.com/integrations/mcp-credentials/), and scoped catalog presets.
- **Soft approval.** A lightweight, reversible approval step, on by default for Generic and Platform Chat ([v0.29.0](https://github.com/everruns/everruns/releases/tag/v0.29.0)).
- **Platform Chat.** Chats became the landing surface, every user gets a pinned [Platform Chat](https://docs.everruns.com/built-ins/harnesses/platform-chat/) thread that can drive the control plane, and v2 runs on one command line shared by people and agents ([v0.29.0](https://github.com/everruns/everruns/releases/tag/v0.29.0)).
- **Context and inputs.** [Hierarchical `AGENTS.md`](https://docs.everruns.com/how-to/use-agents-md/) files are resolved and injected below harness safety instructions ([v0.25.0](https://github.com/everruns/everruns/releases/tag/v0.25.0)), agents accept PDF attachments ([v0.26.0](https://github.com/everruns/everruns/releases/tag/v0.26.0)), and agents can attach [citations](https://docs.everruns.com/capabilities/citation-retrieval/) to individual claims.
- **Tracing.** [Observability](https://docs.everruns.com/observability/) emits the Gen-AI agent and OpenInference trace conventions ([v0.24.0](https://github.com/everruns/everruns/releases/tag/v0.24.0)).
- **Smaller builds.** Bringing 114 small third-party contracts in-tree and stripping binaries made shipped binaries about 22% smaller ([v0.21.0](https://github.com/everruns/everruns/releases/tag/v0.21.0)).

## Around the family

[**Yolop**](/yolop/) went from v0.6.0 to [v0.18.3](https://github.com/everruns/yolop/releases/tag/v0.18.3). The headline is session coordination: Yolop sessions can discover each other, reserve work, dispatch it, and wake when it completes, and `yolop coordination spawn-workers` prints ready-to-run launch commands for a coordinator's workers. Model, MCP, and connector configuration moved to the CLI (`yolop models` now keeps your own cross-provider list), extensions can ship prebuilt, checksum-verified binaries, and the default release binary dropped the local-inference engine, from 29.9 MB to 18.2 MB on Linux, with separate Metal and CUDA builds for those who want it.

[**Mira**](/mira/) reached [v0.5.0](https://github.com/everruns/mira/releases/tag/v0.5.0): a study's `main` can now be a plain function via `Study::serve_blocking()`, and external TOML experiment plans run named treatment overlays as separate, reproducible runs.

The **SDKs** for Rust, Python, and TypeScript reached [v0.2.1](https://github.com/everruns/sdk/releases/tag/v0.2.1), with harnesses and models APIs and a leaner Rust client.

---

All of it is open source and MIT-licensed: [everruns/everruns](https://github.com/everruns/everruns), [everruns/yolop](https://github.com/everruns/yolop), [everruns/mira](https://github.com/everruns/mira). Start with `cargo add everruns`, read [docs.everruns.com](https://docs.everruns.com/), or try [Everruns Cloud](/cloud/). Questions and war stories go to [contact@everruns.com](mailto:contact@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`.