10 Best TypeScript AI Agent Frameworks in 2026 for Node.js Teams

Last updated October 24, 2026. We built the same one-tool agent in all 10 frameworks that day, ran each five times offline on Node.js 22, logged every model request, and checked docs, releases, and npm downloads.

The best TypeScript AI agent frameworks in 2026 are the Vercel AI SDK, Mastra, and LangGraph.js, because they combine typed tools, active releases, and millions of weekly npm installs. OpenAI Agents SDK, Google ADK for TypeScript, and Strands Agents follow, and the right pick depends on your model vendor, your cloud, and how much framework you want to ship.

TypeScript AI agent frameworks give Node.js teams the agent loop, typed tool calls, memory, and workflows without leaving their stack. This guide sits in our agent frameworks hub, and our guide to the 12 best AI agent frameworks covers the Python side and the wider market.

On October 24, 2026 we installed each framework fresh, built one pricing agent with one tool, and recorded install size, cold start, memory, and every byte sent to a local model server. No vendor paid for placement or reviewed this page, per our editorial standards and disclosure policy.

TypeScript Agent Frameworks Compared at a Glance

Every framework here runs a tool-calling agent on Node.js, so the useful differences are what each one adds around the loop and what that costs you in packages, memory, and prompt bytes. The table combines each project’s docs with our own test on October 24, 2026, using the latest npm release of each.

Framework	Best for	Version tested	Install size	Start to answer	Bytes per job	Weekly npm installs
Vercel AI SDK	Most Node.js and Next.js apps	ai 7.0.151	29 MB	0.17 s	1.4 KB	18.4 million
Mastra	All-in-one agents, workflows, and memory	1.79.0	158 MB	0.60 s	1.4 KB	1.3 million
LangGraph.js	Stateful graphs and middleware	langchain 1.5.19	115 MB	0.46 s	1.5 KB	2.1 million
OpenAI Agents SDK	Handoffs, voice, and sandbox agents	0.21.0	84 MB	0.36 s	1.5 KB	1.2 million
Google ADK for TypeScript	Gemini and Google Cloud teams	2.3.0	148 MB	0.58 s	1.4 KB	138,000
Strands Agents	AWS and Bedrock teams	1.22.0	68 MB	0.34 s	1.5 KB	333,000
Genkit	Firebase and full-stack apps	1.43.0	363 MB	0.46 s	2.0 KB	130,000
VoltAgent	A hosted console for agent ops	2.11.0	268 MB	0.43 s	1.4 KB	23,800
Ax	Typed signatures and prompt tuning	25.4.5	24 MB	0.16 s	3.7 KB	28,100
BeeAI Framework	Rule-constrained agents	0.1.31	92 MB	0.34 s	5.0 KB	872

Verdict: Choose the Vercel AI SDK for a lean agent inside an existing Node.js or Next.js app, Mastra when you want workflows, memory, and a dev studio in one package, and LangGraph.js for durable, branching flows. Pick OpenAI Agents SDK for handoffs and voice, Google ADK on Gemini, and Strands Agents on AWS.

How We Chose and Tested These Frameworks

We started with code-first frameworks that publish a TypeScript package on npm, document a tool-calling agent, shipped a release in 2026, and can talk to an OpenAI-compatible endpoint or, for Google ADK, a Gemini-compatible one. That ruled out Python-only projects, visual builders, hosted-only platforms, and archived repositories.

• Same job everywhere: one pricing agent with one get_price tool answers a customer question that carries the reference QX-59, using the same system prompt, tool description, and user message in each script.
• Idiomatic code: we used each project’s main agent class, such as ToolLoopAgent in the AI SDK, createAgent in LangChain, LlmAgent in ADK, and a signature program in Ax.
• Scripted model: a local server played the model with fixed replies and logged each request’s size, tools offered, and whether it streamed.
• Offline and measured: a Node preload refused every connection that left the machine and logged the host. We took peak memory, launch to answer time, and median import time over five fresh processes each.
• Footprint: a fresh npm install per framework on Node.js 22.23 and npm 10, then the same script bundled and minified with esbuild 0.28 to check that it bundles and still runs.

