Flue vs Eve vs Mastra: Frameworks TypeScript de Agentes em 2026

TL;DR

Flue é runtime-agnostic — roda em Cloudflare Workers, Node, Docker, GitHub Actions — e trata o agente como um harness programável sem lock-in. Eve é a extensão natural do ecossistema Vercel: deploy com um comando, sandbox gerenciado, durabilidade embutida, mas com gravidade forte rumo à plataforma. Mastra é o canivete suíço TypeScript-first que já atingiu 1.0 GA, tem 300K+ downloads semanais no npm, e brilha em workflows complexos com integrações pré-construídas. Os três modelam agentes como diretórios de arquivos e compartilham mais semelhanças do que diferenças na superfície — a decisão real está em onde você faz deploy, quanto vendor lock-in aceita, e se precisa de um framework maduro hoje ou de um harness flexível para o futuro.

Introdução

Junho de 2026 vai ser lembrado como o mês em que o ecossistema TypeScript de agentes IA explodiu. Em menos de duas semanas, três eventos convergiram: o time do Astro lançou o Flue em 1.0 beta, a Vercel publicou o Eve em public preview, e o Mastra consolidou sua posição como o framework TypeScript-first mais usado em produção com cases em Replit, SoftBank e PayPal.

Não é coincidência. O mercado chegou num ponto de inflexão onde prototipar agentes com raw model calls já não escala. Todo time que tenta fazer isso acaba reconstruindo os mesmos cinco pedaços difíceis: execução durável que sobrevive crashes, sandbox para código não-confiável, aprovações human-in-the-loop, intake multi-canal, e observabilidade com avaliações contínuas.

Esses três frameworks resolvem esse mesmo conjunto de problemas — mas com filosofias, stacks de deploy e trade-offs radicalmente diferentes. Se você é desenvolvedor TypeScript montando a stack de agentes da sua empresa em julho de 2026, este comparativo existe pra você não precisar gastar semanas avaliando os três.

Antes de mergulhar: se você ainda não decidiu se precisa de um framework de agentes ou se um harness simples como o Pi resolve seu caso, comece por aí. E se a confusão for entre frameworks de agentes e coding agents (Claude Code, Codex), temos um artigo separado que desenha essa fronteira. Aqui o foco é comparar frameworks entre si.

Tabela Comparativa

Antes da prosa, a decisão em formato tabela. Todos os dados foram verificados contra documentação oficial, READMEs e posts de lançamento de cada projeto em junho–julho de 2026.

A tabela revela a convergência: todos os três oferecem skills em markdown, execução durável, sandbox, e model-agnostic na teoria. As linhas que realmente separam são deploy target, maturidade, e ecossistema embutido.

Análise por Eixo

Developer Experience (DX)

A experiência do desenvolvedor é onde os três frameworks mais se parecem — e onde as diferenças sutis revelam filosofias distintas.

Flue trata o agente como código composável. A API central é createAgent(() => ({...})), e o desenvolvedor monta o harness explicitamente: modelo, tools, skills, sandbox — tudo passado como valores. Skills são arquivos Markdown importados como módulos TypeScript via import attributes (import triage from './SKILL.md' with { type: 'skill' }). Isso dá controle total sobre a composição, mas exige que você monte a estrutura. O scaffold vem com npx flue init --target node, onde --target já define o runtime.

// Flue — agente composto em código
import { createAgent } from '@flue/runtime';
import triage from './skills/triage/SKILL.md' with { type: 'skill' };
import * as tools from './tools/github.ts';

export default createAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  tools: [...tools],
  skills: [triage],
  sandbox: local(),
  instructions: `Reproduz bugs e diagnostica a causa raiz.`,
}));

Eve aposta no filesystem-first. O agente é um diretório com convenções: instructions.md é o system prompt, cada arquivo em tools/ vira uma tool (o nome do arquivo é o nome da tool), skills/ guarda markdown carregado sob demanda, e schedules/ define cron jobs. É a mesma filosofia de file-based routing que funcionou em Next.js — o filesystem é o registro. Scaffold: npx eve@latest init my-agent.

// Eve — tool como arquivo com filename = tool name
import { defineTool } from "eve/tools";
import { z } from "zod";

export default defineTool({
  description: "Busca dados meteorológicos de uma cidade.",
  inputSchema: z.object({ city: z.string().min(1) }),
  async execute({ city }) {
    return { city, condition: "Sunny", temperatureF: 72 };
  },
});

