The Agent Framework Moment: Why Flue and Eve Look so Much Alike

TL;DR

Two new agent framework releases landed six weeks apart, and they look almost like the same project. Flue, from the team behind Astro, and Eve, the Vercel agent framework, both define an agent declaratively with Markdown instructions, TypeScript tools, durable execution, sandboxes, and channels. They are two of the cleanest ways to build AI agents available today. The convergence is the signal: agents are getting their framework moment, the way the web got Next.js.

Neither framework can see the live web on its own. The last two sections show how to add that with Firecrawl as a single tool in each.

On May 1, 2026, Astro co-creator Fred Schott introduced Flue and asked a pointed question: "Are agents ready for their library to framework moment?"

On June 17, Vercel answered without meaning to. It launched Eve with the line "Like Next.js, for agents," the exact framing Schott had used weeks earlier.

This is also a fight between the two companies defining the modern web platform. Flue comes from the team behind Astro, which Cloudflare acquired in January 2026, and it ships hardened on Cloudflare's Agents SDK. Eve comes from Vercel, the maker of Next.js. Different harnesses, different clouds, built independently, yet they arrived at nearly the same design.

Developers noticed immediately. One replied under Vercel's launch within half an hour: "Wait a second, the API is very similar."

That is not a coincidence or a copy. It is what happens when an idea is ready. When enough teams build the same thing the hard way, the shared shape becomes a framework. This piece walks through both releases, why they converged, and the one capability both leave for you to add.

An agent framework is the top layer of a three-layer stack. Cloudflare laid this out cleanly when it opened its Agents SDK to Flue as the first framework to build on it.

The harness was the hard part, and it matured first. For the conceptual backbone, Firecrawl's explainer on why AI agents prefer the CLI and its breakdown of MCP versus CLI both trace how harness design settled in 2025 and 2026. Once that loop was solid, the framework layer became the obvious next step, and two teams reached it at once.

Flue is an open-source TypeScript framework for durable agents and workflows, built by the team behind Astro and led by Fred Schott. That team joined Cloudflare in January 2026, which is why Flue lands as Cloudflare's entry in this race. Schott describes it as "like Claude Code, but 100% headless and programmable. No TUI. No GUI. Just TypeScript." It started as the engine for AI workflows inside the Astro repo, then grew into its own project.

flueframework.com, where a triage agent is composed from a model, skills, tools, and a sandbox.

@FredKSchott on X, May 1, 2026. The launch post drew 3,814 likes.

Flue runs on Pi, the same harness that powers OpenClaw, and it borrows a lesson from databases: the source of truth is the log. Every prompt, model response, and tool result is appended to a Durable Stream. When a process dies, another picks up the log and resumes from the exact step it left off.

The defining choice is declarative. As Cloudflare puts it, "you don't script what your agent does, you describe what it knows." You compose an agent from context: a model, tools, skills, a sandbox, and instructions. There is no orchestration loop to write.

// src/agents/triage.ts
import { createAgent } from '@flue/runtime';
import { local } from '@flue/runtime/node';
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import { replyToIssue } from '../tools/github.ts';
 
export const route = (c, next) => next();
 
export default createAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  tools: [replyToIssue],
  skills: [triage],
  sandbox: local(),
  instructions: 'Triage a bug report end to end: reproduce, diagnose, verify, and attempt a fix.',
}));

Flue is deliberately multi-cloud, and Cloudflare's ownership has not changed that. The same agent deploys to Node as a long-lived process, to Cloudflare where each agent becomes a Durable Object, or to GitHub Actions and GitLab CI. Its flue add command generates a Markdown blueprint your coding agent reads and wires in, which Schott's team calls "shadcn, for your agents." A companion @flue/react package streams agent state straight into a frontend.

Eve is Vercel's open-source agent framework, and its central idea is that an agent is a directory. You define instructions and skills in Markdown, tools in TypeScript, and Eve compiles the folder into a running agent. Vercel says it is "the framework that we build and run our own agents on."

vercel.com/eve, pitched as "like Next.js for web apps, but for agents," with an agent shown as a directory of files.

@vercel on X, June 17, 2026. The launch post drew over 7,000 likes.

The directory is the whole mental model. Each file maps to one part of the agent, so the tree tells you what the agent is and does at a glance.