A scripted model replies instantly, so these numbers show the overhead each framework adds, not how well a real model reasons. Real prompts and outputs are larger, so byte gaps grow. We also ran LlamaIndex.TS, which worked, but we left it out of the ranking because its repository is archived.

What Our October 24 Hands-On Test Found

The biggest gap between these frameworks was footprint, not speed: the leanest install was 24 MB and the heaviest was 363 MB for the same one-tool agent. Every framework answered in under a second against an instant model, so for most apps the packages you ship, audit, and bundle matter more than milliseconds.

• Lightest installs: Ax at 24 MB with two packages and the Vercel AI SDK at 29 MB with 12. Strands Agents came third at 68 MB.
• Heaviest installs: Genkit at 363 MB with 519 packages and VoltAgent at 268 MB with 349. Mastra and Google ADK sat near 150 MB.
• Bundles: all 10 bundled with esbuild and ran. Ax produced the smallest bundle at 171 KB gzipped and the AI SDK 222 KB, while Mastra was largest at 1.6 MB and needed one package marked external.
• Memory: the AI SDK and Ax peaked near 81 MB, and Mastra and Google ADK near 150 MB. The archived LlamaIndex.TS peaked highest at 182 MB.

Prompt overhead differed by more than three times for an identical job. Eight frameworks sent between 1.4 and 2.0 KB. BeeAI sent 5.0 KB because its RequirementAgent adds a final_answer tool and forces a tool call on every turn, and Ax sent 3.7 KB because it writes a structured prompt from your signature.

The terminal log shows the side effects we hit. VoltAgent answered correctly but never exited on its own in five of five runs, and without NODE_ENV=production it tried to fetch a model registry from models.dev. VoltAgent and BeeAI also printed AI SDK warnings about system messages, and Google ADK logged one info line per request.

1. Vercel AI SDK: Best for Most Node.js and Next.js Apps

The Vercel AI SDK is the default choice for TypeScript agents in 2026: it was the lightest full framework in our test and it has the largest install base by far. Its agents docs center on the ToolLoopAgent class, with runtimeContext for shared state and per-tool typed context. The ai package had 18.4 million npm installs last week.

Our agent installed in 29 MB across 12 packages, answered in 0.17 seconds, and peaked at 81 MB, with the leanest prompt of the major frameworks at 1.4 KB. The repository has 27,490 stars, ships under Apache 2.0, and released 7.0.152 on October 23. Mastra, VoltAgent, and BeeAI all install AI SDK packages, so learning it pays off later.

• Best for: teams adding agents to Node.js, Next.js, or edge apps who want small installs and many model providers.
• Built in (October 2026): the tool loop agent, typed tools with Zod, structured output, streaming UI helpers, and dozens of providers.
• Watch out for: fewer built-in pieces for memory, workflows, and evals, so you assemble those yourself.

2. Mastra: Best All-in-One TypeScript Agent Framework

Mastra is the most starred TypeScript agent framework at 29,036 stars, and it bundles agents, workflows, memory, and a local studio in one project. Its agents docs say to use agents for open-ended tasks and workflows for steps you know in advance. @mastra/core had 1.3 million npm installs last week.

It was the slowest to answer in our test at 0.60 seconds and used 154 MB, with 158 MB installed across 149 packages. Its bundle was the largest at 1.6 MB gzipped, and esbuild needed @opentelemetry/api marked external. The license file keeps folders named ee under a separate enterprise license, with the rest under Apache 2.0.

• Best for: product teams that want agents, workflows, memory, and evals from one vendor.
• Built in (October 2026): agents, graph workflows, memory, RAG, MCP, evals, and a local dev studio.
• Watch out for: the heaviest bundle in our test, Node.js 22.13 or later, and enterprise-licensed folders to check.

3. LangGraph.js: Best for Stateful Graphs and Middleware

LangGraph.js is the pick when an agent needs durable state, branching, and human review, and it now sits under the simpler createAgent API. The LangChain JavaScript docs describe createAgent as a configurable harness that you extend with middleware. @langchain/langgraph had 2.1 million npm installs last week.

Our createAgent run installed 115 MB across 25 packages, answered in 0.46 seconds, peaked at 141 MB, and sent 1.5 KB. The LangGraph.js repository has 3,371 stars under MIT, a small number next to its downloads, since the langchain package installs LangGraph as a dependency.

