Choose Mastra if: You're building a TypeScript/Next.js agent product from scratch You want built-in memory, RAG, and workflows without assembling libraries You need production patterns (persistence, observability) out of the box Choose LangGraph if: Your agent workflow has complex branching, loops, or human approval steps You need the LangChain ecosystem of 700+ integrations You want visual debugging of agent execution paths via LangGraph Studio Choose CrewAI if: Your use case maps naturally to

Best AI Agent Framework Starter Kits 2026

TL;DR

Mastra is the strongest all-in-one TypeScript agent framework in 2026 — built-in agent memory, tool calling, RAG, and workflows with first-class Next.js integration. LangGraph is the most flexible for complex multi-step agent graphs, especially in Python. CrewAI has the simplest API for multi-agent role-based collaboration. Vercel AI SDK is the right choice if you want a minimal agent layer inside an existing Next.js app without adopting a full framework. AutoGen Studio is best for non-developers or teams that want a visual builder for multi-agent conversations. Pick based on your language (TypeScript vs Python), whether you need multi-agent orchestration, and how much framework you want around your agents.

Feature Matrix

Framework	Language	Agent Memory	Tool Calling	RAG Built-in	Visual Builder	License
Mastra	TypeScript	✅ Built-in (libSQL, Postgres)	✅ Native	✅ Native (pgvector, Pinecone)	❌	Apache 2.0
LangGraph	Python / JS	✅ Checkpointer API	✅ Native	Via LangChain	✅ LangGraph Studio	MIT
CrewAI	Python	✅ Short/long-term	✅ Native	Via tools	❌	MIT
Vercel AI SDK	TypeScript	❌ Manual	✅ Native	❌ Manual	❌	Apache 2.0
AutoGen Studio	Python	✅ Conversation state	✅ Native	Via tools	✅ Web UI	MIT

Mastra — TypeScript-First Agent Framework

Language: TypeScript | License: Apache 2.0 | GitHub: 20K+ stars

Mastra came out of the team behind the Vercel AI SDK and fills the gap that SDK deliberately left open: a full agent framework with opinions about memory, RAG, workflows, and tool management. Where the Vercel AI SDK gives you primitives (streamText, generateObject, tool), Mastra gives you an agent runtime.

The core abstraction is the Agent class. You define an agent with a model, system prompt, tools, and memory configuration. Mastra handles the tool-calling loop, conversation persistence, and RAG retrieval automatically.

import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";
import { memory } from "./memory";
import { searchDocs, createTicket } from "./tools";

const supportAgent = new Agent({
  name: "Support Agent",
  model: openai("gpt-4o"),
  instructions: `You are a support agent. Search documentation before
    answering questions. Create tickets for issues you cannot resolve.`,
  tools: { searchDocs, createTicket },
  memory,
});

const response = await supportAgent.generate(
  "My API key isn't working after rotation"
);

The memory system is what separates Mastra from lighter alternatives. It ships with adapters for libSQL (SQLite), PostgreSQL, and Upstash, and automatically stores conversation threads, semantic memory (embeddings of past interactions), and working memory (structured state the agent maintains across turns). You don't build a conversation history table — Mastra manages it.

RAG is native, not bolted on. Mastra includes a rag module with document loaders, chunking strategies, embedding generation, and vector store adapters (pgvector, Pinecone, Qdrant). When you configure RAG on an agent, it automatically retrieves relevant context before every LLM call. No separate retrieval pipeline to build — the agent's generate method handles it.

Workflows are the other differentiator. Mastra's workflow engine lets you chain agents with conditional branching, parallel execution, human-in-the-loop approval steps, and retry logic. This is where single-agent chat becomes a multi-step autonomous system. The workflow engine includes built-in observability: every step logs its input, output, duration, and token usage, making production debugging significantly easier than tracing through ad-hoc chain calls.

import { Workflow, Step } from "@mastra/core/workflow";

const triageWorkflow = new Workflow({ name: "ticket-triage" })
  .step(classifyIntent)
  .then(routeToTeam)
  .branch({
    billing: handleBilling,
    technical: handleTechnical,
    feature: createFeatureRequest,
  })
  .commit();

