VoltAgent

Overview

VoltAgent is an open-source TypeScript AI agent framework focused on observability-first development. While most agent frameworks prioritize developer ergonomics, VoltAgent's distinguishing bet is that production agents are fundamentally observability problems — so it ships tracing, metrics, evaluation hooks, and session management as first-class primitives rather than bolt-on integrations.

The project gained 32 points on Hacker News and targets teams who have outgrown the "console.log" era of agent development. VoltAgent supports LangChain, OpenAI, Anthropic, and any compatible provider, but the framework's identity is defined by its observability layer.

Features

• OpenTelemetry-native tracing: every agent step produces a span, ready for Jaeger, Grafana, or Datadog
• Prompt/version tracking: prompts are versioned, hashed, and attached to every trace
• Evaluation hooks: score any step with custom evaluators (rule-based or LLM-as-judge)
• Session management: first-class sessions with automatic conversation history
• Tool registry: declare tools once, use them in any agent
• Multi-provider: OpenAI, Anthropic, Google Gemini, Groq, Ollama
• TypeScript-first: end-to-end type safety from prompt to response

Installation

# npm
npm install @voltagent/core @voltagent/telemetry

# pnpm
pnpm add @voltagent/core @voltagent/telemetry

# yarn
yarn add @voltagent/core @voltagent/telemetry

Quick Start

import { VoltAgent, OpenAIProvider } from "@voltagent/core";

const agent = new VoltAgent({
  name: "research-agent",
  provider: new OpenAIProvider({ model: "gpt-4o" }),
  systemPrompt: "You are a research assistant.",
  tools: [
    {
      name: "search_web",
      description: "Search the web",
      execute: async ({ query }) => webSearch(query)
    }
  ]
});

const response = await agent.invoke("What is MCP?");
console.log(response.content);

Tracing Setup

import { OpenTelemetryTelemetry } from "@voltagent/telemetry";

const telemetry = new OpenTelemetryTelemetry({
  exporter: new OTLPExporter({
    endpoint: "http://localhost:4318/v1/traces"
  }),
  serviceName: "research-service"
});

const agent = new VoltAgent({
  name: "research-agent",
  provider: new OpenAIProvider({ model: "gpt-4o" }),
  telemetry,
});

Each agent invocation produces a trace with:

• LLM call spans (model, tokens, latency)
• Tool execution spans (input, output, error)
• Step spans (prompt, response, tool calls)
• Resource attributes (agent name, version, session ID)

Evaluation

import { Evaluator } from "@voltagent/core";

const hallucinationEvaluator = new Evaluator({
  name: "hallucination-check",
  type: "llm-judge",
  judgeModel: "gpt-4",
  rubric: "Score 1-5 on factual accuracy. Penalize unsupported claims.",
  threshold: 3
});

const agent = new VoltAgent({
  name: "research-agent",
  provider: new OpenAIProvider({ model: "gpt-4o" }),
  evaluators: [hallucinationEvaluator]
});

Sessions

const session = await agent.createSession({ id: "user-42" });

const response = await session.invoke({
  messages: [
    { role: "user", content: "Who am I?" }
  ]
});
// Response includes session context, trace ID, and token usage

Pros

• ✅ Observability as a first-class primitive: no separate integration required
• ✅ OpenTelemetry-native: works with any OTLP backend, not just vendor telemetry
• ✅ Built-in evaluation hooks: LLM-as-judge and rule-based evaluators out of the box
• ✅ Session management: conversation history handled for you
• ✅ TypeScript-first: full type safety from prompt to response
• ✅ Multi-provider: same agent interface across OpenAI, Anthropic, Gemini, Groq

Cons

• ❌ Young project: ~300 GitHub stars, small contributor base
• ❌ TypeScript-only: no Python SDK
• ❌ Telemetry defaults to local OTLP: production backends (Datadog, New Relic) require manual config
• ❌ No built-in memory: long-term memory is delegated to external systems (Mem0, Zep, etc.)
• ❌ No graph primitives: multi-step orchestration is imperative, not declarative

When to Use

Use VoltAgent when:

• You need production observability from day one (tracing, metrics, evaluation)
• You're TypeScript-first and want end-to-end type safety
• Your team is already on OpenTelemetry — VoltAgent plugs in without new infrastructure
• You need LLM-as-judge evaluation integrated with your runtime

Prefer alternatives when:

• You need Python — use MCP-Agent or Pydantic AI
• You need graph-based orchestration — use LangGraph
• You need enterprise-grade deployment — use LangGraph Platform or Databricks

Resources

• GitHub Repository
• Documentation
• Show HN discussion