Mastra vs Eve: El Mejor Framework de Agentes de IA en TypeScript en 2026

Si estás construyendo agentes de IA en TypeScript, dos frameworks dominan la conversación a mediados de 2026: Mastra y Vercel Eve.

Ya uso Mastra en trabajo real. Construí un asistente completo con herramientas de archivos, shell, búsqueda web, automatización de navegador y memoria persistente, y escribí una guía de Mastra paso a paso con el código en GitHub. Así que esta comparación no es teórica por el lado de Mastra. Eve es la opción nueva que quería evaluar con honestidad contra esa experiencia.

Mastra es la opción madura. La v1.0 se publicó en enero de 2026, tiene más de 26K estrellas en GitHub, ~1.1M de descargas semanales en NPM y corre en producción en Replit (96% de éxito en tareas), PayPal y Marsh McLennan. Es basado en código, portable y se despliega en cualquier lugar donde corra Node.js.

Eve es el nuevo aspirante de Vercel. Lanzado el 17 de junio de 2026 en la conferencia Vercel Ship, apuesta por un enfoque de filesystem primero: tu agente es un directorio. Vercel ejecuta más de 100 agentes internos con Eve, incluido un agente de análisis de datos que gestiona más de 30K consultas de Slack al mes.

La decisión se resume en: ¿máxima portabilidad o máxima comodidad en Vercel?

Esto es un cara a cara en precios, dependencia de plataforma, madurez y DX. Si ya conoces Mastra por la guía de construcción, salta a la comparación directa.

De un vistazo: tabla comparativa de Mastra vs Eve

Las dos filas que más importan: despliegue/dependencia de plataforma y madurez. Las mejores funciones de Eve están atadas a la infraestructura de Vercel. Mastra lleva 18 meses de ventaja en endurecimiento para producción. Todo lo demás son detalles.

¿Qué es Mastra?

Mastra fue creado por Sam Bhagwat y el equipo fundador de Gatsby. Levantó una ronda semilla de $13M (YC W25) con inversores como Paul Graham y Guillermo Rauch (el CEO de Vercel). Ese último detalle es interesante dada la competencia.

La filosofía es composición basada en código. Piensa en el modelo mental de un ORM o un cliente de base de datos: defines agentes, herramientas y workflows como objetos tipados en código. La configuración es explícita. Lo ves todo delante de ti.

Diagrama de arquitectura de Mastra

Funciones clave de Mastra: agentes, workflows, memoria y evals

Los agentes son la primitiva central. Creas una clase Agent con instrucciones, herramientas, memoria y un modelo, y luego llamas a generate() o stream():

import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { Memory } from '@mastra/memory';

const weatherAgent = new Agent({
  id: 'weather-agent',
  name: 'Weather Bot',
  instructions: 'You are a helpful weather assistant.',
  model: openai('gpt-4o-mini'),
  tools: { getWeather },
  memory: new Memory({ storage: { type: 'postgres' } }),
});

const response = await weatherAgent.generate('What is the weather in Tokyo?');

Los workflows usan un patrón builder basado en grafos con .then(), .branch() y .parallel(). Soportan suspend/resume para escenarios con humano en el bucle:

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

export const onboardingWorkflow = new Workflow({
  name: 'onboarding',
  triggerSchema: z.object({ accountId: z.string() }),
})
  .step(new Step({ id: 'verify', execute: verifyAccount }))
  .step(new Step({ id: 'enrich', execute: enrichWithCRM }))
  .parallel([
    new Step({ id: 'send_welcome', execute: sendWelcomeEmail }),
    new Step({ id: 'schedule_call', execute: scheduleKickoff }),
  ])
  .commit();

La memoria es donde Mastra realmente brilla. Tiene cuatro niveles: historial de mensajes, memoria de trabajo, recuerdo semántico (95% en el benchmark LongMemEval) y RAG. El Memory Gateway corre como servicio independiente. Si te interesa la memoria de agentes, lee nuestra comparación de sistemas de memoria para agentes.

Los evals permiten puntuar el rendimiento del agente con evaluadores por modelo, por reglas y estadísticos:

