Choosing a Stack

Use this guide to choose a default stack quickly, then tune for cost and reliability.

Start with a profile

The fastest way to compose capabilities is a HarnessProfile preset — it sets the default-on capability bundle in one line, and you override individual pieces afterward (later calls win). (HarnessProfile ships in v0.12+; on earlier versions use the explicit .with*() chain below.)

import { ReactiveAgents, HarnessProfile } from "reactive-agents";

const agent = await ReactiveAgents.create()
  .withProvider("anthropic")
  .withProfile(HarnessProfile.balanced())   // memory + RI + verifier + strategy switching
  .withTools()
  .build();

Preset	Use when
HarnessProfile.lean()	Latency/cost-sensitive paths or ablations — model only, all default capabilities off.
HarnessProfile.balanced()	Most production apps — the full stack (memory + reactive intelligence + verifier + strategy switching). Memory is off in a bare builder as of v0.12; balanced() enables it explicitly.
HarnessProfile.intelligent()	You want cross-session compounding learning — balanced + skill persistence.

Override after the preset: .withProfile(HarnessProfile.lean()).withMemory() re-enables just memory.

Default Recommendation

For most production apps, the equivalent explicit chain:

const agent = await ReactiveAgents.create()
  .withProvider("anthropic")
  .withModel("claude-sonnet-4-6")
  .withReasoning({ defaultStrategy: "adaptive" })
  .withTools()
  .withMemory()
  .withGuardrails()
  .withCostTracking()
  .withObservability({ verbosity: "normal" })
  .build();

Decision Matrix

Decision	Start here	Move when
Provider	Anthropic	You need local/offline (ollama) or existing proxy infra (litellm)
Model tier	Mid/high capability	Latency or budget pressure dominates quality
Memory tier	Tier 1	You need semantic similarity retrieval (Tier 2 vectors)
Reasoning strategy	Adaptive	Workload is consistent and you want deterministic behavior
Tools	Built-ins only	You need external systems via MCP/custom tools

Strategy Selection Cheat Sheet

Workload	Strategy
API automation / deterministic tool work	reactive
Long multi-step tasks with explicit plans	plan-execute-reflect
Exploration and branching ideas	tree-of-thought
Self-critique and iterative improvement	reflexion
Mixed unknown workloads	adaptive

Cost-First vs Quality-First Profiles

Cost-first profile

.withProvider("ollama")
.withModel("qwen3:4b")
.withContextProfile({ tier: "local", toolResultMaxChars: 800 })
.withReasoning({ defaultStrategy: "reactive" })
.withMaxIterations(6)

Quality-first profile

.withProvider("anthropic")
.withModel("claude-sonnet-4-6")
.withReasoning({ defaultStrategy: "adaptive" })
.withMemory({ tier: "enhanced" })
.withVerification()
.withMaxIterations(20)

Team-Based Starting Points

Internal copilots

• Guardrails + identity + audit
• Tier 1 memory
• Adaptive strategy
• Normal observability

Autonomous operations agents

• Gateway + policies + kill switch
• Strong budgets and alerts
• Event subscriptions for suppression/exhaustion events

Research/reporting agents

• Tools + verification + memory tier 2
• Plan-execute or reflexion
• Higher max iterations

Anti-Patterns to Avoid

• Turning on all layers before proving need
• Using tier: "enhanced" memory without an embedding provider configured
• Long max iterations without budget controls
• MCP subprocess usage without guaranteed disposal

Next Steps

Context Engineering Tune compaction, truncation, and tier-aware prompts for your model size.

Tools & MCP Wire built-in tools, MCP servers, and custom tools via defineTool or ToolBuilder.

Production Deployment Harden the stack you just chose: budgets, kill switch, structured logs, audit.

Local Models Guide Pick a model + tier on Ollama. The healing pipeline keeps 4B+ tool calling viable.