agent/
  agent.ts            # the model it runs on
  instructions.md     # who it is
  tools/              # what it can do
  skills/             # what it knows
  subagents/          # who it delegates to
  channels/           # where it lives
  schedules/          # when it acts on its own

A tool is a single TypeScript file. The filename becomes the tool name, and Eve hands the model its description with no registration step. Vercel draws the analogy directly: "Just as Next.js turns a folder into a route by owning the routing, eve turns a file into an ability by owning the agent loop."

// agent/agent.ts
import { defineAgent } from 'eve';
 
export default defineAgent({ model: 'anthropic/claude-opus-4.8' });

Underneath, Eve leans on Vercel's stack. Durable execution comes from the open-source Workflow SDK, sandboxes from Vercel Sandbox, model calls from AI Gateway, and auth from Vercel Connect. Human-in-the-loop approvals, subagents, tracing, and evals all ship in the box.

This is not a demo. Vercel says agents triggered less than 3% of its deployments a year ago and around 29% now, and it runs more than a hundred agents in production. Its internal data analyst, d0, fields more than 30,000 questions a month, and its support agent, Vertex, resolves 92% of tickets on its own.

Strip away the branding and the two frameworks line up point for point. Agents have a shape now, and both teams found it.

1. Declarative definition over a hand-written control loop.
2. Markdown for instructions and skills, the agent's knowledge as plain text.
3. Typed TypeScript tool files, each defined with a function literally named defineTool.
4. Durable execution as table stakes, not an add-on.
5. A sandbox per agent for untrusted, model-generated code.
6. Subagents for delegating specialized work.
7. Channels that drop the agent into Slack, Discord, or GitHub as one file.
8. MCP support for external tools.
9. The "Next.js for agents" framing, used independently by both.
10. Coding agents as the install path, scaffolding and extending the project for you.

The differences are real but narrow. They sit at the seams, not the structure.

This is the same path the web walked. Everyone hand-rolled routing, bundling, and data fetching until Next.js absorbed the pattern. Agents were stuck rebuilding the same plumbing for every project, a problem Firecrawl's writeup on multi-agent orchestration describes from the orchestration side. Flue and Eve now sit alongside the wider field Firecrawl surveys in its roundup of open-source agent frameworks, and they are the abstraction arriving on schedule.

An agent turn is not one request. It streams tokens, calls tools, waits on people, and can run for minutes or hours, so a crash mid-turn cannot lose the work. Both frameworks treat durable state as table stakes, and both let you back it with a real database, but they build it on different foundations.

Vercel frames this as the agent's infrastructure layer. Eve ships durable execution, agent sandboxes, and human-in-the-loop on top of Vercel's Agent Stack, where the Workflow SDK checkpoints every step and resumes from the last good one. Flue answers with Durable Streams, an append-only log that any process can replay, plus first-party adapters for Postgres, Supabase, Redis, and more.

@vercel_dev on X, June 17, 2026. A top reply asked the question every team eventually hits: does it support native agent state for persistent reasoning across runs?

The reception split along a useful line: the frameworks are praised for treating an agent as structured software, not a chat wrapper. Under the Flue launch, one developer summed up the frustration these frameworks target: "Most agent tools are still basically chat wrappers, which makes them hard to integrate into actual systems. You need structured data out of the agent instead of just a text stream to build reliable loops."

@YashSerai on X, May 1, 2026, replying to the Flue launch.

Another reply distilled the whole stack into four words: "Agent = model + harness." That equation is exactly why the framework layer matters. The model is increasingly a commodity you swap with one line, and the harness is now a shared substrate. What is left to build is the framework around it, which is the part that decides whether your agent survives production. Firecrawl's comparison of Claude Code and OpenCode makes the same point about harnesses converging while the experience around them differentiates.

@Vtrivedy10 on X, May 1, 2026, on the Flue launch.

Here is the catch that neither launch post leads with. An AI agent built on Flue or Eve can run code, call your APIs, and survive a crash, but it cannot see the live web. There is no built-in search primitive in either framework. Out of the box, the model answers from training data that is months stale.

For a research assistant, a support agent, or anything that touches current events, prices, or documentation, that is a hard limit. You can hand the agent a raw fetch tool, but raw HTML is noisy, JavaScript-heavy pages return nothing useful, and many sites block plain requests. The fix is a tool that returns clean, current, model-ready results.

