Mastra

Mastra provides a unified TypeScript runtime for defining and executing AI agents that abstract over multiple LLM providers (OpenAI, Anthropic, etc.) through a provider-agnostic interface. Agents are defined as TypeScript classes with methods that map to LLM tool calls, enabling type-safe agent logic without provider lock-in. The framework handles provider-specific protocol differences (function calling schemas, streaming formats, token counting) transparently.

Mastra enables defining multi-step workflows as composable TypeScript functions where each step can invoke LLMs, tools, or other steps with automatic state threading between steps. Workflows support branching, loops, and error recovery through a declarative step definition pattern. State is automatically passed between steps and persisted across execution, enabling long-running workflows and resumable execution from failure points.

Mastra provides abstractions for integrating with external APIs and webhooks, enabling agents and workflows to trigger external systems and respond to events. The framework handles HTTP requests, authentication (API keys, OAuth), request/response serialization, and error handling for external integrations. Webhooks can trigger workflows or agent execution based on external events.

Mastra supports deploying agents and workflows to serverless platforms (AWS Lambda, Vercel Functions, etc.) and traditional servers. The framework handles environment configuration, credential injection, and optimization for serverless constraints (cold starts, execution time limits). Deployment is managed through CLI tools or infrastructure-as-code integrations.

Mastra provides a schema-based tool registry where developers define tools as TypeScript functions with JSON Schema parameter definitions. The framework automatically generates provider-specific function calling schemas (OpenAI format, Anthropic format, etc.) and handles tool invocation, parameter validation, and result serialization. Tools are registered centrally and can be reused across agents and workflows with automatic schema adaptation per provider.

Mastra integrates vector embeddings for semantic memory, enabling agents to store and retrieve relevant context from past interactions or documents. The framework provides abstractions for embedding generation (via providers like OpenAI, Anthropic), vector storage backends, and semantic search over stored memories. Memory can be scoped to individual agents, conversations, or shared across agents, with automatic relevance ranking and context injection into LLM prompts.

Mastra enables agents to extract structured data from LLM outputs by defining JSON schemas and automatically validating responses against those schemas. The framework uses provider-native structured output features (OpenAI's JSON mode, Anthropic's structured output) when available, falling back to prompt-based extraction with validation. Extracted data is automatically typed and validated before being passed to downstream steps or returned to the application.

Mastra supports streaming LLM responses at token-level granularity, enabling real-time UI updates and progressive result rendering. The framework abstracts streaming across different providers (OpenAI, Anthropic, etc.) with a unified streaming interface. Streaming works with agents, workflows, and tool calls, allowing applications to display partial results as they become available rather than waiting for complete responses.

Mastra provides built-in observability for agent and workflow execution through structured logging of all steps, tool calls, LLM requests/responses, and state changes. The framework integrates with observability platforms (e.g., Langsmith, custom logging backends) to capture execution traces, enabling debugging, monitoring, and performance analysis. Traces include timing information, token counts, costs, and error details at each step.

Mastra provides a templating system for defining reusable prompts with variable interpolation, conditional sections, and dynamic content injection. Prompts are defined as TypeScript strings or template files with support for injecting context, memory, tool descriptions, and other dynamic content. The framework handles prompt formatting, variable substitution, and optimization (e.g., token count estimation) transparently.

Mastra provides built-in error handling and retry mechanisms for LLM calls, tool invocations, and workflow steps. The framework supports configurable retry policies with exponential backoff, jitter, and provider-specific error classification (rate limits, transient errors, etc.). Errors are caught, logged, and can trigger fallback behaviors or workflow branching based on error type.

Mastra enables building multi-agent systems where agents can communicate through message passing and share context. Agents can invoke other agents, pass results between them, and coordinate on complex tasks. The framework manages agent lifecycle, message routing, and shared state across agents, enabling hierarchical and collaborative agent architectures.