import { evaluate } from '@mastra/evals';

await evaluate(refundAgent, {
  testCases: refundGoldenSet,
  scorers: [policyComplianceScorer, costScorer],
  threshold: 0.9,
});

El soporte MCP te permite tanto crear como consumir servidores MCP. Si no conoces el protocolo, consulta qué es MCP y cómo funciona. Para saber cuándo las herramientas nativas de Mastra superan a un MCP siempre activo (y el coste en RAM de los servidores stdio), lee herramientas de Mastra vs MCP.

La observabilidad incluye una UI de navegador Studio en local, una plataforma cloud y logs/trazas/métricas completos. En mi propio asistente, Studio es lo que uso a diario para el chat y las trazas mientras desarrollo.

Precios de Mastra: del plan gratuito a enterprise

El markup de tokens a través del Gateway es tarifa de mercado + 5.5%.

Punto clave: el framework central es Apache 2.0. Puedes autoalojar Mastra gratis. Los planes de pago son para la plataforma cloud (Studio, Memory Gateway, observabilidad). Si quieres control total, combínalo con un proveedor de VPS económico como Hetzner y gastarás menos de $10/mes en infraestructura.

Los precios de los VPS subieron en todos los proveedores en 2026 — si estás replanteándote un servidor alquilado, mira qué cambió y cuándo gana un mini PC.

Ventajas y desventajas de Mastra

Ventajas:

Desventajas:

• La documentación va por detrás de la velocidad del código. Los patrones documentados pueden estar desactualizados
• Solo TypeScript. Sin soporte para Python
• Los patrones opinados pueden resultar restrictivos cuando tu caso de uso se desvía
• Incidente de cadena de suministro en junio de 2026 (cuenta de colaborador dormida secuestrada, más de 140 paquetes maliciosos)
• La compresión de memoria ejecuta llamadas LLM en segundo plano con coste adicional
• El ecosistema de integraciones aún está creciendo frente a LangGraph

¿Qué es Vercel Eve?

Eve se lanzó el 17 de junio de 2026 en la conferencia Vercel Ship. Está construido por Vercel, el equipo detrás de Next.js.

La filosofía es filesystem primero, convención sobre configuración. Tu agente es un directorio. Suelta archivos en las carpetas correctas y el framework se encarga del resto. Sin registro, sin cableado de boilerplate. El nombre del archivo se convierte en el nombre de la herramienta.

Vercel está ejecutando Eve en producción. Más de 100 agentes internos impulsan desde análisis de datos hasta automatización de ventas.

La arquitectura de Eve: filesystem primero

Un agente Eve es un directorio con una estructura concreta:

my-agent/
└── agent/
    ├── agent.ts            # model and runtime config
    ├── instructions.md     # always-on system prompt
    ├── tools/              # typed functions the model can call
    │   └── get_weather.ts
    ├── skills/             # procedures loaded on demand
    │   └── plan_a_trip.md
    ├── channels/           # message channels
    │   └── slack.ts
    ├── schedules/          # recurring cron jobs
    │   └── weekly_recap.ts
    └── subagents/          # specialized child agents

Estructura de directorios de Vercel Eve

Una herramienta es simplemente un archivo en tools/:

import { defineTool } from 'eve/tools';
import { z } from 'zod';

export default defineTool({
  description: 'Return mock weather data for a city.',
  inputSchema: z.object({ city: z.string().min(1) }),
  async execute({ city }) {
    return { city, condition: 'Sunny', temperatureF: 72 };
  },
});

La configuración del agente es mínima:

import { defineAgent } from 'eve';

export default defineAgent({
  model: 'anthropic/claude-sonnet-4.6',
});

Y tu system prompt es solo un archivo markdown:

# Identity
You are an expert weather assistant.
You can fetch the weather for any city in the world.

Otras funciones clave:

