June was a heavy month for Everruns — a dozen releases, give or take. Rather than walk through them by version number, here is what actually shipped, grouped by what it changes. Most of it pulls in the same direction: less new surface area, more depth on retrieval, durability, safety, and observability — the parts that decide whether an agent holds up in production. Every feature below links into the [documentation](https://docs.everruns.com/). ![A diagram of June 2026 releases grouped into four themed cards: Knowledge and tools (Knowledge Indexes, Agentic Resource Discovery), Reliability for long runs (Durable subagents, Tool-Call Repair), Safety and governance (Guardrails, Governed egress), and Quality you can see (Online judges and health checks, Task webhooks).](/blog/whats-new-spring-2026-feature-map.svg) ## Knowledge and tools ### Knowledge Indexes An agent is only as good as what it can look up, and stuffing every document into the context window stops working after a handful of them. [Knowledge Indexes](https://docs.everruns.com/api/operations/tags/knowledge_indexes/) add source-backed semantic search instead. You [import a knowledge base](https://docs.everruns.com/api/operations/create_kb/) in [Open Knowledge Format](https://docs.everruns.com/api/operations/tags/knowledge_bases/) — structured frontmatter up top, prose in the body — [build an index](https://docs.everruns.com/api/operations/create_index/) over it, and the agent queries for the passages that actually match rather than carrying the whole corpus. When the sources change, you [re-sync the index](https://docs.everruns.com/api/operations/sync_index/). Retrieval stays grounded in something you curated. ### Agentic Resource Discovery No one can pre-wire every tool an open-ended task might need, so this month an agent gained the ability to find them. [Agentic Resource Discovery](https://docs.everruns.com/integrations/ard/) lets a running agent search a registry, find an [MCP](https://docs.everruns.com/features/mcp/) server or another agent it was never configured with, and attach it to its own session — `discover_resources` to search, `attach_resource` to verify trust and materialize the capability, `list_attached_resources` to see what is live. Newly attached MCP tools appear with an `mcp_` prefix on the next turn. The rails are deliberate: registry allowlists, trust verification, SSRF protection, and a per-session cap on how much can attach. ## Reliability for long runs ### Durable subagents This is the most Everruns-shaped work of the month. The platform already guarantees that a single agent's execution [survives a process restart](https://docs.everruns.com/explanation/durable-execution/) — every step is persisted to Postgres and replayed. That guarantee now extends to [subagents](https://docs.everruns.com/capabilities/sub-agents/): a parent that spawns children to work in parallel gets durable spawn handles, so a long-running subagent can reconnect after the parent is interrupted instead of vanishing on a restart. Durability went from a property of one agent to a property of the whole tree. ### Tool-Call Repair Models occasionally emit tool arguments that are not clean JSON — fenced in Markdown, trailed by prose, a number quoted as a string. Left alone, a multi-hour run can die on a formatting hiccup. [Tool-Call Repair](https://docs.everruns.com/capabilities/tool-call-repair/) fixes it in two stages: a deterministic local pass that unwraps fences, drops trailing commas, and coerces types, then a bounded re-prompt if that is not enough. It is provider-agnostic, because the failure looks the same across vendors, and it is one line to turn on: ```json { "capabilities": ["tool_call_repair"] } ``` ## Safety and governance ### Guardrails [Guardrails](https://docs.everruns.com/api/operations/dry_run_guardrails/) are config-driven checks that run at stages of the loop — most usefully, before a tool executes. Two new check types arrived. **`llm_judge`** evaluates a step with a model against a policy you write in plain language, for the cases that are not a clean regex match. **`mcp`** hands the decision to an external policy service over a scoped connection, so an existing engine can be the decider. You can [dry-run a guardrail](https://docs.everruns.com/api/operations/dry_run_guardrails/) against examples before enforcing it, which makes tuning a policy safe to do against real traffic. ### Governed egress External calls — `web_fetch` and MCP execution included — now route through an outbound egress service with a system-wide allowlist and SSRF DNS pinning, so a resolved hostname cannot be swapped for an internal address mid-request. Paired with [agent versions](https://docs.everruns.com/features/agent-versions/) — immutable snapshots of a known-good prompt, tool, and capability setup — you can pin both what an agent is and where it is allowed to talk. ## Quality you can see ### Online judges and health checks The judge machinery behind [evals](https://docs.everruns.com/features/evals/) now runs against production. An LLM-as-judge online scorer grades live sessions on a 0.0–1.0 scale, and [agent health checks](https://docs.everruns.com/features/agent-checks/) run scheduled smoke tests against an agent's real configuration — each case scored both deterministically and by a judge against generated rubrics. Both are advisory; they surface trouble without blocking, so a run that finishes wrong is visible rather than silent. ### Task webhooks When a session task reaches a terminal state — done, failed, cancelled — [task webhooks](https://docs.everruns.com/api/operations/tags/task-webhooks/) fire an outbound HTTP callback, so downstream systems react to a finished run instead of polling for one. [Create](https://docs.everruns.com/api/operations/create_webhook/), update, and [list](https://docs.everruns.com/api/operations/list_webhooks/) them over the API. ## Also this month Smaller changes worth knowing about: - **More models and providers.** [Claude Fable 5](https://docs.everruns.com/providers/anthropic/) with adaptive thinking, plus [AWS Bedrock](https://docs.everruns.com/providers/bedrock/), [Fireworks AI](https://docs.everruns.com/providers/fireworks/), and [Microsoft MAI](https://docs.everruns.com/providers/mai/), and an OAuth connect flow starting with [OpenRouter](https://docs.everruns.com/providers/openrouter/) — connecting a provider is a click, not a copied key. - **Memory and tasks.** A Memory API gives agents file-backed memory over HTTP, and Session Tasks turn background work into something with cancellation, a reaper, and visibility in chat. - **`everruns-local`.** An embedded host backend [on crates.io](https://crates.io/crates/everruns-local) for local development without standing up the server — a companion to the [`everruns-runtime`](https://crates.io/crates/everruns-runtime) crate we [wrote about recently](/blog/embedding-the-runtime). --- All of it is in the open-source platform, MIT-licensed. The full reference is at [docs.everruns.com](https://docs.everruns.com/), and the code is at [github.com/everruns/everruns](https://github.com/everruns/everruns). If you build something on it, we would like to hear about it — [contact@everruns.com](mailto:contact@everruns.com).