Mastra

Mastra is an open-source TypeScript AI agent framework that bundles agents, workflows, RAG, memory, evals, and observability into a single coherent stack — built by the team behind Gatsby. We rate it 86/100 — the most polished and ergonomic option for JavaScript and TypeScript teams shipping LLM agents to production.

What is Mastra?

Mastra is a Node.js framework for building AI agents and agentic workflows in TypeScript. It was created by Sam Bhagwat, Smith Maru, and Abhi Aiyer — the same team that founded Gatsby — and incubated at Y Combinator. The repository was first published on August 6, 2024, the project went public in October 2024, and the team shipped the long-awaited v1.0 release in January 2026. By that point Mastra had crossed 22,000 GitHub stars and roughly 300,000 weekly npm downloads.

The pitch is simple: most agent frameworks (LangChain, LlamaIndex, CrewAI) were born in Python and ported reluctantly to JavaScript. Mastra was designed TypeScript-first from day one, so types flow end to end and the API feels native to the Node.js, Next.js, and Vercel-style ecosystem rather than a translation layer.

Key Features of Mastra

• Agents: An LLM reasons about goals, picks tools, and iterates internally until it returns an answer or hits a stopping condition. Tools are typed TypeScript functions with Zod schemas, so input validation is automatic.
• Graph workflows: An explicit step engine with .then(), .branch(), and .parallel() for deterministic orchestration when you do not want the model deciding control flow.
• Human-in-the-loop: Workflows can be suspended and resumed indefinitely against persistent storage, so you can pause for approval and pick up the exact state hours or days later.
• Memory and RAG: First-class conversation history, retrieval over your own sources, plus working memory and semantic recall — all wired into the agent loop without bolt-on libraries.
• MCP servers: Mastra can author Model Context Protocol servers, exposing your agents and tools to Claude Desktop, Cursor, or any MCP-aware client out of the box.
• Evals and observability: Built-in evaluators and OpenTelemetry-style AI tracing surface model calls, tool executions, and workflow steps in the local Studio and any compatible backend.
• Mastra Studio (Playground): Run npm create mastra@latest, start the dev server, and a local UI at http://localhost:4111 lets you chat with agents, replay traces, and inspect workflow state interactively.

What Users Say About Mastra

On Hacker News and r/LocalLLaMA, the recurring praise is the developer experience: end-to-end TypeScript types, fast cold starts, and a studio that actually surfaces what the agent did. Independent benchmarks circulating in early 2026 reported P95 latency of ~1,240ms versus ~2,450ms for LangChain, a build-time of 18 hours versus 41 hours on a comparable RAG agent, and lower error rates (5.8% vs 8.9%) — numbers worth treating as directional rather than gospel, but they match the ergonomic story users tell.

The honest complaints are also consistent. Several breaking changes between v0.3 and v0.4 (notably the workflow API rewrite) burned early adopters, and integration coverage is much narrower than LangChain's hundreds of connectors — Mastra ships closer to 50–60. Python-shop teams also note that the TypeScript-only stance creates a real coordination cost when ML engineers think in notebooks.

Mastra Pricing

The framework itself is fully open source under Apache 2.0. Mastra Cloud is the optional managed deployment layer, and the public pricing page lists three tiers:

Plan	Price	Key Limits
Starter	$0	Unlimited users and deployments, 100,000 observability events, 24 hours of CPU uptime, 10 GB egress
Teams	$250 per team / month	Multiple teams, custom SSO, SOC 2 documentation, 250 hours of CPU time, 100 GB egress
Enterprise	Custom	RBAC, support SLA, dedicated support engineer, custom CPU and egress

Add-ons are billed à la carte: $10 per 1M model tokens, $10 per 100,000 observability events, $100 per additional project, and $10 per GB of extra egress.

Who Should Use Mastra?

Best for: TypeScript and JavaScript teams shipping production LLM features inside Next.js, Node.js, or React stacks; founders building agentic SaaS who want types, evals, and tracing without gluing five libraries together; engineers who want an MCP server with one decorator instead of a sidecar.

Not ideal for: Python-first AI teams with existing LangChain, LlamaIndex, or DSPy infrastructure; projects that depend on the long tail of LangChain integrations Mastra has not yet wrapped; teams that cannot tolerate any further API churn before v1.x stabilizes.

Pros and Cons

Pros:

• End-to-end TypeScript types from agent definition to tool inputs — Zod-validated, autocompleted in your IDE.
• One framework for agents, deterministic workflows, RAG, evals, and tracing — far less duct tape than the Python alternatives.
• Local Studio at localhost:4111 gives you a real playground and trace viewer without paying for SaaS.
• MCP-server authoring is first class, which lines up with how editors like Cursor and Claude Desktop expect tools to ship in 2026.
• Apache 2.0 core — you can self-host the framework with no vendor lock-in.

Cons:

• Integration count lags LangChain by an order of magnitude — niche tools and SaaS connectors often require hand-rolling.
• API churn through v0.x left a real taste in early adopters' mouths; long-term stability promises are unproven beyond a few months of v1.x.
• TypeScript-only excludes Python ML engineers from contributing directly.
• Mastra Cloud's $250/team starting tier is steep relative to a Vercel or Fly.io footprint, even if Cloud is optional.

Alternatives to Mastra

Langfuse covers tracing and evals but does not give you agents or workflows. LangChain.js still has the broadest integration catalog, at the cost of a heavier and more Python-shaped API. Vercel's AI SDK is lighter and great for chat UIs, but stops short of Mastra's workflow engine, memory, and MCP authoring story.

Verdict: Is Mastra Worth It?

If you are writing TypeScript and you want to ship an LLM agent or agentic workflow to production this quarter, Mastra is the most coherent option on the market in 2026. The framework rewards teams who pick one stack and commit to it; it is less suited to polyglot AI shops that already lean on Python tooling. We rate it 86/100 — held back from the 90s only by the still-young integration catalog and the API churn that preceded v1.0, both of which look likely to improve through 2026.

Frequently Asked Questions

Is Mastra free?

Yes. The Mastra framework is open source under Apache 2.0 and free to self-host. Mastra Cloud has a free Starter tier with 24 hours of CPU uptime and 10 GB of egress; paid Teams plans start at $250 per team / month.

What platforms does Mastra support?

Mastra runs on any Node.js 18+ runtime — Linux, macOS, Windows, Vercel, Cloudflare Workers, AWS, and Mastra Cloud — and integrates with React, Next.js, Vercel AI SDK UI, and CopilotKit on the client.

How does Mastra compare to LangChain?

Mastra is TypeScript-native with end-to-end types, a built-in workflow engine, evals, and a local Studio. LangChain is Python-first (with a JavaScript port) and offers a larger integration catalog. Mastra wins on developer experience and benchmarks; LangChain wins on breadth.

Is Mastra open source?

Yes. The core framework is Apache 2.0 on github.com/mastra-ai/mastra. A small set of enterprise features under any ee/ directory uses a separate Mastra Enterprise License for production use.

Who built Mastra?

Mastra is built by Sam Bhagwat, Smith Maru, and Abhi Aiyer — the founding team of Gatsby — and is backed by Y Combinator.