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

TL;DR

Two agent frameworks launched six weeks apart in 2026, 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. That convergence suggests agents are getting their framework moment, the way the web got Next.js.

Flue can't see the live web on its own. Eve ships a provider-managed web_search tool and now a native Firecrawl connection you add with eve add connection/firecrawl. The last two sections show how to add Firecrawl web search to 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. The two teams used different harnesses and different clouds and worked independently, yet they arrived at nearly the same design.

Within half an hour, one developer replied under Vercel's launch: "Wait a second, the API is very similar."

Neither team copied the other. When enough teams build the same thing the hard way, the shared shape becomes a framework.

An agent framework is the top layer of a three-layer stack. Cloudflare laid this out 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. 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, where the log is the source of truth. 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.

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.

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.

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 in the core of the framework.
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 narrow, and most are implementation choices:

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 the Best AI Agent Frameworks of 2026 comparison.

An agent turn 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 a requirement, 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?

Builders praised both frameworks for treating an agent as structured software. 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 why the framework layer matters. The model is increasingly a commodity you swap with one line, and the harness is now a shared substrate, which leaves the framework as 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.

An AI agent built on Flue or Eve can run code, call your APIs, and survive a crash, but neither framework gives it clean page content from the live web out of the box. Flue ships no search primitive, so until you add a tool its model answers from training data that is months stale. Eve ships a provider-managed web_search tool, which leaves the search and its results to the model provider and appears only for supported providers. Eve now adds Firecrawl with one command, eve add connection/firecrawl, while in Flue you still bring your own tool or MCP server.

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.

Firecrawl web search returns clean Markdown from the live web and handles the JavaScript rendering and complex web infrastructure that break a naive scraper. It 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(),
}));

With that file in place, the agent pulls clean, live context before it reasons and keeps Flue's durability and multi-cloud deploy targets.

In Eve, the shortest path is the Firecrawl connection in Eve's registry. One command writes the connection definition under agent/connections/:

eve add connection/firecrawl

Then set FIRECRAWL_API_KEY as a server-side environment variable. Eve sends the key directly to Firecrawl and never exposes it to the model, and the default connection asks for approval before each Firecrawl call. Beyond search, it covers scrape, map, crawl, parse, and monitor, plus 400+ data providers through Firecrawl Alexandria, subject to your plan and team policy (some providers ask your team to accept their data terms first). The Firecrawl integration page on eve.dev has the full setup.

If you want full control over what the model sees, write the tool yourself. 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, and because the file is named web_search.ts, it replaces Eve's provider-managed web_search. 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. For a full walkthrough that takes this same Firecrawl tool and ships it as an eve Slack agent your team can @mention, follow our hands-on tutorial.

Flue also speaks MCP, so you can connect Firecrawl's MCP server there instead of writing the tool file. In Eve, the registry connection above is the shortest path, and the hand-written tool is the option when you want full control over what the model sees.

Flue and Eve move the work up a layer. The model is a one-line choice and the harness is a shared, battle-tested substrate, so the framework is where you stop writing plumbing and start describing behavior.

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.

Picking between Flue and Eve is mostly a developer-experience and deploy-target decision rather than 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. Neither framework launched with clean, model-ready web content built in. Eve now covers it with a one-command Firecrawl integration alongside its provider-managed web_search, and Flue still expects you to bring it as a tool.

Flue and Eve are early, and the differences between them will grow as each matures. Two strong teams independently agreed on the shape of an agent, which is a strong sign that agents have reached their framework era. When you build on either one, plan for the live web from the start. In Eve that is eve add connection/firecrawl, and in Flue it is the fifteen-line tool above.