• Best for: teams that need checkpoints, interrupts, and graph-shaped flows they can replay.
• Built in (October 2026): createAgent with middleware, StateGraph, checkpointers, and Deep Agents for planning and subagents.
• Watch out for: two layers of API to learn, and older tutorials written for earlier LangChain.js releases.

4. OpenAI Agents SDK: Best for Handoffs, Voice, and Sandbox Agents

OpenAI Agents SDK keeps the primitive list short, with agents, sandbox agents, voice agents, handoffs, and guardrails covering most agent apps. The TypeScript docs call it the production upgrade of Swarm. The repository has 3,938 stars under MIT, and @openai/agents had 1.2 million npm installs last week.

Our run installed 84 MB, answered in 0.36 seconds, and peaked at 113 MB. To use a non-OpenAI endpoint we called setOpenAIAPI('chat_completions'), since the SDK defaults to the Responses API, and switched tracing off. Version 0.21.0 is still below 1.0, so expect API changes.

• Best for: teams on OpenAI models that want triage handoffs, realtime voice, or sandboxed workspaces.
• Built in (October 2026): agents, handoffs, agents as tools, guardrails, sessions, tracing, sandbox and realtime voice agents.
• Watch out for: a 0.x version, Responses API defaults, and tracing you should configure before using other models.

5. Google ADK for TypeScript: Best for Gemini and Google Cloud Teams

Google ADK for TypeScript reached 2.0 with graph workflows, giving Node.js teams the same agent model Google ships for Python, Go, and Java. The TypeScript quickstart lists Node.js 24.13 and npm 11.8 as prerequisites, though our test also ran on Node.js 22.23. The adk-js repository has 1,448 stars under Apache 2.0.

ADK speaks the Gemini API, so we pointed it at a Gemini-compatible endpoint. It installed 148 MB across 174 packages, took 0.58 seconds to answer, and peaked at 149 MB, with the smallest prompt at 1.4 KB. It logged one info line per model request, and @google/adk had 138,000 npm installs last week.

• Best for: teams on Gemini and Google Cloud that want graph workflows and dev tools in TypeScript.
• Built in (October 2026): LlmAgent, function tools, graph workflows, sessions, runners, and the adk-devtools package.
• Watch out for: a young TypeScript port, newer Node.js requirements in the docs, and Gemini-first defaults.

6. Strands Agents: Best for AWS and Bedrock Teams

Strands Agents brings the AWS-backed model-driven agent loop to TypeScript, and it was one of the leanest major frameworks in our test. The TypeScript quickstart asks for Node.js 22 or later. The old sdk-typescript repository is archived, and development moved to the harness-sdk repository, which has 8,935 stars.

Our run installed 68 MB across 48 packages, answered in 0.34 seconds, and peaked at 111 MB. It streams by default, and its many AWS integrations are optional peer packages you add only when needed. @strands-agents/sdk released 1.22.0 on October 21 and had 333,000 npm installs last week.

• Best for: AWS teams that want Bedrock, AgentCore, and A2A support with a small core.
• Built in (October 2026): a model-driven agent loop, tools, streaming, MCP, A2A, and Bedrock and OpenAI model providers.
• Watch out for: a repository move that breaks old links, and examples that lean toward AWS services.

7. Genkit: Best for Firebase and Full-Stack Apps

Genkit is the strongest fit for Firebase and full-stack apps that want flows, tool calling, and a local developer UI from one open source project. Its tool calling docs cover defineTool and how the model requests tools from your app. The repository has 6,546 stars under Apache 2.0.

It was the heaviest install in our test at 363 MB and 519 packages, though it answered in 0.46 seconds and peaked at 130 MB. Its prompt was 2.0 KB, about a third larger than the leanest, and it pulls in Zod 3 while most others use Zod 4. We reached OpenAI-compatible endpoints through the @genkit-ai/compat-oai plugin.

• Best for: Firebase and Google Cloud teams that want flows, prompts, and agents in one toolkit.
• Built in (October 2026): flows, tool calling, dotprompt files, a developer UI, and plugins for many model providers.
• Watch out for: a very large dependency tree and a Zod 3 dependency to reconcile with Zod 4 code.

8. VoltAgent: Best for a Built-In Agent Ops Console