Mastra fica entre os dois: tem convenções claras mas não impõe uma estrutura de diretório rígida. A API é type-safe end-to-end com strong typing em tool inputs, agent state, e stream events. O Mastra Studio oferece uma UI interativa para testar agentes, inspecionar traces, e editar prompts — algo que nem Flue nem Eve têm hoje em nível equivalente.

// Mastra — workflows com control flow type-safe
import { Agent, createTool } from '@mastra/core';

const agent = new Agent({
  model: 'anthropic/claude-sonnet-4',
  tools: [weatherTool],
  memory: observationalMemory(),
  instructions: 'Analisa padrões climáticos e sugere ações.',
});

Veredicto DX: Eve ganha em simplicidade de onboarding (filesystem-first, zero config). Mastra ganha em produtividade pós-setup (Studio, type-safety profundo, workflows visuais). Flue ganha em composabilidade para quem quer controle total sobre o harness.

Deploy

Deploy é onde a decisão para de ser preferência estética e vira restrição de infraestrutura.

Flue nasceu runtime-agnostic e leva isso a sério. Os deploy targets oficiais incluem Node.js (qualquer VM ou container), Cloudflare Workers (via SDK oficial com Durable Objects), GitHub Actions, GitLab CI/CD, Daytona e Render. Na Cloudflare, cada agente vira um Durable Object com escalamento automático, storage isolado, e sem necessidade de provisionar servidores. O blog da Cloudflare descreve o mapeamento como “limpo” — runFiber() para durabilidade, @cloudflare/codemode para sandbox, @cloudflare/shell para filesystem virtual.

Eve é Vercel-first. Um agente Eve é um projeto Vercel normal que deploya com vercel deploy — exatamente como um app Next.js. A Vercel carrega a parte difícil: sandbox gerenciado, auth brokered via Vercel Connect, rollback instantâneo quando uma eval regride, e execução durável via Workflow SDK. Eve tem uma arquitetura de adapters que permite rodar em outros hosts, mas a documentação oficial lista apenas Vercel como target de deploy na versão 0.11.4. O custo é gravitacional: recriar o stack de conveniências da Vercel em outro host significa escrever e manter adapters.

Mastra deploya em qualquer ambiente compatível com Node.js — incluindo Bun, Deno, Cloudflare Workers, e Vercel Functions. Server adapters permitem rodar com Express, Hono, ou qualquer HTTP server. É a opção mais flexível em termos de deploy quando combinada com maturidade de produção.

Veredicto Deploy: Se sua infra vive na Cloudflare, Flue é a escolha natural com SDK oficial e integração profunda em Durable Objects. Se vive na Vercel, Eve é o caminho de menor fricção. Se você precisa de flexibilidade real sem amarras, Mastra cobre mais targets com mais battle-testing em produção.

Durabilidade e Execução

Um agent turn não é uma request simples. O modelo faz streaming de tokens, chama tools, espera resultados, pausa para aprovação humana, delega para subagentes. Essa sequência pode durar minutos, e a qualquer momento o processo pode ser interrompido. Sem execução durável, o estado em memória simplesmente desaparece.

Flue resolve com Durable Streams: cada evento na história de execução é adicionado a um log append-only. Prompt, tool response, model choice — tudo é registrado como um ledger imutável. Se o processo morre, outro pega o log e continua do passo exato. Na Cloudflare, isso usa runFiber() para checkpointing nativo dentro do Durable Object, com stash() avançando os checkpoints e onFiberRecovered() entregando o último snapshot para decidir como continuar.

Eve usa o Workflow SDK open-source da Vercel para execução durável. O agente pode fazer checkpoint, pausar e retomar entre crashes e redeploys sem que você construa uma máquina de estado. Aprovações human-in-the-loop pausam o agente até um humano autorizar ações destrutivas.

Mastra oferece workflows com time-travel: persiste o estado automaticamente, permite suspender um workflow e retomar quando quiser, ou “viajar no tempo” de volta a qualquer step com seu contexto original para debug ou replay. Cada step pode suspender execução, passar controle a um humano, e retomar quando o input chegar.

Veredicto Durabilidade: Os três resolvem o problema, mas com abordagens distintas. Flue (Durable Streams) é o mais elegant para ambientes distribuídos e event-sourced. Eve herda a maturidade do Workflow SDK da Vercel. Mastra tem o diferencial de time-travel debugging que nenhum dos outros oferece nativamente.

Ecossistema e Integrações