Best for: TypeScript teams building production agent products who want an opinionated framework with built-in memory, RAG, and workflows. If you're already in the Next.js ecosystem, Mastra is the natural choice — it uses the Vercel AI SDK under the hood for model calls.

If you're evaluating AI starters more broadly, see our comparison of AI/LLM boilerplates for options that include billing, auth, and full SaaS infrastructure alongside AI features.

LangGraph + LangChain Templates — Graph-Based Agent Orchestration

Language: Python / JavaScript | License: MIT | GitHub: 8K+ stars (LangGraph)

LangGraph models agents as state machines. Every agent is a graph: nodes are functions (LLM calls, tool executions, human input), edges are transitions (conditional routing, loops). This graph-first approach makes complex agent architectures — where an agent needs to plan, execute, reflect, and retry — explicit and debuggable rather than buried in prompt chains.

LangChain provides a template gallery with pre-built agent architectures: ReAct agents, plan-and-execute agents, multi-agent supervisors, and RAG agents. These templates are full project scaffolds with pyproject.toml, environment configuration, and deployment scripts for LangServe.

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode

# Define agent state
class AgentState(TypedDict):
    messages: list
    next_step: str

# Build the graph
graph = StateGraph(AgentState)
graph.add_node("reason", call_llm)
graph.add_node("act", ToolNode(tools))
graph.add_node("reflect", evaluate_result)

graph.add_edge(START, "reason")
graph.add_conditional_edges("reason", should_act, {
    "use_tool": "act",
    "respond": END,
})
graph.add_edge("act", "reflect")
graph.add_edge("reflect", "reason")  # loop back

agent = graph.compile(checkpointer=memory_store)

The checkpointer API is LangGraph's memory system. It persists the full graph state at every node, enabling conversation continuity, time-travel debugging (replay from any checkpoint), and human-in-the-loop patterns where execution pauses at a node and resumes after human approval. This state persistence model is more powerful than simple conversation history — you can serialize the entire agent's reasoning progress and resume from any point.

LangGraph Studio provides a visual builder for designing and debugging agent graphs. You can see the state at each node, replay executions, and identify where agents go off track. This is genuinely useful for debugging complex multi-step agents where the failure mode is "the agent chose the wrong branch at step 4."

The JavaScript version of LangGraph (@langchain/langgraph) brings the same graph abstractions to TypeScript, though the ecosystem is smaller. Most LangGraph templates and community examples are Python-first. If your team is TypeScript-primary, evaluate whether the graph model is essential to your use case — if not, Mastra or the Vercel AI SDK will have better ecosystem support.

Best for: Teams building complex agent architectures with branching logic, retry loops, and multi-agent coordination. Python-primary teams, or anyone who needs the LangChain ecosystem of 700+ integrations (document loaders, vector stores, retrievers). If you've already explored the LangChain Starter vs Vercel AI Starter comparison, LangGraph is the next step up for agent-specific workflows.

CrewAI — Role-Based Multi-Agent Collaboration

Language: Python | License: MIT | GitHub: 25K+ stars

CrewAI takes a different approach to multi-agent systems: instead of graphs or workflow engines, you define agents with roles, goals, and backstories, then organize them into crews that collaborate on tasks. The mental model is a team of specialists working together, not a state machine.

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data on market trends",
    backstory="You are an expert analyst at a top consulting firm.",
    tools=[search_tool, scrape_tool],
    llm="gpt-4o",
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, data-driven reports",
    backstory="You write for a developer audience. No fluff.",
    llm="gpt-4o",
)

research_task = Task(
    description="Research the top 5 AI agent frameworks by GitHub stars, funding, and adoption.",
    agent=researcher,
    expected_output="Structured data with sources",
)

writing_task = Task(
    description="Write a comparison report based on the research.",
    agent=writer,
    expected_output="2000-word markdown report",
    context=[research_task],  # receives research output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process="sequential",
)

result = crew.kickoff()

CrewAI's simplicity is its strength. The API surface is small: Agent, Task, Crew, and Tool. You can define a multi-agent system in under 50 lines. Agents have short-term memory (current task context) and long-term memory (persisted across runs via RAG over past results). The framework handles delegation — agents can ask other agents for help during task execution.