• Ejecución durable (Vercel Workflow SDK): los pasos con checkpoint sobreviven a caídas, redespliegues y arranques en frío.
• Computación en sandbox: Vercel Sandbox (VM aislada) para producción, más backends locales: Docker, microsandbox, bash. Si te interesa ejecutar herramientas de IA en contenedores aislados, el enfoque de sandbox de Eve merece un vistazo.
• Humano en el bucle: añade needsApproval: true en cualquier herramienta. La sesión se pausa hasta que alguien aprueba.
• Multicanal: Slack, Discord, Teams, Telegram, Twilio, GitHub, Linear, API HTTP. El mismo agente, todos los canales.
• Vercel Connect: OAuth intermediado. El modelo nunca ve las credenciales.
• AI Gateway: enrutado de modelos con fallback entre proveedores.

Los ejemplos de producción internos de Vercel muestran lo que Eve puede hacer:

Precios de Eve: costes de infraestructura de Vercel

Eve en sí es gratis (Apache 2.0). Los costes vienen de la infraestructura de Vercel:

• Plan Vercel Pro: $20/mes (incluye $20 de crédito para recursos)
• Functions: precios estándar de Vercel Functions
• Workflows: precios de Vercel Workflows
• Sandbox: ~$0.128/h por computación en sandbox
• AI Gateway: tokens del proveedor de modelos + markup de Vercel
• Tokens de modelo: pase directo al proveedor

No hay una línea separada de “Eve” en tu factura. Todo se factura contra los recursos de tu plan de Vercel.

El truco: la predictibilidad de costes. Los precios de Mastra son por niveles y fijos. Los de Eve son por uso y escalan con la computación. Para agentes siempre activos, el sandbox a $0.128/h suma (~$92/mes por agente siempre activo).

Ventajas y desventajas de Eve

Ventajas:

Desventajas:

• Fuerte dependencia de Vercel: ejecución durable, sandbox, conectores y gateway requieren Vercel
• Muy nuevo / beta (v0.11.4). Las APIs pueden cambiar antes de la GA
• Deriva de dependencias: los paquetes pre-release (@ai-sdk, @vercel/connect) pueden romperse. Hay que fijar versiones
• Observabilidad escasa para fallos previos a la ejecución (webhook mal configurado, etc.)
• Trampa silenciosa en la ruta del trigger: la integración con Slack requiere un flag específico o falla en silencio
• Los límites de cron más estrictos que una vez al día requieren un plan de pago
• Sin soporte para Python

Mastra vs Eve: comparación directa de los factores clave de decisión

Las funciones son similares sobre el papel. Las diferencias reales emergen cuando miras el despliegue, la madurez, el coste y la experiencia de desarrollador en condiciones reales.

Flexibilidad de despliegue y dependencia del proveedor

Mastra se despliega en cualquier parte: Vercel, Netlify, Cloudflare Workers, Hono/Express/Next.js independiente, tu propio VPS. Cero dependencia de plataforma. El núcleo es Apache 2.0. Si quieres autoalojarlo en un Hetzner de $5/mes, adelante. Así es exactamente como ejecuto mi asistente Mastra en la práctica. Si quieres algo aún más ligero para agentes autoalojados, mira la guía de configuración de Hermes Agent.

Eve requiere Vercel para producción. El desarrollo local es posible con backends de Docker o microsandbox, pero la ejecución durable, el sandbox, los conectores y el AI Gateway necesitan infraestructura de Vercel.

El impacto en el mundo real: si Vercel cambia sus precios o necesitas moverte a otra nube, Mastra es portable. Eve exige una refactorización importante. El sentimiento de la comunidad en Reddit refleja esto. Los desarrolladores escarmentados por el acoplamiento de Next.js son escépticos ante otra dependencia de Vercel.

Si te autoalojas, proveedores de VPS económicos como Hetzner hacen que los despliegues de Mastra sean rentables.

Madurez y preparación para producción

Mastra: v1.0 desde enero de 2026. Más de 18 meses de desarrollo activo. 26K estrellas en GitHub. ~1.1M de descargas semanales en NPM. Cumple SOC 2 Tipo II. Entre sus usuarios en producción están Replit (96% de éxito en tareas), PayPal, Marsh McLennan (75K empleados) y SoftBank. Clasificado como el framework TypeScript nº 1 en el benchmark de 9 frameworks de AgentMail.

