---
title: What's New
description: Latest features and changes to Reactive Agents across recent releases
sidebar:
  order: 2
---

import { Aside } from '@astrojs/starlight/components';
import metrics from '../../../data/metrics.json';

<Aside type="tip" title="Subscribe">
Get release highlights as an RSS feed: [`/rss.xml`](/rss.xml). Drop into NetNewsWire, Inoreader, or any feed reader.
</Aside>

A quick-scan guide to what has landed in each major release. Start here when returning after time away — each bullet links to the relevant documentation.

---

## v0.11.x — Production tooling + full observability (May 2026)

The focus: developer tooling that makes agents production-observable and repeatable, plus the first `create-reactive-agent` scaffolder, cross-runtime support, and three new capabilities (`code-action` strategy, skill persistence, interactive playground).

### New packages

- **`@reactive-agents/observe`** — Zero-config OpenTelemetry tracing. Set `OTEL_EXPORTER_OTLP_ENDPOINT` and every run emits a workflow → LLM → tool span hierarchy, OpenInference-compliant, to any OTLP backend (Jaeger, Grafana Tempo, Langfuse, Arize Phoenix). See [OpenTelemetry Tracing](/features/observe/).
- **`@reactive-agents/replay`** — Deterministic trace replay. Record any run to a snapshot file and re-run it with a different model or prompt without calling the LLM again. Enables regression testing and prompt A/B comparisons. See [Snapshot & Replay](/features/snapshot-replay/).
- **`@reactive-agents/runtime-shim`** — Cross-runtime support. The framework now runs on Node.js 22.5+ in addition to Bun. Provides unified `Database`, `spawn`, `serve`, `glob`, `writeFile`, `readFile`, and `hash` primitives that delegate to the available runtime. FTS5 is optional — falls back to LIKE-based search on Node's built-in SQLite. Unblocks Stackblitz WebContainers (Node-only) and Vercel/Netlify deployments.

### New tooling

- **`create-reactive-agent` CLI** — `bunx create-reactive-agent my-app` scaffolds a runnable agent project in seconds. Supports `--template minimal|standard|tool-use|multi-agent|gateway`, `--provider`, `--model`, `--pm bun|npm|yarn|pnpm`. See [create-reactive-agent](/features/create-reactive-agent/).

### Interactive Playground

Three live Stackblitz scenarios, zero install. Runs fully in-browser via WebContainers — no local runtime required. Default provider is Google Gemini (free tier).

| Scenario | What it shows |
|----------|--------------|
| **Hello Agent** | Simple Q&A — minimal builder, one-step response |
| **Tool Integration** | Built-in `code-execute` + `scratchpad` tools working together |
| **Strategy Demo** | `reactive` vs `plan-execute-reflect` side-by-side on the same task |

See [Playground](/guides/playground/).

### `code-action` strategy (`@experimental`)

A 7th reasoning strategy in which the LLM generates a TypeScript IIFE that runs inside a Worker-thread sandbox. Tools are exposed as normal async functions and called via `postMessage` round-trips — no JSON schema juggling in the prompt. Best suited for multi-tool orchestration tasks where expressing control flow in code is cleaner than iterative tool calls.

Enable with `defaultStrategy: "code-action"`. `ToolService` is optional; the strategy also handles pure computation tasks. See [code-action](/features/code-action/).

### Skill persistence

Learned `SkillRecord` objects now survive process restarts. The skill system uses a dual-store: the existing in-memory session store for fast within-run access, plus a new SQLite-backed `SkillStore` that persists across runs. On cold start, skills are resolved from the persistent store before any LLM call. `skillFragmentToSkillRecord()` is exported from `reactive-agents` for manual skill construction.

### New runtime controls

- **`RunHandle`** — `runStream()` now returns a `RunHandle` with four controls and a status property:
  - `.pause()` — suspends the loop at the next safe checkpoint
  - `.resume()` — resumes a paused run
  - `.stop()` — graceful shutdown: finishes the current step, then runs output synthesis
  - `.terminate()` — immediate abort, skips synthesis
  - `.status` — `"running" | "paused" | "stopped" | "terminated" | "completed"`
  - `.result` — `Promise` that resolves when the run reaches a terminal state

  See [Compose API](/reference/compose-api/).

