# Flue vs Eve vs Mastra: Frameworks TypeScript de Agentes em 2026 > Comparativo técnico entre Flue, Eve e Mastra — os três frameworks TypeScript que redefiniram agentes IA em junho de 2026. Veredicto por perfil. Source: https://agentify.ia.br/blog/flue-vs-eve-vs-mastra/ ## 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](/blog/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](/blog/agent-frameworks-vs-coding-agents) 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. Critério Flue (Astro team) Eve (Vercel) Mastra Versão atual 1.0.0-beta.1 (jun 2026) 0.11.4, public preview (jun 2026) 1.x GA (jan 2026+) Licença Apache-2.0 Apache-2.0 Apache-2.0 Harness base Pi ( @earendil-works/pi-* ) Vercel AI SDK + Workflow SDK Próprio (model router unificado) Deploy targets Node, Cloudflare Workers, GitHub Actions, GitLab CI, Docker, Render Vercel (adapters possíveis) Node, Bun, Deno, Cloudflare, Vercel, qualquer runtime Execução durável Durable Streams (append-only log) Workflow SDK open-source Workflows com checkpoint + time-travel Sandbox Virtual built-in + container remoto + @cloudflare/codemode Vercel Sandbox (managed) + Docker/microsandbox local Workspaces (filesystem + code execution) Skills/Instruções SKILL.md importado com with { type: 'skill' } Markdown em skills/ directory Tools via MCP + skill files Modelos suportados Qualquer LLM (model-agnostic) Qualquer via AI SDK (string config) 1000+ via model router unificado Observabilidade OpenTelemetry, Braintrust, Sentry, custom Built-in tracing + evals Tracing nativo, evals, scorers, métricas Frontend SDK @flue/react (beta, não documentado) eve/react , eve/vue , eve/svelte React, Next.js, Astro, SvelteKit, Hono GitHub Stars ~8K (repo público desde fev 2026) Novo (jun 2026) 25.8K+ npm downloads/semana Crescendo (pós-beta) Novo 300K+ 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() }), async execute({ city }) { return { city, condition: "Sunny", temperatureF: }; }, }); ``` **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](/blog/harness-e-loop-arquitetura-agentes) 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 -->