Eve: beta v0.11.4. Lanzado hace menos de un mes (junio de 2026). ~250 estrellas en GitHub. Vercel ejecuta más de 100 agentes internamente, pero están respaldados por el propio equipo de ingeniería de Vercel, no por desarrolladores externos.

El riesgo clave: las APIs de Eve pueden cambiar significativamente antes de la GA. Construir sistemas de producción sobre APIs beta conlleva riesgo de migración. El contraargumento es que el dogfooding interno de Vercel (d0, Lead Agent, Vertex) sugiere una estabilidad real en producción, aunque la API pública siga en cambio.

Experiencia de desarrollador y curva de aprendizaje

Mastra es basado en código. Resulta familiar si has usado ORMs, clientes SDK o APIs tipadas. La configuración es explícita. La puesta en marcha inicial es más exigente pero más predecible. Defines todo en código y lo ves todo delante de ti.

Eve es filesystem primero. Es familiar si conoces las convenciones del App Router de Next.js. Suelta archivos en directorios y las cosas funcionan. Menos ceremonia para agentes simples. Pero puede confundir cuando las convenciones aún no están documentadas.

Los comandos de scaffolding cuentan la historia:

# Create project
npm create mastra@latest

# Define agent in code
const agent = new Agent({
  id: 'my-agent',
  instructions: 'You are helpful.',
  model: openai('gpt-4o-mini'),
  tools: { myTool },
});

# Create project
npx eve@latest init my-agent

# Agent is a directory:
# agent/instructions.md    ← system prompt
# agent/tools/my_tool.ts   ← just a file
# agent/agent.ts           ← model config

La calidad de la documentación es una preocupación en ambos. Los docs de Mastra van por detrás de la velocidad del código. Los patrones documentados pueden estar muertos en las versiones actuales. Los docs de Eve son nuevos, pero la infraestructura de documentación de Vercel suele ser sólida.

Precios a escala: lo que pagarás de verdad

Mastra tiene niveles predecibles. Gratis si lo autoalojas. $250/mes por la plataforma cloud Teams. Markup de tokens a tarifa de mercado + 5.5%.

Eve es pago por uso vía Vercel. El plan Pro cuesta $20/mes. Sandbox a ~$0.128/h. Functions, Workflows y AI Gateway suman coste. Es más difícil predecir el gasto mensual.

Así quedan las cuentas a diferentes escalas:

Mastra es más predecible. Eve puede ser más barato para cargas de trabajo intermitentes pero caro para agentes siempre activos.

Memoria, estado y ejecución durable

Mastra tiene un sistema de memoria de 4 niveles: historial de mensajes, memoria de trabajo, recuerdo semántico (95% en el benchmark LongMemEval) y RAG. El Memory Gateway corre como servicio independiente. La compresión de memoria mediante llamadas LLM en segundo plano sí añade coste. Para una mirada más profunda a los enfoques de memoria de agentes, consulta Cognee vs Hindsight.

Eve gestiona la persistencia de sesión mediante el Vercel Workflow SDK. Los pasos con checkpoint sobreviven a caídas, redespliegues y arranques en frío. No hay servicio de memoria independiente. El enfoque de Eve trata más del estado de ejecución que del recuerdo semántico a largo plazo.

La diferencia práctica: Mastra es mejor para agentes que necesitan recordar y recuperar información entre sesiones (soporte al cliente, personalización). Eve es mejor para agentes que necesitan sobrevivir a eventos de infraestructura (caídas, redespliegues) dentro de una sesión.

Ambos ofrecen ejecución durable. Mastra lo hace mediante suspend/resume de workflows. Eve lo hace mediante checkpoints del Vercel Workflow SDK.

Comparación de código: construir el mismo agente en Mastra y en Eve

Construyamos un agente del tiempo sencillo en ambos frameworks para mostrar la diferencia de DX.

# Scaffold
npm create mastra@latest

// src/agents/weather.ts
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

const getWeather = createTool({
  id: 'get-weather',
  description: 'Return weather data for a city.',
  inputSchema: z.object({ city: z.string() }),
  execute: async ({ context }) => {
    return { city: context.city, condition: 'Sunny', temp: 72 };
  },
});

