Fred Schott shipped Flue 2.0 on July 31, marking the framework's first stable release and a complete architectural pivot. The foundation is Agent Hooks, a TypeScript API that mirrors React's composability model and replaces the static agent definitions from Flue 1.0 Beta. The beta logged 700,000+ downloads in roughly one month, enough signal to rebuild around composition instead of file routing.

An agent in Flue 2 is a JavaScript function that re-renders on every turn before each model call. Hooks attach to that cycle. The 16 built-in hooks cover tool binding (useTool(), useSkill()), subagent delegation (useSubagent()), persistent cross-turn state (usePersistentState()), sandbox access (useSandbox()), and MCP connections (useMcpConnection()). Custom hooks compile to npm packages. The `flue add` command generates a Markdown blueprint your coding agent reads directly—"shadcn for your agents," in Schott's phrasing.

HookCategoryPurpose
useTool()Tool bindingAttach a tool to the agent for the current turn
useSkill()Tool bindingBind a reusable skill (composable capability unit)
useSubagent()DelegationDelegate work to a child sub-agent
usePersistentState()StateMaintain state that survives across conversation turns
useSandbox()ExecutionGrant the agent access to a sandboxed execution environment
useMcpConnection()MCPMount a full MCP server's tool set without adapter code
FIG. 02 Flue 2.0 built-in hooks — named hooks and their roles — flueframework.com/blog/flue-2/

Static configurations cannot do what hooks unlock: agents that change their own capability set at runtime. A support bot can delay attaching account management tools until a user is verified. An agent hitting a hard problem can swap in a heavier model mid-conversation. In Flue 1.0 and competing harnesses, dynamically upgrading a model or sandbox mid-session requires significant plumbing. Flue 2 needs a few lines of TypeScript.

Flue 2.0 per-turn agent lifecycle: hooks re-evaluate before every model call, enabling runtime capability changes
FIG. 03 Flue 2.0 per-turn agent lifecycle: hooks re-evaluate before every model call, enabling runtime capability changes — flueframework.com/blog/flue-2/

The underlying runtime is Pi, an open-source minimal harness. Schott positions it like Astro positions Vite—stable, low-abstraction foundation with an opinionated framework on top. Hosted agents compile with Vite directly. The new CLI adds `flue run` for local execution and CI environments. Built-in Stateless MCP mounts an MCP server's full tool set into any agent without adapter code. Deployment targets include Node.js, Cloudflare Workers (as Durable Objects), GitHub Actions, GitLab CI, and Daytona.

Flue 2.0 runtime stack and supported deployment targets
FIG. 04 Flue 2.0 runtime stack and supported deployment targets — flueframework.com/blog/flue-2/

Flue has no managed cloud offering, no scheduling UI, no hosted observability, and no one-click deploys. Schott's stated position is "the framework is the product." For evals and replay, the docs point to Braintrust or a custom observer—a deliberate gap that Mastra and LangGraph fill natively. The skills import attribute (`with { type: 'skill' }`) requires Node 22+ and modern bundlers; monorepos on older TypeScript configs will hit tooling rough edges.

The direct competitor is Vercel's Eve, which launched June 17 with positioning "like Next.js, for agents." Both are open source. Both treat the harness as foundational. Eve is directory-based: Markdown instructions and TypeScript tools in the filesystem. Flue is function-based: a JS function plus hooks. The practical choice depends whether your team prefers filesystem conventions or programmatic composition at scale. Schott credits Eve as a genuine peer—two teams converging on the same design because the idea was ready.

DimensionFlue 2.0Eve (Vercel)
Stable releaseJuly 31June 17
Open sourceYesYes
Agent definition styleJavaScript function + hooksDirectory-based (Markdown + TypeScript files)
Positioning"The framework is the product""Like Next.js, for agents"
Runtime foundationPi (minimal open-source harness)Filesystem conventions
Tool attachmentRuntime via hook calls (programmatic)Static TypeScript tool files in directory
Managed cloud / hostingNoneVercel platform
Evals / observabilityDelegated (Braintrust or custom)Native
Composition modelCustom hooks → npm packagesMarkdown blueprints in filesystem
FIG. 05 Flue 2.0 vs Vercel Eve — framework design comparison — firecrawl.dev/blog/flue-vs-eve-agent-frameworks

Flue 2's hooks pattern fits agents that need to change shape mid-conversation. Static workflows with fixed tool sets do not need it. Support bots, triage agents, and anything that earns capabilities conditionally do—and the 16 built-in hooks plus custom hook composition handle that without a bespoke state machine.