Reactive Agents

17Packages

900+Tests

5LLM Providers

5Reasoning Strategies

10Execution Phases

Build Agents That Think, Act, and Learn

Most agent frameworks give you a chat loop and call it a day. Reactive Agents gives you a 10-phase execution engine, 5 reasoning strategies, 4-tier memory, A2A protocol for agent interop, and 14 composable layers — all fully typed, all independently toggleable.

Type-Safe from End to End

Every agent, tool, memory entry, and LLM call is validated by Effect-TS schemas. Catch errors at compile time. Runtime validation at every service boundary. No any leaking through your agent stack.

Composable Layer Architecture

Enable exactly the capabilities you need. Memory without guardrails? Just reasoning and tools? Full production stack? Each layer is an independent Effect Layer with explicit dependencies — no hidden coupling, no wasted resources.

Observable Execution Engine

Every agent task flows through a deterministic 10-phase lifecycle with before/after/error hooks. When observability is enabled, every phase emits spans and metrics. You see exactly what your agent decided and why.

5 Reasoning Strategies

ReAct for tool use. Reflexion for self-improvement. Plan-Execute for structured work. Tree-of-Thought for creative exploration. Adaptive to auto-select the best strategy. Register your own strategies too.

Multi-Agent & A2A Protocol

Build teams of specialized agents that collaborate via the A2A (Agent-to-Agent) protocol. Dynamic agent spawning, agent-as-tool composition, SSE streaming, and structured JSON-RPC communication. Scale from single agents to orchestrated multi-agent workflows.

40+ LLM Providers

Native support for Anthropic, OpenAI, Google Gemini, Ollama, and 35+ more via LiteLLM. Mix providers per-agent, route by cost/capability, or use multiple models in parallel. Fallback chains and A/B testing built in.

---

Quick Example

Simple Agent

import { ReactiveAgents } from "reactive-agents";

const agent = await ReactiveAgents.create()
.withName("assistant")
.withProvider("anthropic")
.withModel("claude-sonnet-4-20250514")
.build();

const result = await agent.run("Explain quantum entanglement");
console.log(result.output);

With Tools + Reasoning

import { ReactiveAgents } from "reactive-agents";
import { defineTool } from "@reactive-agents/tools";
import { Effect, Schema } from "effect";

const searchTool = defineTool({
  name: "web_search",
  description: "Search the web",
  input: Schema.Struct({ query: Schema.String }),
  handler: ({ query }) => Effect.succeed(`Results for: ${query}`),
});

const agent = await ReactiveAgents.create()
  .withName("researcher")
  .withProvider("anthropic")
  .withReasoning()           // ReAct loop: Think -> Act -> Observe
  .withTools([searchTool])   // Tools are called during reasoning
  .withMemory("1")           // Persistent memory across sessions
  .build();

const result = await agent.run("What happened in AI this week?");

Production Stack

const agent = await ReactiveAgents.create()
  .withName("production-agent")
  .withProvider("anthropic")
  .withModel("claude-sonnet-4-20250514")
  .withReasoning()           // 5 reasoning strategies
  .withTools([...myTools])   // Sandboxed tool execution
  .withMemory("2")           // Vector + FTS5 search
  .withGuardrails()          // Injection, PII, toxicity detection
  .withVerification()        // Semantic entropy fact-checking
  .withCostTracking()        // Budget enforcement + model routing
  .withObservability()       // Distributed tracing + metrics
  .withIdentity()            // RBAC + agent certificates
  .withInteraction()         // 5 autonomy modes
  .withAudit()               // Compliance audit trail
  .build();

---

How It’s Different

vs. LangChain / LlamaIndex

Those frameworks are Python-first, dynamically typed, and monolithic. Reactive Agents is TypeScript-native, statically typed with Effect-TS schemas, and fully modular — you only load what you use.

vs. Vercel AI SDK

Vercel AI SDK handles streaming and tool calling well but stops there. Reactive Agents adds reasoning strategies, persistent memory, guardrails, verification, cost routing, observability, and multi-agent orchestration.

vs. AutoGen / CrewAI

Multi-agent frameworks that lack type safety, composable architecture, or fine-grained observability. Reactive Agents gives you all three plus a 10-phase execution engine you can hook into at any point.

vs. Building From Scratch

You get 17 production-ready packages with 900+ tests, covering memory, reasoning, tools, A2A protocol, safety, cost, identity, and orchestration. Focus on your agent’s logic, not infrastructure.

---

Architecture at a Glance

ReactiveAgentBuilder
  -> createRuntime()
    -> CoreServices    (EventBus, AgentService, TaskService)
    -> LLMProvider     (Anthropic, OpenAI, Gemini, Ollama, LiteLLM 40+)
    -> Memory          (Working, Semantic, Episodic, Procedural)
    -> Reasoning       (ReAct, Reflexion, Plan-Execute, ToT, Adaptive)
    -> Tools           (Registry, Sandbox, MCP Client)
    -> A2A             (Agent Cards, JSON-RPC, SSE Streaming)
    -> Guardrails      (Injection, PII, Toxicity, Contracts)
    -> Verification    (Semantic Entropy, Fact Decomposition)
    -> Cost            (Complexity Router, Budget Enforcer)
    -> Identity        (Certificates, RBAC)
    -> Observability   (Tracing, Metrics, Structured Logging)
    -> Interaction     (5 Modes, Checkpoints, Preference Learning)
    -> Orchestration   (Multi-Agent Workflows)
    -> Prompts         (Template Engine, Built-in Library)
    -> ExecutionEngine (10-phase lifecycle with hooks)

17 Packages, One Command

bun add reactive-agents effect

Or install individual packages for minimal bundle size. See installation guide →