export const weatherAgent = new Agent({
  id: 'weather-agent',
  name: 'Weather Bot',
  instructions: 'You are a helpful weather assistant.',
  model: openai('gpt-4o-mini'),
  tools: { getWeather },
});

// Usage
const response = await weatherAgent.generate('What is the weather in Tokyo?');

# Scaffold
npx eve@latest init my-agent

<!-- agent/instructions.md -->
# Identity
You are an expert weather assistant.
You can fetch the weather for any city in the world.

// agent/tools/get_weather.ts
import { defineTool } from 'eve/tools';
import { z } from 'zod';

export default defineTool({
  description: 'Return mock weather data for a city.',
  inputSchema: z.object({ city: z.string().min(1) }),
  async execute({ city }) {
    return { city, condition: 'Sunny', temperatureF: 72 };
  },
});

// agent/agent.ts
import { defineAgent } from 'eve';

export default defineAgent({
  model: 'anthropic/claude-sonnet-4.6',
});

El trade-off: Mastra es más explícito y autocontenido, bueno para iterar rápido y verlo todo de una vez. Eve reparte la lógica entre archivos, mejor cuando personas distintas son dueñas de herramientas, instrucciones o canales, pero con más carga cognitiva para un agente simple.

¿Quieres el recorrido completo que usé para mi propio asistente? Consulta el tutorial completo de Mastra o clona el repositorio mastra-assistant.

Marco de decisión: cuándo elegir Mastra y cuándo Eve

No hay un ganador universal. La infraestructura, el equipo y la tolerancia al riesgo lo deciden.

Diagrama de decisión: Mastra vs Eve

Elige Mastra si…

Elige Eve si…

Considera alternativas si…

Alternativas que vale la pena considerar

Más allá de Mastra y Eve, hay algunas opciones que conviene conocer:

Vercel AI SDK es para casos de uso más simples. UI de streaming, enrutado de modelos, llamadas a herramientas básicas. Sin abstracciones de agente, sin memoria, sin workflows. Si eso es todo lo que necesitas, sáltate un framework de agentes completo.

LangGraph.js es el port a TypeScript de LangGraph. Más pesado, pero encaja mejor si tu equipo también usa LangGraph en Python y quiere el mismo modelo mental.

Flue es nuevo, filesystem primero como Eve pero agnóstico de plataforma. Vale la pena vigilarlo si te gusta la DX de Eve sin la dependencia de Vercel.

El patrón “agente como directorio” es común en 2026. Eve y Flue lo usan. Es una reacción contra el estilo cargado de boilerplate de frameworks anteriores.

Para una comparación de frameworks de estilo similar, consulta Astro vs Next.js vs TanStack Start.

Si quieres un agente de codificación con IA en lugar de un framework para construir agentes, OpenCode Go es un camino distinto. Para enrutado multi-modelo sin un framework de agentes completo, Agent Router unifica Claude Code, OpenAI Codex y Gemini CLI.

Veredicto final: Mastra vs Eve en 2026

El trade-off sigue siendo portabilidad vs comodidad nativa de Vercel.

Para la mayoría de los equipos TypeScript que envían agentes a producción hoy, Mastra es la apuesta más segura. Es maduro, portable, cumple SOC 2 y está probado a escala. El sistema de memoria de 4 niveles es sólido. Puedes desplegar en cualquier parte y mover la infraestructura sin reescribir agentes. Por eso construí mi propio asistente de archivos/web/navegador sobre Mastra y sigo mejorándolo en abierto.

Para equipos nativos de Vercel que quieren la DX más rápida y pueden vivir con el riesgo beta, Eve es atractivo. El filesystem primero es una DX agradable. El multicanal de serie ahorra trabajo de integración. El dogfooding interno de Vercel (más de 100 agentes) sugiere que madurará rápido tras la GA.

Eve después de la GA puede cerrar la brecha de madurez. Los docs y el ecosistema de Mastra aún necesitan trabajo. La competencia aquí es buena para ambos.

Preguntas frecuentes