The trade-off: CrewAI is less flexible than LangGraph for complex control flow. You get sequential or hierarchical process execution, but not arbitrary graph topologies. If your agent needs conditional branching with retry loops, LangGraph is the better fit. If your agent needs "a researcher finds data, a writer turns it into content, an editor reviews it," CrewAI is faster to build.

Best for: Python teams building multi-agent systems where the collaboration pattern maps naturally to roles and tasks. Content pipelines, research workflows, data processing chains. If you're building an AI chatbot product with a single agent, CrewAI is overkill — look at Vercel AI SDK or Mastra instead.

Vercel AI SDK + Next.js Agent Starter — Minimal Agent Layer

Language: TypeScript | License: Apache 2.0 | npm: 1M+ weekly downloads

The Vercel AI SDK isn't an agent framework — it's a toolkit for building AI features in JavaScript applications. But its tool primitive, maxSteps parameter for agentic loops, and streamText/generateText functions are enough to build capable agents without adopting a framework.

The agent pattern in the Vercel AI SDK is straightforward: define tools, set maxSteps to allow the model to call tools and reason over results in a loop, and let the SDK handle the tool-calling protocol.

import { streamText, tool } from "ai";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

const result = streamText({
  model: openai("gpt-4o"),
  system: "You are a helpful assistant that can search and calculate.",
  messages,
  tools: {
    search: tool({
      description: "Search the knowledge base",
      parameters: z.object({ query: z.string() }),
      execute: async ({ query }) => searchKnowledgeBase(query),
    }),
    calculate: tool({
      description: "Evaluate a math expression",
      parameters: z.object({ expression: z.string() }),
      execute: async ({ expression }) => eval(expression),
    }),
  },
  maxSteps: 5, // agent can call tools up to 5 times
});

There's no built-in memory, no RAG pipeline, no workflow engine. You build those yourself or pull in libraries. The next-ai-chatbot template on GitHub provides a starting point with conversation persistence (Vercel KV or Postgres), file attachments, and multi-model support — but it's a chat app, not an agent framework.

The advantage is control and bundle size. The Vercel AI SDK adds minimal abstraction. You understand every line of your agent code because you wrote it. There's no framework magic hiding tool-calling loops or memory management. For teams that want agents inside an existing Next.js application without restructuring around a framework, this is the right choice.

The SDK also has the broadest model provider support in the TypeScript ecosystem: OpenAI, Anthropic, Google Gemini, Mistral, Groq, Perplexity, and any OpenAI-compatible API. Switching models is a one-line import change. For agent products that need to offer users a choice of models, or that need fallback routing between providers, this flexibility matters.

Best for: Teams with an existing Next.js app that need to add agent capabilities without adopting a framework. Solo developers who want to understand every layer. Products where the agent is one feature, not the entire product. Pairs well with any Next.js SaaS boilerplate — add agent features incrementally.

AutoGen Studio — Visual Multi-Agent Builder

Language: Python | License: MIT | GitHub: 40K+ stars (AutoGen)

Microsoft's AutoGen is a framework for multi-agent conversations where agents talk to each other to solve problems. AutoGen Studio adds a visual interface on top: you design agent teams, configure their capabilities, and test conversations through a web UI without writing code.

The core concept is ConversableAgent — an agent that can send and receive messages from other agents. You compose agents into group chats with different topologies: round-robin, speaker selection (an LLM picks who talks next), or custom routing.

from autogen import ConversableAgent, GroupChat, GroupChatManager

coder = ConversableAgent(
    name="Coder",
    system_message="Write Python code to solve tasks. Return only code.",
    llm_config={"model": "gpt-4o"},
)

reviewer = ConversableAgent(
    name="Reviewer",
    system_message="Review code for bugs and security issues.",
    llm_config={"model": "gpt-4o"},
)

executor = ConversableAgent(
    name="Executor",
    system_message="Execute approved code and return results.",
    code_execution_config={"work_dir": "workspace"},
)

group_chat = GroupChat(
    agents=[coder, reviewer, executor],
    messages=[],
    max_round=10,
    speaker_selection_method="auto",
)

