VoltAgent

Abstracts OpenAI, Anthropic, Google AI, Groq, and other LLM providers through the Vercel AI SDK v5 integration, enabling runtime model switching without code changes. The Agent class exposes generateText(), streamText(), generateObject(), and streamObject() methods that normalize provider-specific APIs into a unified interface, with support for dynamic model selection based on task requirements or cost optimization.

Provides createTool() helper and ToolManager class for declarative tool definition with JSON schema validation. Tools are registered with input/output schemas, automatically marshaled into LLM function-calling payloads, and executed with type safety. The framework handles tool invocation within agent loops, error handling, and result normalization across different LLM provider function-calling APIs (OpenAI, Anthropic, etc.).

Provides VoltAgent CLI and create-voltagent-app scaffolding tool for initializing new agent projects with pre-configured templates. The CLI generates project structure, installs dependencies, and sets up configuration files for common patterns (chatbot, multi-agent system, workflow, etc.). The scaffolding includes example agents, tools, and memory setup, enabling developers to start building immediately.

Integrates with vector databases (e.g., Pinecone, Weaviate, Milvus) for storing and retrieving embeddings. Agents can embed documents or facts, store them in vector databases, and perform semantic search during reasoning. The framework handles embedding generation (via OpenAI, Cohere, or local models), vector storage, and retrieval. RAG patterns are supported natively, enabling agents to augment reasoning with retrieved context.

Provides lifecycle hooks (onBeforeExecute, onAfterExecute, onToolCall, onMemoryAccess, etc.) enabling developers to inject custom logic at key points in agent execution. Hooks are implemented as middleware, allowing composition of multiple handlers. Developers can use hooks for logging, monitoring, validation, or modifying agent behavior without changing core agent code.

Implements OperationContext to track execution across multi-agent systems, maintaining parent-child relationships, request IDs, and execution metadata. Each agent operation creates a context that flows through tool calls, subagent delegations, and memory accesses. Contexts enable distributed tracing, error attribution, and debugging of complex multi-agent workflows.

Normalizes messages from different sources (HTTP, WebSocket, voice, MCP, A2A) into a unified message format. The framework handles protocol-specific serialization/deserialization, enabling agents to work with messages regardless of their origin. Message types include text, tool calls, and structured data, with consistent handling across all protocols.

Implements SubAgentManager for delegating tasks from parent agents to child agents through a delegate_task tool. Agents can decompose complex problems into subtasks, assign them to specialized subagents, and aggregate results. The system maintains parent-child relationships, passes context through operation contexts, and supports recursive delegation (agents delegating to other agents).

Provides Memory class with pluggable storage adapters (LibSQLMemoryAdapter, PostgreSQLStorage, SupabaseStorage, InMemoryStorage) enabling agents to persist and retrieve conversation history, facts, and state. The Memory V2 architecture separates storage concerns from memory logic, supporting both short-term working memory and long-term persistent storage. Agents can query memory using semantic search (via vector embeddings) or keyword-based retrieval.

Integrates with the Model Context Protocol (MCP) standard, allowing agents to discover and invoke tools exposed by MCP servers. Agents can connect to external MCP servers (local or remote), dynamically load tool definitions, and execute them as if they were native tools. The framework handles MCP protocol negotiation, tool schema translation, and result marshaling.

Implements an Agent-to-Agent (A2A) protocol enabling agents to communicate directly with each other, send messages, and coordinate on tasks. Agents can invoke other agents as tools, passing context and receiving results. The A2A protocol handles message serialization, routing, and response aggregation across distributed agent instances.

Provides workflow system for defining task graphs with dependencies, conditional branching, and parallel execution. Workflows are declared as configurations specifying task sequences, conditions, and error handling. The framework executes workflows, manages task state, and coordinates agent execution across workflow steps. Workflows can be composed from agents, tools, and other workflows.

Provides a Hono-based HTTP server that exposes agents as REST API endpoints. The server handles request routing, authentication, request/response serialization, and streaming. Agents are exposed as endpoints (e.g., POST /agents/:agentId/chat) that accept messages and return responses. The server supports both request-response and streaming modes, with built-in support for WebSocket upgrades for real-time communication.

Provides voice package enabling agents to accept voice input (speech-to-text), process it, and return voice output (text-to-speech). The framework integrates with speech recognition and synthesis APIs (e.g., OpenAI Whisper for STT, ElevenLabs or similar for TTS). Voice interactions are normalized into text messages, processed by agents, and converted back to speech for output.

Integrates OpenTelemetry for comprehensive observability, capturing agent execution traces, tool invocations, LLM API calls, and memory operations. The framework exports traces to external observability platforms (Datadog, New Relic, Jaeger, etc.). Traces include span attributes for agent decisions, tool inputs/outputs, and latency metrics. The VoltOps platform provides a dashboard for monitoring agent behavior.