- **Killswitches** — Six factory functions from `@reactive-agents/compose` that wire stopping conditions into the agent loop. Pass them to `.compose()` or `.withHarness()`:

  ```ts
  import { maxIterations, budgetLimit, timeoutAfter, watchdog, requireApprovalFor } from "@reactive-agents/compose";
  ```

  | Factory | Stops when… |
  |---------|-------------|
  | `maxIterations(n)` | Loop count reaches `n` |
  | `budgetLimit({ maxTokens?, maxCostUSD? })` | Token or cost ceiling hit |
  | `timeoutAfter(duration)` | Wall-clock duration exceeded |
  | `watchdog({ timeout })` | No progress within `timeout` |
  | `requireApprovalFor(toolName, approver)` | Named tool needs human approval |

  See [Compose API](/reference/compose-api/).

- **Compose API** (`@stable`) — `.compose(fn)` (alias: `.withHarness(fn)`) attaches a harness transform that intercepts tagged chokepoints (`prompt.system`, `nudge.loop-detected`, `message.tool-result`, etc.) via `h.on()`, `h.tap()`, `h.before()`, `h.after()`, and `h.onError()`. Existing builder methods `.withSystemPrompt()`, `.withErrorHandler()`, and `.withHook()` now desugar through the harness. See [Compose API](/reference/compose-api/) and [Harness Tags](/reference/harness-tags/).

### Strategy switching on by default

`enableStrategySwitching` now defaults to `true`. The reactive intelligence dispatcher will switch strategies automatically when entropy signals a stuck loop — no explicit opt-in required.

### Decision tracing

Every tool call now carries the model's stated *why*. Rationale capture went from an optional nudge to a coaxed contract across all three execution paths:

- **Kernel-injected system prompt** — Unconditionally appends a MANDATORY rationale instruction regardless of `toolSchemaDetail`. Model must precede each tool call with `<rationale call="N">{"why":"…","confidence":0-1}</rationale>`.
- **Native function-calling capture** — `parseRationaleBlocks()` reads side-channel blocks from `thought` + `thinking` content and attaches each rationale to the matching `ToolCallSpec` by 1-indexed position.
- **plan-execute-reflect enforcement** — `LLMPlanStepSchema` now carries a `rationale: { why, confidence? }` field; planner marks it MANDATORY for every `tool_call` step. Failures after retry emit `plan_rationale_missing` metric — no synthetic fallback invented.
- **`AgentDebrief.rationale[]`** — Unified milestone-decision log: tool selections, curator decisions, strategy switches, reactive interventions, and terminations. All render in `debrief.markdown` under `## Decision Rationale`.

See [Decision Tracing](/concepts/decision-tracing/) for the full pipeline and [Debrief & Chat](/features/debrief-chat/) for the result shape.

---

## v0.10.x — Local models match frontier (May 2026)