manager = GroupChatManager(groupchat=group_chat)
await coder.initiate_chat(manager, message="Analyze sales data in data.csv")

AutoGen Studio is the visual layer. You drag agents into a workspace, configure their LLM backends and system prompts, add tools (functions they can call), and run test conversations. The studio persists agent configurations and conversation histories in a local database.

The framework's strength is conversational multi-agent patterns where agents debate, critique, and refine each other's output. Code generation with review, research with fact-checking, writing with editing — patterns where iteration between agents produces better results than a single agent pass.

AutoGen's weakness for web application developers: it's a backend framework designed for notebooks and scripts, not HTTP request/response cycles. There's no built-in web server, no streaming API, and no frontend integration. If you're building a user-facing product, you'll need to wrap AutoGen agents in a FastAPI or Flask server yourself. The visual Studio is primarily a prototyping tool, not a production deployment target.

Best for: Teams exploring multi-agent architectures who want a visual interface for prototyping. Research teams, internal tool builders, and Python developers who want to experiment with agent topologies before committing to code. Less suited for production web applications — AutoGen is a backend framework, not a web application starter.

Architecture Comparison

The five frameworks represent three distinct architecture patterns for agent systems:

Single-agent with tools (Vercel AI SDK, Mastra): One agent with access to tools, running in a loop until the task is complete. Simple, predictable, sufficient for most product use cases. The agent decides which tool to call and when to stop.

Graph-based orchestration (LangGraph): Agents as state machines with explicit control flow. Nodes are computation steps, edges are transitions. Best for complex workflows where you need deterministic routing, retries, and human-in-the-loop approval at specific steps.

Multi-agent conversation (CrewAI, AutoGen): Multiple agents with different roles collaborating through message passing. Best for tasks that benefit from specialization and iteration — research, content creation, code review. Higher token costs due to inter-agent communication.

For most production applications in 2026, single-agent with tools is the right starting point. Multi-agent systems add complexity and cost — every inter-agent message is an additional LLM call, and debugging a conversation between three agents is significantly harder than tracing one agent's tool-calling loop. Start with one well-prompted agent with the right tools, and add multi-agent patterns only when you have a clear use case that benefits from agent specialization.

The cost difference is measurable. A single-agent system with 5 tool calls to complete a task might use 10K-20K tokens total. A multi-agent system with 3 agents collaborating on the same task can consume 50K-100K tokens due to inter-agent communication overhead. At GPT-4o pricing ($2.50/M input, $10/M output), that's the difference between $0.01 and $0.05 per task — which compounds fast at scale.

If you're adding agent features to an existing SaaS product rather than building an agent-first product, our guide to adding AI features to SaaS boilerplates covers the infrastructure patterns (token billing, rate limiting, streaming) that apply regardless of which framework you choose.

When to Use Which

Choose Mastra if:

You're building a TypeScript/Next.js agent product from scratch
You want built-in memory, RAG, and workflows without assembling libraries
You need production patterns (persistence, observability) out of the box

Choose LangGraph if:

Your agent workflow has complex branching, loops, or human approval steps
You need the LangChain ecosystem of 700+ integrations
You want visual debugging of agent execution paths via LangGraph Studio

Choose CrewAI if:

Your use case maps naturally to roles: researcher, writer, reviewer
You want the simplest API for multi-agent collaboration
Python is your primary language and you want fast prototyping

Choose Vercel AI SDK if:

You have an existing Next.js app and want to add agent features
You want minimal abstraction and full control over every layer
The agent is one feature in your product, not the entire product

Choose AutoGen Studio if:

You want a visual interface for designing agent teams
You're prototyping multi-agent conversation patterns
Non-developers on your team need to configure agent behavior

For teams evaluating the broader AI starter kit landscape — including MCP server boilerplates and AI SaaS starters with Claude and OpenAI — the framework choice depends on whether you're building an agent-first product or adding agent features to existing infrastructure. Agent-first products benefit from Mastra or LangGraph. Existing products adding agent capabilities benefit from the Vercel AI SDK's lightweight approach.

The SaaS Boilerplate Matrix (Free PDF)