That is exactly what Firecrawl does. It searches the live web and returns clean Markdown, handling the JavaScript rendering and anti-bot friction that break a naive scraper. Firecrawl web search drops into TypeScript agents as a single tool, so both frameworks reach the live web in about fifteen lines. Firecrawl's breakdown of training data versus retrieved versus live web data explains why that freshness matters for an agent's answers. Because both frameworks define a tool the same way, the integration is nearly identical in each.

Start by installing the SDK and setting your key. Grab a free API key from the Firecrawl dashboard.

npm install firecrawl
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY

A Flue tool has four parts: a name, a description, a parameters schema built with valibot, and an execute function that returns text for the model. The tool calls app.search() and formats the results.

// src/tools/web-search.ts
import { defineTool } from '@flue/runtime';
import * as v from 'valibot';
import { Firecrawl } from 'firecrawl';
 
const app = new Firecrawl(); // reads FIRECRAWL_API_KEY from the environment
 
export const webSearch = defineTool({
  name: 'web_search',
  description: 'Search the live web and return current results with titles and URLs.',
  parameters: v.object({
    query: v.pipe(v.string(), v.description('The search query')),
    limit: v.optional(v.number(), 5),
  }),
  execute: async ({ query, limit }) => {
    const results = await app.search(query, { limit });
    return results.web.map((r) => `${r.title}\n${r.url}`).join('\n\n');
  },
});

Then pass the tool into the agent. The model decides when to call web_search, and the result becomes part of the session context.

// src/agents/researcher.ts
import { createAgent } from '@flue/runtime';
import { local } from '@flue/runtime/node';
import { webSearch } from '../tools/web-search.ts';
 
export const route = (c, next) => next();
 
export default createAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  instructions: 'You are a research assistant. Use web_search to find current sources before you answer.',
  tools: [webSearch],
  sandbox: local(),
}));

That is the whole integration. The agent now pulls clean, live context before it reasons, and it still keeps Flue's durability and multi-cloud deploy targets.

In Eve, a tool is a file you drop into agent/tools/, and the filename becomes the tool name. The schema uses Zod instead of valibot, but the structure mirrors the Flue version almost line for line.

npm install firecrawl
export FIRECRAWL_API_KEY=fc-YOUR-API-KEY

// agent/tools/web_search.ts
import { defineTool } from 'eve/tools';
import { z } from 'zod';
import { Firecrawl } from 'firecrawl';
 
const app = new Firecrawl(); // reads FIRECRAWL_API_KEY from the environment
 
export default defineTool({
  description: 'Search the live web and return current results with titles and URLs.',
  inputSchema: z.object({
    query: z.string().describe('The search query'),
    limit: z.number().default(5),
  }),
  async execute({ query, limit }) {
    const results = await app.search(query, { limit });
    return results.web.map(({ title, url }) => ({ title, url }));
  },
});

There is no registration step. Eve discovers the file at build time, hands the model the description, and the agent can search the web on its next run. Point the same agent at eve dev and you will see the web_search tool call appear in the terminal UI as it happens.

If you would rather skip the tool file, both frameworks also speak MCP, so you can connect Firecrawl's MCP server instead. For most agents, though, the native tool above is the shortest path, and it gives you full control over what the model sees.

The arrival of Flue and Eve marks a shift in where the work lives. The model is a one-line choice. The harness is a shared, battle-tested substrate. The framework around them is now mature enough that you stop writing plumbing and start describing behavior.

It also tells you who is fighting for this layer. With the Astro team inside Cloudflare and Eve coming straight from Vercel, the agent framework is now contested by the two companies that already shaped how the web gets built and deployed. That is the same rivalry that gave the frontend its frameworks, pointed at agents.

It also clarifies what to evaluate. Picking between Flue and Eve is mostly a developer-experience and deploy-target decision, not a model decision, the same way Firecrawl's roundup of the best AI coding agents frames coding tools around harness depth rather than raw model scores. And both frameworks leave the same gap: live web data is the primitive they expect you to bring.

Flue and Eve are early, and the differences between them will grow as each matures. What matters is that two strong teams independently agreed on the shape of an agent, which is the clearest sign yet that agents have reached their framework era. When you build on either one, plan for the live web from the start, because a framework can make your agent durable, but only a web data layer can make it current.