VoltAgent: a TypeScript agent framework with a separate console for tracing and operations

Two products in one repository: a framework and a console

VoltAgent describes itself as an end-to-end AI Agent Engineering Platform with two parts. The first is the open-source TypeScript framework, which covers memory, RAG, guardrails, tools, MCP, voice and workflows. The second is the VoltOps Console, offered as Cloud or Self-Hosted, which handles observability, automation, deployment, evals, guardrails and prompts. The repository is MIT licensed, not archived, written mostly in TypeScript, and its last push landed on 2026-10-15. The latest tagged core release is @voltagent/[email protected] from 2026-09-28. The split has a practical consequence: the framework runs on its own, but the operational features you may be attracted to, such as tracing and deployment, sit in the console, so decide early whether you will use the hosted version or run your own.

The scaffold wires a Hono server, a logger and optional LibSQL memory

The entry point is the create-voltagent-app CLI:

npm create voltagent-app@latest

The command guides you through setup, and the generated starter code lives in src/index.ts, which registers an agent and an expense approval workflow found in src/workflows/index.ts. The starter imports VoltAgent, Agent and Memory from @voltagent/core, LibSQLMemoryAdapter from @voltagent/libsql, createPinoLogger from @voltagent/logger, honoServer from @voltagent/server-hono, and openai from @ai-sdk/openai, plus a weatherTool from ./tools. So the default stack is an HTTP server on Hono, Pino logging and the AI SDK's OpenAI provider. Afterwards you navigate to the project and start it:

npm run dev

That command compiles and runs your code through tsx and prints the VoltAgent server startup message.

Memory falls back to in-memory unless you attach an adapter

A comment in the starter marks the Memory instance as optional persistent memory and says to remove it to use the default in-memory store. The consequence is easy to miss: if you delete the adapter or never configure one, whatever the agent has remembered is gone when the process restarts. Persistent memory comes from adapters, and the recent releases include @voltagent/[email protected] and @voltagent/[email protected], both dated 2026-08-27, alongside the LibSQL adapter used by the starter. The framework describes memory as durable adapters that let agents remember context across runs, so the durability comes from the adapter you pick, not from the core package. If you deploy to a host with an ephemeral filesystem, check where a local LibSQL file would end up before trusting it.

Supervisors, sub-agents and a declarative workflow engine

Multi-agent work is built around a supervisor runtime that routes tasks to specialized sub-agents and keeps them in sync. Separately, the workflow engine lets you describe multi-step automations declaratively instead of stitching together custom control flow, and the starter's expense approval workflow is the example of that. Agents are defined in @voltagent/core with typed roles, tools, memory and model providers in one place. Tools are Zod-typed and come with lifecycle hooks and cancellation. Guardrails intercept and validate agent input or output at runtime to enforce content policies, and eval suites can run alongside workflows. Two paths exist for multi-step logic, supervisors for delegation and workflows for fixed sequences, so you need to choose which one a given problem belongs to before you build it.

MCP, voice and resumable streaming are built in, with named providers

The tool registry connects to Model Context Protocol servers without extra glue code. Voice adds text-to-speech and speech-to-text with OpenAI, ElevenLabs or a custom provider, so a different vendor means writing your own provider. Resumable streaming lets a client reconnect to an in-flight stream after a page refresh and keep receiving the same response, which matters for chat interfaces. LLM compatibility is described as swapping between OpenAI, Anthropic, Google or other providers by changing config rather than rewriting agent logic. The examples folder backs this up with directories such as with-anthropic, with-amazon-bedrock, with-cloudflare-workers, with-a2a-server, with-composio-mcp, with-chroma and next-js-chatbot-starter-template, which are the quickest way to see a given integration in code.

RAG has two routes, and one is a managed service

Retrieval is offered as retriever agents that pull facts from your data sources and ground responses before the model answers. There is also the VoltAgent Knowledge Base, which is described as a managed RAG service for document ingestion, chunking, embeddings and search. The word managed is the catch: using it means your documents go to a hosted service rather than staying inside your own stack, so it is a data-handling decision as well as a feature choice. If you must keep documents in your own infrastructure, the retriever route with your own sources is the one that matches. Pricing and limits for the managed service are not given in the repository, so confirm those on voltagent.dev before building on it.

Contributing means a pnpm, Lerna and Nx monorepo with strict tooling

Working on the framework itself is heavier than using it. The root package.json is private, named voltagent at version 0.1.0, and requires Node 20 or newer and pnpm 8 or newer, with packageManager pinned to [email protected]. The build uses Lerna and Nx, releases go through Changesets, formatting and linting use Biome and Prettier, and commits are checked with commitlint and Husky. Tests run on Vitest. Top-level entries include packages/, examples/, website/, docs/, i18n/ and an archive/ folder, with a script named archive:deprecated for retiring packages. For someone who only consumes the npm packages none of this matters, but a contributor should install the pinned pnpm version to match the lockfile. For AI coding assistants, the @voltagent/mcp-docs-server package exposes VoltAgent documentation, examples and changelogs to tools such as Claude, Cursor or Windsurf.

Editorial conclusion

Choose VoltAgent if your agents live in a TypeScript codebase and you want memory, workflows, guardrails and MCP in one set of packages. Skip it if your team works in Python or wants a no-code builder. Before adopting, check which parts you need from the cloud or self-hosted console, and replace the default in-memory store with a real adapter early.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. VoltAgent/voltagent on GitHub