Flue traz channels pré-configurados para Slack, Teams, Discord, GitHub e mais — com flue add channel slack gerando um blueprint Markdown que coding agents podem ler e integrar. O ecossistema de persistência é plugável (@flue/postgres), observabilidade via OpenTelemetry/Braintrust/Sentry, e frontend via @flue/react (ainda beta). A integração com Cloudflare dá acesso a AI Gateway, Browser Run, Email Service, Agent Memory, AI Search e 14+ model providers via bindings.

Eve oferece channels para Slack, Discord, Teams, Telegram, Twilio, GitHub e Linear, com defineChannel para custom. Auth a sistemas externos via Vercel Connect (OAuth brokered). Frontend via eve/react, eve/vue, eve/svelte. O ecossistema é rico mas gravitacional: quanto mais você usa, mais fica na Vercel.

Mastra é onde ecossistema brilha mais forte. Router unificado com 1000+ modelos, integrações com Next.js, React, Astro, Express, SvelteKit e Hono. MCP como first-class citizen para compartilhar tools entre agentes. Mastra Studio como UI de desenvolvimento. Cases em produção com Replit (milhares de agentes/dia), SoftBank, PayPal, PLAID e Marsh McLennan. Dois livros publicados (Principles e Patterns of Building AI Agents), curso em vídeo, podcast semanal, e comunidade Discord ativa.

Veredicto Ecossistema: Mastra ganha de lavada em maturidade de ecossistema — mais integrações, mais cases, mais conteúdo educacional, comunidade maior. Flue tem a vantagem única da integração profunda com Cloudflare. Eve tem o ecossistema Vercel inteiro como backing, mas está nascendo agora.

Lock-in e Portabilidade

Este é o eixo que mais deveria pesar na decisão — e o que mais gente ignora até ser tarde demais.

Flue é explicitamente anti-lock-in. O README abre com “Not another SDK” e a descrição no GitHub é “the sandbox agent framework.” O modelo é um campo de configuração. O deploy target é um flag no init. A persistência é um adapter. A observabilidade é um adapter. Trocar de provider, host, ou modelo é uma mudança de configuração no harness — não uma reescrita. A dependência honesta é o Pi (harness core), mas isso é engine interna, não vendor billing.

Eve é Vercel-first com escape hatches. O design de adapters é genuíno — o sandbox aceita Docker local, o deploy em teoria aceita outros hosts. Mas a realidade é que sandbox gerenciado, auth brokered, rollback instantâneo, evals integradas, e durable execution são os motivos para escolher Eve — e todos são conveniências da plataforma Vercel. Migrar para fora significa reimplementar tudo isso. A Vercel chama Eve de “framework for agents that run anywhere,” mas o preço da portabilidade é gravitacional, não contratual.

Mastra é Apache-2.0 full open-source, roda em qualquer runtime Node-compatible, e não assume nenhum provider específico. O model router suporta 1000+ modelos. Deploy anywhere é real e battle-tested. A empresa oferece um produto cloud (Mastra Server) mas o framework é completamente self-hostable sem limitações.

Veredicto Lock-in: Flue e Mastra são igualmente portáteis — nenhum assume vendor ou runtime. Eve é portátil na teoria mas gravitacional na prática. Se evitar lock-in é requisito hard, Eve é a opção que merece mais due diligence antes de adotar.

Maturidade

Maturidade em frameworks pré-1.0 é medida em: tempo no mercado, adoção em produção, estabilidade de API, e velocidade de resposta a bugs.

Flue tem repositório público desde fevereiro de 2026 e atingiu 1.0 beta em junho. O fato de ser construído pelo time do Astro (um framework web maduro com anos de produção) dá confiança na qualidade de engenharia, mas a API é nova e pode mudar. Pin versões exatas.

Eve é o mais jovem dos três. Public preview em 16 de junho de 2026 na versão 0.11.4, sob termos beta da Vercel. A Vercel claims “mais de cem agentes em produção internamente,” o que é um sinal de road-testing real, mas APIs vão mudar antes do GA.

Mastra é o mais maduro. 1.0 GA em janeiro de 2026, 25.8K+ stars no GitHub, 300K+ downloads semanais no npm. Cases públicos de produção em escala (Replit criando milhares de agentes Mastra por dia). O framework existe há mais de 15 meses e passou pelo ciclo completo de stabilização de API. Time fundador veio do Gatsby (outro framework web maduro) e é backed pela Y Combinator (W25).

Veredicto Maturidade: Mastra >> Flue > Eve. Se você precisa de um framework estável para produção hoje, Mastra é a única opção que não requer pin de beta versions com expectativa de breaking changes.

Bônus: Vercel AI SDK 7 e o HarnessAgent