The biggest release since v0.9 — `0.10.0` through `0.10.6`, shipped over four weeks. The headline: **local Ollama models now hit 91–94% on the same task suite as paid frontier APIs**, thanks to a closed-loop healing pipeline and adaptive tool-calling. Read the full [v0.10.0 changelog](https://github.com/tylerjrbuell/reactive-agents-ts/blob/main/CHANGELOG.md) for engineering detail.

### What you gain

#### Local models that actually work

- **Healing Pipeline** — 4-stage closed-loop recovery on every tool call (tool-name fuzzy match → parameter-name aliasing → path resolution → type coercion). **86.7% recovery rate, +80pp accuracy, 90% cheaper than LLM reprompt.** Ships on by default — see [LLM Providers](/features/llm-providers/) and [Resilience](/features/resilience/).
- **Adaptive tool calling** — Each model gets fingerprinted on first run; native FC capable models route through the JSON path, weaker ones through a 3-tier text-parse cascade (XML → JSON → pseudo-code). The framework learns each model's dialect after 5 runs and stops asking it to do things it can't.
- **Calibration system** — Per-model observations (parallel-call capability, classifier reliability, tool-call dialect) adapt empirically. Auto-enabled when `.withReasoning()` is on.
- **Frontier benchmark: 100% on `ra-full`** verified across `claude-sonnet-4-6`, `claude-haiku-4-5`, `gpt-4o-mini`, `gemini-2.5-pro`. Bare LLM only reaches 85% on the same suite.
- **Local benchmark: 91–94% on `ra-full`** for `gemma4:e4b` (4 GB) and `cogito:14b` (9 GB) — tied with `gemini-2.5-flash` and `gpt-4o-mini` on the same 35-task suite.

#### Long agent runs stay cheap

- **Three-stage context curation** — Tool results get compressed and stashed → curator renders only what's needed → optional reactive trim. **60.7% context reduction, 38.6% token savings, 0.16 ms overhead per step.** See [Intelligent Context Synthesis](/features/intelligent-context-synthesis/).
- **Reactive Intelligence dispatcher** — 6 corrective interventions fire automatically when an agent shows entropy signs (early-stop, temperature adjust, strategy switch, context compress, tool inject, skill activate). Suppression gates prevent runaway dispatch. See [Reactive Intelligence](/features/reactive-intelligence/).

#### Production safety hardened

- **`@reactive-agents/diagnose`** — Standalone npm package detects system-prompt, API-key, credential, and internal-instruction leaks in any output. **100% true positive, 0% false positive, 0.02 ms latency.** 25 regex patterns + 4 FP filters.
- **Single-owner termination** — All 12 phases route stop decisions through one arbitrator. CI lint guard prevents future bypass paths. Agents always finish cleanly, never get stuck.

#### Better runtime + tooling

- **`@reactive-agents/cortex`** — Cortex Studio is now installable from npm: `bunx @reactive-agents/cortex` or `rax cortex` launches the live agent canvas, debrief UI, and visual builder. See [Cortex](/features/cortex/).
- **Gateway chat mode** — Per-sender SQLite session history, episodic context injection, daily compaction. Set `channels.mode: 'chat'` for conversational webhooks; keep `'task'` for one-shot triggers. See [Gateway](/features/gateway/) and [Messaging Channels](/guides/messaging-channels/).
- **Composable kernel architecture** — Internal `kernel/` reorganized by capability (`act/` · `attend/` · `comprehend/` · `decide/` · `reason/` · `reflect/` · `sense/` · `verify/` + `loop/` + `state/`). Doesn't change the public API; makes contributing to the framework easier. See [Composable Kernel](/concepts/composable-kernel/).
- **{metrics.tests.toLocaleString()} tests** across {metrics.testFiles} files — verified by `bun test` on every PR.

### Patch releases

| Version | Highlights |
|---------|-----------|
| `0.10.0` | Phase 1 release — healing pipeline, calibration, diagnose, cortex npm |
| `0.10.1–0.10.2` | Documentation polish, version drift fixes across 28 packages |
| `0.10.3` | Coordinated package alignment, npm publish drift CI guard |
| `0.10.4` | Coordinated changeset release (single source of truth) |
| `0.10.5–0.10.6` | Static-asset serving in Cortex server, README + cookbook freshness |

### Breaking changes

None. All existing `ReactiveAgents.create().with*()` builder chains keep working unchanged. New calibration fields are forward-compatible — existing `~/.reactive-agents/observations/` files decode cleanly.

---

## v0.9.x — MCP Production Hardening + Pre-v0.10 Polish

- **MCP client rewritten on `@modelcontextprotocol/sdk`** — smart auto-detection between stdio and HTTP-only containers, two-phase docker lifecycle — see [Orchestration](/features/orchestration/)
- **Composable kernel architecture (initial)** — `react-kernel.ts` reduced from ~1,700 to ~197 lines via `makeKernel({ phases })` factory — see [Composable Kernel](/concepts/composable-kernel/)
- **Permanently-failed required tools fix** — tools that always error no longer cause loop-until-maxIterations — see [Harness Control Flow](/features/harness-control-flow/)
- **Cortex MCP CRUD + JSON import** — import Cursor/Claude-style MCP configs directly into Cortex — see [Cortex](/features/cortex/)
- **StatusRenderer TUI** — live terminal display with collapsible think panel (`t` key toggles), `mode: 'stream' | 'status'`
- **3 new terminal tools** — `git-cli`, `gh-cli`, and `gws-cli` are now built-in
- **Web-search provider Serper.dev** — third web-search backend alongside Tavily
- **`crypto-price` built-in tool** — CoinGecko price lookup, no API key required
- **Observability on by default** — minimal verbosity is now enabled out of the box
- **Sub-agent `maxIterations` fully honored** — the silent cap of 3 has been removed

---

## v0.9.0 — MCP Production Hardening

- **MCP client rewritten on `@modelcontextprotocol/sdk`** — smart auto-detection between stdio and HTTP-only containers, two-phase docker lifecycle — see [Orchestration](/features/orchestration)
- **Composable kernel architecture** — `react-kernel.ts` reduced from ~1,700 to ~197 lines via `makeKernel({ phases })` factory; phases are now individually swappable — see [Composable Kernel](/concepts/composable-kernel)
- **Permanently-failed required tools fix** — tools that always error no longer cause loop-until-maxIterations; framework detects and stops early — see [Harness Control Flow](/features/harness-control-flow)
- **Cortex MCP CRUD + JSON import** — import Cursor/Claude-style MCP configs directly into Cortex — see [Cortex](/features/cortex)
- **`effect` moved to `peerDependencies`** — add `effect` explicitly if you import from it directly — see [Installation](/guides/installation)

---

## v0.8.5 — Native FC Hardening + Web Framework Adapters

- **React, Vue, and Svelte adapters** — `useAgentStream()` and `useAgent()` hooks/composables/stores for all three frameworks, consuming SSE endpoints — see [Web Integration](/guides/web-integration) and [Streaming](/features/streaming)
- **7-hook provider adapter system** — `taskFraming`, `toolGuidance`, `errorRecovery`, `synthesisPrompt`, `qualityCheck`, `continuationHint`, `systemPromptPatch` fully wired — see [Reactive Intelligence](/features/reactive-intelligence)
- **Dynamic stopping (3-layer)** — novelty signal (Jaccard overlap), budget exhaustion phase transition, and per-tool call cap (`maxCallsPerTool`) — see [Harness Control Flow](/features/harness-control-flow)
- **Full prompt observability** — `logModelIO: true` logs the complete FC conversation thread with no truncation — see [Observability](/features/observability)
- **Actionable failure messages** — loop detection, required-tools, and stall detection all emit `Fix:` suggestions with specific builder options — see [Troubleshooting](/guides/troubleshooting)

---

## v0.8.0 — Reactive Intelligence Layer

- **Entropy-aware intelligence pipeline** — 5-source composite entropy sensor, trajectory classifier, and reactive controller that takes corrective action automatically — see [Reactive Intelligence](/features/reactive-intelligence)
- **Thompson Sampling strategy learner** — SQLite-backed bandit learns which reasoning strategy wins per task category across runs — see [Reactive Intelligence](/features/reactive-intelligence)
- **Builder hardening** — `withStrictValidation()`, `withTimeout()`, `withRetryPolicy()`, `withFallbacks()`, `withHealthCheck()`, and `withErrorHandler()` — see [Builder API](/reference/builder-api)
- **Automatic strategy switching** — when entropy analysis detects a stuck loop, the agent switches reasoning strategy without user intervention — see [Choosing Strategies](/guides/choosing-strategies)
- **Observability dashboard upgrade** — chalk/boxen terminal UI with entropy grade (A–F), sparklines, and entropy-informed alerts — see [Observability](/features/observability)

---

## v0.5.0 — A2A Protocol + Observability Foundation

- **Full A2A (Agent-to-Agent) protocol** — JSON-RPC 2.0 server, streaming SSE, client, discovery, and capability matching based on Google's A2A spec — see [A2A Protocol](/features/a2a-protocol)
- **Agent-as-tool pattern** — wrap any local or remote A2A agent as a callable tool with `createAgentTool()` / `createRemoteAgentTool()` — see [Sub-agents](/guides/sub-agents)
- **Live observability streaming** — `withObservability({ live: true, verbosity })` writes structured phase logs to stdout as each step fires — see [Observability](/features/observability)
- **`rax serve`** — expose any agent as an A2A-compliant HTTP server with a single CLI command — see [CLI](/reference/cli)
- **EventBus reasoning events** — all 5 strategies publish `ReasoningStepCompleted`; subscribe with `agent.on()` for custom monitoring — see [Observability](/features/observability)
