VoltAgent

A VoltAgent application registers agents and workflows on a VoltAgent instance, which serves them over HTTP through a server adapter such as @voltagent/server-hono. Agents run on the Vercel AI SDK; @voltagent/core 2.x declares ai 6.x as a peer dependency. Each agent is a model plus instructions, tools and optional memory.

Multi-agent coordination uses a supervisor. When an agent has subAgents, the framework adds a delegate_task tool and lists the sub-agents in the supervisor's system prompt. The supervisor's model picks the targets, the sub-agents run the task with their own tools, and results come back as an array for the supervisor to combine. Sub-agents can be supervisors themselves. Delegated messages are tagged so the supervisor's memory reads can leave them out.

Workflows are a separate, explicit path: a typed chain of steps that can call agents, branch, run in parallel or race, and pause with suspend(). Execution state is stored through a Memory adapter, which is what allows restart and replay. Conversation memory is keyed by user and conversation ID and defaults to an in-memory adapter unless LibSQL, Postgres or another adapter is configured.

A tool created with needsApproval: true, or with a function that decides per call, is not executed when the model calls it. The agent returns a tool part in the approval-requested state; the application shows it to a user and sends back an approval or denial, for example through the AI SDK useChat helper. Approved tools run on the next step, and a denial is passed to the model. Workspace tool policies can switch approval on for file writes and deletes.

In workflows, a step calls suspend() with a reason and optional data, then reads resumeData (validated by a resumeSchema) when the run is resumed. Runs can also be suspended from outside through a suspend controller, cancelled from the stream handle, or restarted from their last checkpoint. In supervisor setups, the onHandoffComplete hook sees each sub-agent result before the supervisor does.

npm create voltagent-app@latest

import { Agent, VoltAgent, createTool } from "@voltagent/core";
import { honoServer } from "@voltagent/server-hono";
import { z } from "zod";

const refund = createTool({
  name: "issueRefund",
  description: "Refund an order",
  parameters: z.object({ orderId: z.string() }),
  needsApproval: true,
  execute: async ({ orderId }) => ({ ok: true, orderId }),
});
const billing = new Agent({ name: "billing", purpose: "Handles refunds and invoices",
  instructions: "Resolve billing requests.", model: "openai/gpt-4o-mini", tools: [refund] });
const triage = new Agent({ name: "triage", instructions: "Route requests to specialists.",
  model: "openai/gpt-4o-mini", subAgents: [billing] });

new VoltAgent({ agents: { triage, billing }, server: honoServer() });

• The quick start asks for Node.js 20.19 or newer so the generated tsdown build resolves ESM correctly.
• A provider key such as OPENAI_API_KEY must be in .env if it was skipped during create-voltagent-app.
• 2.x aligns with AI SDK v6: upgrade ai to ^6 and @ai-sdk/* providers to ^3 alongside @voltagent/*; generateObject / streamObject are deprecated in favour of generateText / streamText with structured output.
• Memory defaults to an in-memory adapter, and A2AServer keeps tasks in memory unless you supply a task store.
• The dev server listens on port 3141 by default.

Yes. MCPConfiguration connects agents to MCP servers over stdio, streamable HTTP or SSE, and @voltagent/mcp-server exposes a VoltAgent project to MCP clients.

The framework is MIT-licensed. The VoltOps Console for observability, evals and deployment has a free Developer plan, paid plans and an Enterprise option with self-hosted deployment.

TypeScript. The quick start asks for Node.js 20.19 or newer, and version 2.x expects AI SDK v6 packages.

It can serve agents over A2A through @voltagent/a2a-server; no A2A client is documented. For AG-UI, the @voltagent/ag-ui package connects agents to CopilotKit.

A supervisor agent lists subAgents and receives a delegate_task tool. Its model decides which sub-agents get a task and then combines their results.