Vale mencionar o AI SDK 7 da Vercel neste contexto, porque ele não é um framework de agentes per se, mas introduz um conceito que muda a conversa: o HarnessAgent.

O HarnessAgent é uma API unificada para rodar agent harnesses estabelecidos — incluindo Claude Code, Codex e Pi — dentro de um Vercel Sandbox, através de uma interface uniforme. A ideia é poderosa: assim como o AI SDK sempre permitiu trocar modelos sem reescrever o agente, agora você pode trocar o harness da mesma forma.

import { HarnessAgent } from '@ai-sdk/harness/agent';
import { claudeCode } from '@ai-sdk/harness-claude-code';

const agent = new HarnessAgent({
  harness: claudeCode, // troque por `codex` ou `pi`
  sandbox: createVercelSandbox({ runtime: 'node24' }),
  tools: { /* custom tools */ },
  skills: [ /* custom skills */ ],
});

Isso é relevante porque posiciona o AI SDK como uma camada abaixo de Eve (Eve é construído sobre o AI SDK), e como uma alternativa para quem quer o poder de um harness de coding agent (Claude Code, Codex) sem construir um framework inteiro ao redor.

Para entender como esse padrão de harness e loop funciona na prática, temos um deep-dive separado.

Veredicto por Perfil

Se você é um Cloudflare user

Escolha: Flue.

O SDK oficial da Cloudflare para Flue é integração de primeiro nível. Cada agente vira um Durable Object com escalamento automático, @cloudflare/codemode para sandbox em isolates que iniciam em <10ms por $0.002/load, @cloudflare/shell para filesystem virtual durável, e acesso via bindings a todo o ecossistema Cloudflare (AI Gateway, Browser Run, Containers, Agent Memory). Nenhum outro framework oferece essa profundidade de integração com Workers.

Mastra também deploya em Cloudflare Workers, mas sem a integração nativa em Durable Objects e sem o SDK oficial do lado da Cloudflare.

Se você é um Vercel user

Escolha: Eve (ou mantenha Mastra se já está em produção).

Eve é Next.js para agentes: vercel deploy e acabou. Sandbox gerenciado, auth brokered, rollback em evals, tracing built-in. Se sua infraestrutura já vive na Vercel e você aceita a gravidade do ecossistema, Eve é o caminho de menor fricção possível.

Mas — e esse “mas” importa — Eve é versão 0.11.4 em public preview. Se você precisa de algo em produção agora, Mastra também deploya perfeitamente em Vercel Functions e é GA há 6 meses. A decisão pragmática pode ser Mastra hoje, migrar para Eve quando atingir GA se o lock-in na Vercel for aceitável.

O AI SDK 7 com HarnessAgent é outra opção se seu caso é mais “usar Claude Code/Codex como backend” do que “construir um framework de agentes custom.”

Se você é um indie dev / startup early-stage

Escolha: Mastra.

Três motivos: maturidade (GA, não vai quebrar sua API na semana que vem), ecossistema (1000+ modelos, MCP, integrações, Studio, cursos), e flexibilidade de deploy (roda em qualquer lugar sem vendor billing obrigatório).

Mastra é o único dos três que oferece um caminho completo do protótipo à produção em escala sem que você precise mudar de framework no meio do caminho. Replit roda milhares de agentes Mastra por dia. Se funciona pra eles, funciona pro seu SaaS.

Se portabilidade extrema e harness programável são mais importantes que maturidade de ecossistema — e se você está ok com beta APIs — Flue é a alternativa mais interessante para quem quer controle total sem vendor dependency.

A Perspectiva de Longo Prazo

Os três frameworks convergiram no mesmo insight correto: o agente como diretório de arquivos, skills em Markdown, tools tipadas, execução durável. Daqui a 12 meses, a feature parity vai ser ainda maior. O que não vai convergir é o posicionamento de plataforma:

• Flue será o framework de referência para Cloudflare e multi-cloud
• Eve será o framework de referência para Vercel (como Next.js é para web)
• Mastra será o framework de referência para TypeScript puro sem amarras de infra

A decisão que você toma hoje é sobre gravidade de plataforma, não sobre features. Features convergem. Ecossistemas divergem. Escolha pela infraestrutura que você já tem, pelo nível de lock-in que aceita, e pela maturidade que precisa — nessa ordem.

Recursos Relacionados

• Agent Frameworks vs Coding Agents: Onde Fica a Fronteira
• Harness e Loop: A Arquitetura por Trás dos Agentes
• Pi: O Harness Open-Source que Roda Flue e OpenClaw