VoltAgent pairs an open source TypeScript framework with VoltOps, a console for observability, evals, and deployment. The docs list memory, RAG, guardrails, tools, MCP, voice, and workflows in the core package. The repository has 10,864 stars under MIT, but @voltagent/core had only 23,800 npm installs last week.

It answered correctly in 0.43 seconds, yet the process never exited on its own, so add an explicit shutdown in scripts and jobs. It installed 268 MB across 349 packages, bundles AI SDK 6 while the AI SDK itself is on 7, and tried to reach models.dev unless NODE_ENV was set to production. Its last release, 2.11.0, shipped on September 28.

• Best for: teams that want a hosted or self-hosted console for traces, evals, and prompts beside the framework.
• Built in (October 2026): agents, memory, RAG, guardrails, MCP, voice, workflows, and the VoltOps console.
• Watch out for: processes that stay alive, a network call in development mode, and a large dependency tree.

9. Ax: Best for Typed Signatures and Prompt Tuning

Ax brings DSPy-style programming to TypeScript: you declare inputs and outputs as a signature, and Ax writes, checks, and can tune the prompt. The Ax docs describe native libraries in six languages. The repository has 2,969 stars under Apache 2.0, and @ax-llm/ax had 28,100 npm installs last week.

Ax was the lightest and fastest in our test: 24 MB with two packages, 0.16 seconds to answer, and the smallest bundle at 171 KB gzipped. Its generated prompt was large, so it sent 3.7 KB per job, and it rejected our first field name, request, as too generic. Version 25.4.5 shipped on October 21.

• Best for: teams that want typed inputs and outputs, validation, and prompt optimization from evals.
• Built in (October 2026): signatures, agents with functions, validated outputs, optimizers, and many model providers.
• Watch out for: larger prompts than plain tool loops, strict field naming, and a smaller community.

10. BeeAI Framework: Best for Rule-Constrained Agents

BeeAI Framework focuses on agents that follow hard rules, and it is hosted by the Linux Foundation under open governance. Its docs describe agents with constraints, YAML orchestration, OpenTelemetry tracing, and MCP and A2A support, with Python and TypeScript at feature parity. The shared repository has 3,443 stars.

The npm package needed --legacy-peer-deps to install, and we had to add uuid and Zod 3 by hand before it ran. Its RequirementAgent sent the most bytes, 5.0 KB, and printed two AI SDK warnings, though it answered in 0.34 seconds at 108 MB. beeai-framework had 872 npm installs last week.

• Best for: teams that need enforced tool order and rules, with neutral open governance.
• Built in (October 2026): RequirementAgent rules, workflows, memory, OpenTelemetry, MCP, and A2A.
• Watch out for: install friction on npm, the highest prompt overhead in our test, and a mostly Python community.

Maintenance and Adoption Compared

The Vercel AI SDK leads every adoption measure, while Mastra leads on stars among agent-first frameworks. The table uses GitHub, npm registry, and npm download data collected on October 24, 2026. Downloads show real installs better than stars, though CI pipelines and dependents inflate them, and VoltAgent and BeeAI installs also pull in the AI SDK.

Framework	GitHub stars	License	Latest release	Weekly npm installs
Vercel AI SDK	27,490	Apache 2.0	7.0.152, Oct 23	18.4 million
Mastra	29,036	Apache 2.0 plus ee folders	1.79.0, Oct 21	1.3 million
LangGraph.js	3,371	MIT	1.5.2, Oct 21	2.1 million
OpenAI Agents SDK	3,938	MIT	0.21.0, Oct 20	1.2 million
Google ADK for TypeScript	1,448	Apache 2.0	2.3.0, Oct 13	138,000
Strands Agents	8,935	Apache 2.0	1.22.0, Oct 21	333,000
Genkit	6,546	Apache 2.0	1.43.0, Oct 21	130,000
VoltAgent	10,864	MIT	2.11.0, Sep 28	23,800
Ax	2,969	Apache 2.0	25.4.5, Oct 21	28,100
BeeAI Framework	3,443	Apache 2.0	0.1.31, Sep 28	872

Every project except VoltAgent shipped a release in October. LlamaIndex.TS still drew about 62,000 weekly installs after its archive, a reminder to check repository status before you adopt a package.

How to Build a Lean TypeScript Agent

The AI SDK script below is the one we ran, minus the test harness. It defines one typed tool, caps the loop at five steps, and points at any OpenAI-compatible endpoint, which is how you keep an agent small and portable across providers and gateways.

import { ToolLoopAgent, tool, stepCountIs } from 'ai';
import { createOpenAI } from '@ai-sdk/openai';
import { z } from 'zod';

const openai = createOpenAI({ baseURL: process.env.LLM_BASE_URL });

const agent = new ToolLoopAgent({
  model: openai.chat('gpt-5-mini'),
  instructions: PRICE,
  stopWhen: stepCountIs(5),
  tools: {
    get_price: tool({
      description: 'Look up the price of a product by SKU.',
      inputSchema: z.object({ sku: z.string() }),
      execute: async ({ sku }) => lookupPrice(sku),
    }),
  },
});

const result = await agent.generate({ prompt: question });

• Cap the loop: set a step limit like stopWhen in the AI SDK or maxTurns in Genkit on every agent.
• Set the environment: run with NODE_ENV=production, and check that the process exits after each job.
• Bundle early: try esbuild or your platform bundler on day one, since serverless and edge limits punish large trees.
• Log the wire: point the agent at a logging proxy or one of the LLM gateways we compared to see what the framework adds to each prompt.

Then watch the agent in production. Our AI agent observability tools guide covers tracing for Node.js agents, and our LLM cost monitoring tools guide shows how to catch prompt overhead before the bill does.

Which TypeScript Agent Framework Should You Choose?

Match your team to a profile below, then rebuild our one-tool agent with your own prompts and a logging endpoint before you commit. Each profile names a first choice, a fallback, and the next check to run, so you can shortlist two frameworks in one afternoon.

Teams adding an agent to a Next.js or Node.js app

• Start with the Vercel AI SDK for the smallest install and the most providers.
• Move to Mastra if you also need workflows, memory, and a studio.
• Pick a host with our Cloudflare vs Vercel vs AgentCore comparison.

Teams with long-running or approval-heavy flows

• Choose LangGraph.js for checkpoints, interrupts, and replayable state.
• Use Mastra workflows if your team prefers a single vendor stack.
• Test failure paths before launch with our AI agent testing tools guide.

Teams committed to one model vendor or cloud

• Use OpenAI Agents SDK on OpenAI, Google ADK or Genkit on Google Cloud, and Strands Agents on AWS.
• Connect tools through the Model Context Protocol and the MCP servers we reviewed.
• Score each release with our AI agent evaluation tools guide.

Teams that care most about prompt quality

• Try Ax signatures when you can define typed inputs and outputs and have eval data.
• Keep plain tool loops in the AI SDK when prompt size matters more.
• Version prompts with our prompt management tools guide.

Frequently Asked Questions

Related Guides

Our TypeScript AI agent frameworks ranking points to three names that keep showing up. Our Mastra vs Vercel AI SDK vs LangGraph.js comparison digs into install size, approval gates and durable execution for each.

TypeScript frameworks cover Node.js teams; Microsoft’s Python and .NET options cover Azure shops. Our Microsoft Agent Framework vs Semantic Kernel vs AutoGen comparison tests support status, defaults and migration away from AutoGen.

For related coverage, see our multi-agent frameworks test, open source AI agent frameworks you can self-host and OpenAI Agents SDK vs Claude Agent SDK vs Google ADK comparison.

Read the agent frameworks hub, 12 best AI agent frameworks, AgentOps hub, agent observability coverage, AI agent observability tools, open source LLM observability, AI agent evaluation tools, AI agent testing tools, LLM cost monitoring tools, prompt management tools, LLM gateways, and MCP explained.

The Bottom Line

For most Node.js teams, the Vercel AI SDK, Mastra, and LangGraph.js are the strongest TypeScript AI agent frameworks in 2026, and the right one depends on how much framework you want to ship. The AI SDK keeps installs small, Mastra gives you the full kit, and LangGraph.js handles durable flows.

These projects release weekly, and repositories move or get archived, as LlamaIndex.TS and the Strands TypeScript SDK showed this year. Rerun a logged test after each upgrade, and send corrections or your own results through our contact page.