# Flue, Fred Schott, and the agent-harness moment in TypeScript

URL: https://www.thedeepfeed.ai/posts/2026-05-02-flue-agent-harness-framework/
Category: Tools
Published: 2026-05-02
Updated: 2026-06-21
Author: the-deep-feed
Tags: flue, agents, harness, typescript, astro
Kind: deep

> Fred Schott shipped Flue — a TypeScript framework that treats the agent harness as a first-class build target. Updated for the 1.0 Beta rewrite, beta.2, the Cloudflare runtime deal, the Vercel-backed eve rival, and a fellow framework author's critique of what Flue makes first-class.

## TL;DR

- Flue shipped **1.0 Beta on June 16** — a **335-commit, 300-file rewrite** that reorganized the framework around three primitives: **Agents, Workflows, and Channels**. The old `init → session → prompt` shape from the May launch is gone; the new core is `@flue/runtime` and a `defineAgent()` config factory. **`beta.2` has already followed** (Astro 7, native arg parsing), and the repo is at **~6,140 stars, 346 forks, 19 contributors**.
- The bet is unchanged: **the agent harness is the framework**, not an SDK. Logic lives in markdown skills imported as modules (`import triage from "../skills/triage/SKILL.md" with { type: "skill" }`); orchestration lives in TypeScript.
- The week's real story is the **Cloudflare deal (June 17)**: Cloudflare positioned its Agents SDK as the *runtime layer* under harnesses, starting with Flue. That makes the harness/runtime split a three-company stack — framework (Flue) over control loop (Pi) over runtime (Cloudflare).
- **Flue is no longer alone.** Vercel open-sourced **eve** on June 17 — the same directory-of-files idea with Vercel's deploy gravity behind it. Flue's answer is portability: *write once, deploy anywhere, any LLM.* shadcn's agentcn now builds on both.
- **The foundations are still being argued.** Alchemy author Sam Goodwin pushed back on June 19: the sandbox Flue makes first-class *"isn't first-class — it's simply a Layer."* The real primitive, he argues, is the agent-as-typed-interface, with the runtime swappable underneath. It's the component-vs-route debate, replayed for agents.

![Flue's harness layered between model and runtime, shown as a four-tier stack with sandbox and filesystem at the base](/post-images/2026-05-02-flue-agent-harness-framework/hero-harness-stack.jpg)

The most interesting AI-infrastructure launch of early May did not come from a foundation lab. It came from the co-founder of a web framework. On May 1, Fred K. Schott (Astro co-founder) posted a sixteen-line pitch for a new TypeScript project called **Flue**: a framework that treats the *agent harness* as a first-class build target. Six weeks later, on June 16, Flue shipped its [1.0 Beta](https://flueframework.com/blog/flue-1-0-beta/) — and the version of Flue you can install today is a different, larger, more opinionated thing than the one that went viral in May.

This piece has been updated for that 1.0 rewrite. The thesis survived intact; almost all the code did not. So the right way to read Flue now is in two layers: the durable bet (the harness is the framework), and the June reality (a 335-commit reorganization, a Cloudflare runtime deal, and a Vercel-backed rival that did not exist when Flue launched).

# What 1.0 actually changed

The 1.0 Beta is not a version bump. The [`v0.11.1...v1.0.0-beta.1` compare](https://github.com/withastro/flue/compare/v0.11.1...v1.0.0-beta.1) is **335 commits across 300 files** — a ground-up reorganization of the public surface. Three things moved:

| Area | May launch (0.3.x) | 1.0 Beta (June) |
|---|---|---|
| Core package | `@flue/sdk/client` | `@flue/runtime` (harness, sessions, tools, sandbox) |
| Agent shape | `export default async ({ init, payload }) => {...}` | `export default defineAgent(() => ({ model, tools, skills, sandbox, instructions }))` |
| Top-level primitives | one (the agent function) | three — **Agents**, **Workflows**, **Channels** |
| Skills | discovered from disk at runtime | imported as typed modules with `import s from "./SKILL.md" with { type: "skill" }` |
| Workflow input | `payload` everywhere | `input` everywhere (SDK, CLI `--input`, RunRecord) |

The announcement frames it as a consolidation: Flue's *"core primitives (agents, workflows, sandboxes, channels) have come together into a cohesive story."* In practice it means the May post's fifteen-line example no longer compiles, and the mental model shifted from "an agent is a function you export" to "an agent is a configuration you declare." That is a meaningful upgrade, because the declarative form is what lets the same agent definition run across Node, Cloudflare, and CI without edits. But it is also a hard break six weeks after launch, which is exactly the kind of thing a `1.0-beta` label is supposed to warn you about.

# Flue in 2026, current API

The smallest current Flue agent declares a config object and returns it from `defineAgent`. From the repository README, here is the canonical bug-triage agent:

```typescript
// agents/triage.ts

import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
import verify from '../skills/verify/SKILL.md' with { type: 'skill' };

const instructions = `
Triage a bug report end-to-end: reproduce the bug,
diagnose the root cause, verify whether the behavior is
intentional, and attempt a fix.
`;

// Expose (and protect) your agents over HTTP:
export const route: AgentRouteHandler = async (_c, next) => next();

export default defineAgent(() => ({
  model: 'anthropic/claude-sonnet-4-6',
  tools: [...githubTools],
  skills: [triage, verify],
  sandbox: local(),
  instructions,
}));
```

Read what the declaration carries. `model` is a string, not a configured client, so Flue resolves the provider. `tools` is a spread of typed functions. `skills` are markdown files imported as modules, so the build can typecheck that the skill exists instead of failing at runtime when a path is wrong. `sandbox: local()` wires the host filesystem; swapping it for a Cloudflare or Daytona backend is a one-line change. `route` is the HTTP guard — the seam where you add auth before the agent is reachable. Everything that was implicit in the May API (the session, the tool registration, the default sandbox) is now explicit and composable.

![Four-layer architecture diagram with model at the bottom and filesystem at the top, the harness as the load-bearing middle](/post-images/2026-05-02-flue-agent-harness-framework/four-layer-stack.jpg)

# The harness, named

The bet that survived the rewrite is the one Flue was built to make. The word "harness" came into the lexicon in [Vivek Trivedy's LangChain post from late 2025](https://www.langchain.com/blog/the-anatomy-of-an-agent-harness), the one Fred links from the Flue homepage. Trivedy's definition is simple: *"Agent = Model + Harness. If you're not the model, you're the harness."* Everything that isn't the LLM (the loop, the tool execution, the filesystem, the sandbox, the orchestration) is the harness. Until Flue, every TypeScript framework in the space (Mastra, Vercel AI SDK, LangGraph.js, Genkit) treated those layers as **plumbing**: necessary, but assembled by the user. Flue's bet is that the harness should be **the framework**.

The architectural commitment runs deeper than the slogan. The package tells you what they actually depend on: [`@mariozechner/pi-agent-core`](https://www.npmjs.com/package/@mariozechner/pi-agent-core) for the agent loop (Mario Zechner's library), [`just-bash`](https://github.com/vercel-labs/just-bash) for the in-memory virtual sandbox, [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk) for MCP tool adapters, and a runtime layer that now spans Node, Cloudflare Workers, GitHub Actions, GitLab CI, Daytona, and Render. The novel contribution is the **assembly** — one orchestration shape that survives every deploy target.

[@prince_twets](https://x.com/prince_twets/status/2067620026002129285) caught the through-line in mid-June, after the rewrite landed:

> withastro/flue caught my eye today. It is a TypeScript agent framework with built in sandboxes, durable execution, and subagents. I like that it treats the harness as the product, not just the model wrapper.
>
> — [@prince_twets](https://x.com/prince_twets/status/2067620026002129285), June 18, 2026

"The harness as the product, not just the model wrapper" is the whole thesis in nine words.

# Agents, workflows, channels

1.0's three primitives map to three different shapes of work, and the distinction is the clearest articulation Flue has produced of what it is *for*.

**Agents** are autonomous. You give them instructions and tools and trust them to decide the path. **Workflows** are structured — your code guides the agent's reasoning from a defined input to a finished result, calling the model where you want judgment and keeping control where you want determinism. **Channels** are the inbound edge: verified events from Slack, Teams, Discord, GitHub, and more, dispatched to an agent.

A workflow makes the agent-as-subroutine pattern concrete. From the repository's Braintrust example:

```typescript

export const route: WorkflowRouteHandler = async (_c, next) => next();

const agent = defineAgent(() => ({ model: 'anthropic/claude-haiku-4-5' }));

const lookup = defineTool({
  name: 'lookup_weather',
  description: 'Look up current weather for a city.',
  parameters: v.object({ city: v.string() }),
  execute: async ({ city }) => `${city}: sunny, 72 F`,
});

export default defineWorkflow({
  agent,
  input: v.object({ city: v.optional(v.string()) }),
  async run({ harness, input }) {
    const session = await harness.session();
    const city = input.city ?? 'San Francisco';
    const response = await session.prompt(
      `Use the weather tool to report current weather in ${city}.`,
      { tools: [lookup] },
    );
    return { message: response.text };
  },
});
```

The `run` function is plain TypeScript. It owns control flow; the model owns the reasoning inside each `session.prompt()`. Most production agent failures happen at exactly this seam, where an LLM is asked to make a routing decision it has no business making, and Flue's workflow primitive moves that seam back to the host language. A tool is a Valibot schema plus an `execute` function; the model can only call what you hand it in `tools`.

Subagents are first-class too. Declare a profile, attach it, and delegate with `session.task()`:

```typescript
const editor = defineAgentProfile({
  name: 'editor',
  instructions: 'Rewrite the supplied sentence in a clearer, shorter form.',
});
const agent = defineAgent(() => ({ model: 'anthropic/claude-haiku-4-5', subagents: [editor] }));
// inside run():
const response = await session.task(`Rewrite this sentence: ${draft}`, { agent: 'editor' });
```

# Markdown logic, TypeScript orchestration

The line in the original launch that landed hardest is the one about logic location: *"Most of the 'logic' lives in Markdown: skills and context and instructions."* The 1.0 rewrite hardened this rather than softening it. Skills are no longer discovered loosely from a directory; they are imported as typed modules:

```typescript
import triage from '../skills/triage/SKILL.md' with { type: 'skill' };
```

A Flue project's structure looks like this:

```
my-agent/
├── agents/
│   └── triage.ts          # 20 lines of orchestration
├── skills/
│   └── triage/
│       └── SKILL.md       # the actual instruction set
├── tools/
│   └── github.ts          # typed tools
└── flue.config.ts
```

![A folder tree with agents/ TypeScript files small and skills/ markdown files large — the logic lives in the markdown](/post-images/2026-05-02-flue-agent-harness-framework/markdown-logic-split.jpg)

The `.ts` file is twenty-to-fifty lines: which model, which tools, which sandbox, what the agent returns. The instruction sets (the part that says what the agent should actually *do*) live in markdown. This is the same shape as Claude Code skills, Cursor rules, and Anthropic's [published skill protocol](https://www.anthropic.com/news/skills). Flue is not inventing a convention. It is taking the one that emerged from the Claude Code ecosystem and saying: this is also how you build *non-interactive* agents that ship to production. The `with { type: 'skill' }` import assertion is the upgrade — it means a missing or malformed skill is a build error, not a 2 a.m. production surprise.

# The Cloudflare deal is the real June story

The 1.0 announcement got the GitHub stars. The more consequential June event was [Cloudflare's June 17 post](https://blog.cloudflare.com/agents-platform-flue-sdk/) positioning its Agents SDK as the *runtime layer* underneath harnesses — and naming Flue as the first. Cloudflare's framing is blunt about why now:

> 2026 is the year agent harnesses go to production. The software that controls the model's access to the outside world — harnesses like Codex, Claude Code, OpenCode, Pi, and Project Think — has matured to the point where teams are deploying agents as real, load-bearing infrastructure.
>
> — Thomas Gauvin, [Cloudflare](https://blog.cloudflare.com/agents-platform-flue-sdk/), June 17, 2026

This separates the stack into three layers owned by three different parties: the **framework** (Flue, where you write the agent), the **control loop** (Pi, the agent core Flue is built on), and the **runtime** (Cloudflare Agents SDK + Durable Objects, where it actually executes and persists). [@stretchcloud](https://x.com/stretchcloud/status/2067346544509235711) read the move correctly:

> Every serious agent demo eventually hits the boring failure mode … the "AI" problem quietly becomes a distributed systems problem. That is why this Cloudflare move is more interesting than another framework launch. They are trying to make the Agents SDK the runtime layer under different harnesses.
>
> — [@stretchcloud](https://x.com/stretchcloud/status/2067346544509235711), June 17, 2026

That is the durability gap from Flue's launch week, the *"is stream reconnect on the roadmap?"* question, being answered not by Flue alone but by pushing the hard distributed-systems problem down to a runtime built for it. Durable Objects already solve session persistence across requests; leaning on them is the pragmatic answer to "what happens when the process dies mid-task."

![A three-layer stack diagram: framework on top, control loop in the middle, runtime at the base, with the runtime layer marked in editorial red](/post-images/2026-05-02-flue-agent-harness-framework/runtime-layer-stack.jpg)

# Same agent code, multiple backends

The thing reviewers kept noticing on launch night was the sandbox abstraction, and it survived the rewrite as `@flue/runtime` backends. From [@curonianai](https://x.com/curonianai/status/2050307603637416077): *"sandbox as primitive, not adapter. Mastra and AI SDK make you BYO the sandbox. Same agent code, multiple backends. Filesystem composition becomes native, which is the actual lever."*

| Sandbox | Implementation | Use case |
|---|---|---|
| `virtual` (default) | `just-bash` in-memory bash + filesystem | Stateless agents, high-traffic webhooks, no container overhead |
| `local()` | Host filesystem | CI runners with the repo already checked out |
| Daytona | `@daytona/sdk` Linux container | Full Linux env, persistent filesystem, real shell |
| Cloudflare Sandbox | `@cloudflare/sandbox` Durable Object container | Per-session container on Cloudflare with persistence |

The agent declaration does not change when the backend does. The default (`virtual`) is the lever Mastra and Vercel AI SDK do not give you: most agent work needs a filesystem, not a full container, and spinning up a container per webhook destroys agent unit economics. Flue makes the cheap path the default and the expensive path opt-in.

# Where Flue actually came from

Frameworks invented from first principles tend to look like it — answers to questions nobody is asking, gaps where the real work is. Flue does not have that smell, and the reason is in the git history.

On February 11, 2026, [Fred opened PR #15476](https://github.com/withastro/astro/pull/15476) on the Astro monorepo titled *"Experiment: Automatic triage for new GitHub issues."* It was in-house infrastructure: the Astro repo gets a steady stream of issues, the maintainers cannot triage them all, and a Claude-Code-style agent could do the first pass. The PR added 14 files, +831 lines. Two weeks later, [PR #15545](https://github.com/withastro/astro/pull/15545) was 19 files of *"security improvements, sandbox updates, skill refinements"* — exactly the unglamorous edges that only show up after the thing is running on real traffic.

By March those skills had been generalized far enough that they no longer looked like Astro-specific infrastructure. Mario Zechner (author of the underlying `pi-agent-core` library) got his hands on it, the response was *"holy shit it's built on pi?!"*, and Fred extracted the abstraction:

> ok, i already posted this but holy shit it's built on pi?! … this makes me super happy!
>
> — [@badlogicgames](https://x.com/badlogicgames/status/2050288716896247887), May 1, 2026

This origin rules out the most common failure mode in the category: a clean abstraction nobody used in production. Flue's harness ran on the Astro repo's issue triage for two months before it had a name. Every primitive was added because the maintainers needed it to ship one specific feature. That the 1.0 rewrite then reorganized those primitives is not a contradiction — it is what happens when a tool built for one repo gets generalized for everyone, and the original shape turns out to be too narrow.

# The rival that did not exist in May: Vercel's eve

The biggest change to Flue's world is not in Flue's repo. On June 17, at Vercel Ship London, [Vercel open-sourced **eve**](https://vercel.com/blog/introducing-eve) — its own agent framework, built on the same core idea that an agent is a directory of files. The framing is nearly identical to Flue's: markdown instructions, typed TypeScript tools, skills, sandboxes, durable workflows. Vercel pitches it as *"Next.js, for agents."*

The two frameworks now define the poles of the TypeScript agent-framework debate:

| | **Flue** | **eve** (Vercel) |
|---|---|---|
| Backer | Astro team (Fred Schott) | Vercel (Guillermo Rauch) |
| Core pitch | Write once, deploy **anywhere**, any LLM | Scaffold to running agent in under a minute |
| Deploy gravity | Node, Cloudflare, CI, Daytona, Render | Vercel Functions + Sandbox (portable, but Vercel-native) |
| Maturity (June 21) | 1.0 Beta (beta.2 shipped), ~6,140 stars, 4 months old | 0.11.x, ~1,900 stars, 5 days old |
| LLM routing | Provider-agnostic strings | AI Gateway (OIDC, no keys on Vercel) |

The honest contrast is **portability versus gravity**. Flue's whole value proposition is that your agent code does not care where it runs; eve's is that on Vercel, the deploy story disappears entirely (OIDC means no API keys, the sandbox and workflow engine are wired in). Reviewers have already flagged the tradeoff — eve's speed-to-first-agent comes with deploy-gravity that becomes a portability bill later, which is precisely the bill Flue is built to never charge.

They are not purely adversarial. shadcn's **agentcn**, launched June 20, builds on both:

> Introducing agentcn 🤖 by @shadcnlabs — Built on Eve by @vercel and @flueai — Zero config, one command setup. @shadcn/ui compatible … 10+ production-ready agent recipes.
>
> — [@alaymanguy](https://x.com/alaymanguy/status/2068382433599439282), June 20, 2026

When the most influential component-library author in the React ecosystem treats two competing frameworks as interchangeable backends, it tells you the *category* has won even before either framework has. The harness-as-framework idea is now the consensus shape; Flue and eve are arguing over who hosts it. (We cover eve's architecture in depth in [the companion piece on Vercel's framework](/posts/2026-06-21-vercel-eve-agent-framework-directory-of-files/).)

# The contrarian read: is the sandbox the right primitive?

![Two contrasting architecture diagrams: Flue making the sandbox first-class inside the harness, versus Alchemy making the agent-as-typed-interface the primitive with the sandbox as one swappable layer, the agent-interface box marked in red](/post-images/2026-05-02-flue-agent-harness-framework/which-primitive-debate.jpg)

Not everyone agrees the harness-as-framework framing is the unit that matters. The sharpest pushback came not from a foundation lab but from a fellow framework author. Sam Goodwin, who builds the infrastructure-as-code framework Alchemy, looked at Flue's design and argued that Flue picked the wrong thing to make first-class:

> Alchemy.Agent is a type-safe string template capturing Prompt and Tools together. It's the "interface". Cloudflare.Agent() implements it with a DO. The "Sandbox" feature of Flue is simply a Layer. It isn't first-class.
>
> — [@samgoodwin89](https://x.com/samgoodwin89/status/2067868213069918404), June 19, 2026

The critique is worth taking seriously because it inverts Flue's own marketing. Flue sells the sandbox as a framework-level primitive, the thing Mastra and the Vercel AI SDK leave to the user. Goodwin's claim is the opposite: the *agent interface*, prompt and tools captured as a type, is the real primitive, and the sandbox is just one runtime layer you compose underneath it, no more privileged than a database binding. Read that way, Flue and Alchemy disagree about which abstraction deserves to be the noun. Flue says the harness; Alchemy says the agent-as-typed-interface, with the runtime (a Cloudflare Durable Object, a sandbox, whatever) as a swappable implementation detail. This is not a small quibble. It is the same argument the frontend world had about whether the *component* or the *route* is the primitive, and it will shape which of these frameworks composes cleanly into larger systems. Flue's answer is defensible — for an agent that writes files, the sandbox genuinely is load-bearing — but the fact that a serious infra author looked at the design and reached for a different noun is the clearest sign the category's foundations are still being argued, not settled.

# Mapping Flue against the rest of the TypeScript agent stack

The category has gotten crowded fast. Six frameworks worth comparing on the dimensions Flue actually cares about:

| Framework | Sandbox primitive? | Markdown-first? | Deploy targets | Secrets boundary |
|---|---|---|---|---|
| **Flue** (`@flue/runtime`) | First-class (4 backends) | Yes (skills as typed modules) | Node, Cloudflare, GitHub Actions, GitLab CI, Daytona, Render | Per-call command grants |
| **eve** (Vercel) | First-class (Vercel Sandbox) | Yes (instructions + skills) | Vercel-native (portable) | Runtime OAuth (Connect) |
| **Mastra** | BYO container | Workflows-as-code | Node, Cloudflare, hosted | Tool-level config |
| **Vercel AI SDK** | None | No | Vercel, Edge | Tool-level config |
| **LangGraph.js** | BYO | No | Node, hosted | Per-tool |
| **`@mariozechner/pi-agent-core`** (Flue dependency) | BYO | TUI/CLI focused | Node | Per-tool |

Two columns matter most. The "sandbox primitive?" column is what `@curonianai` flagged: Flue ships sandbox backends as part of the framework contract, where Mastra and Vercel AI SDK leave it to the user — the right call for a chat product, the wrong call for an agent that writes files. The "markdown-first?" column is the cultural commitment to skill files as the unit of agent capability, the same skill working in Claude Code, in Cursor, and in production without translation. The arrival of eve in the first two rows is the headline: the dimensions Flue chose to compete on are now the dimensions the whole category is converging toward.

# What you can build with Flue right now

Ten things that are plausible weekend projects given 1.0's primitives, ranked by how cleanly the framework's pieces snap together.

| Buildability | Idea | Why it fits Flue |
|---|---|---|
| 🟢 High | **GitHub issue triage bot** | Flue's own origin story. A `triage` skill + the GitHub channel + `local()` sandbox is the entire setup. Replaces Dosu / Greptile / CodeRabbit at near-zero infrastructure cost. |
| 🟢 High | **PR review agent** | Same shape, different skill. Channel fires on `pull_request_review_comment`, agent runs `git diff`, posts review comments. |
| 🟢 High | **Customer support agent with persistent sessions** | Cloudflare backend, R2-backed knowledge base mounted as the agent's filesystem, Durable Object sessions for continuity across messages. |
| 🟢 High | **CI auto-fix workflow** | A `defineWorkflow` branching on a `triage` result severity into an `auto-fix` skill. Best at high-confidence dependency bumps and lint fixes. |
| 🟢 High | **Docs Q&A agent** | R2 bucket of markdown docs, virtual sandbox, `grep`/`glob`/`read` over the bucket as filesystem. No vector DB needed for small corpora. |
| 🟡 Medium | **Slack/Discord/Teams agent** | The channel primitive verifies inbound events; the agent itself is twenty lines. Signed-request verification is handled by the channel, not your code. |
| 🟡 Medium | **Code-review concierge for a private repo** | Daytona backend gives a real container with the repo cloned. Coordination across PRs is the hard part. |
| 🟡 Medium | **Data-analyst agent** with mounted CSVs | Virtual sandbox with Python enabled, mount a directory of datasets, ask questions. Charts via matplotlib written back to the filesystem. |
| 🟡 Medium | **Multi-agent research pipeline** | A parent agent delegating to declared subagents via `session.task()`, each a focused profile. |
| 🔴 Low | **Mid-stream-resumable hour-long agent** | The Cloudflare runtime deal addresses session persistence, but mid-`prompt()` stream resumption across a dropped connection is still the frontier. |

The pattern across the green tier is consistent: a channel or CI trigger, a virtual or local sandbox, a markdown skill, scoped secrets, a typed result. Twenty lines of TypeScript and a fifty-line markdown file. That is the shape of a Flue agent at its most useful, and 1.0's job was to make that shape feel obvious across more runtimes.

![Build-idea cards arranged as a grid of agent shapes, with the issue-triage card highlighted in editorial red as the canonical example](/post-images/2026-05-02-flue-agent-harness-framework/build-ideas-grid.jpg)

# What is honestly still missing

Three real gaps, named by name.

**It is a beta, and 1.0 broke things.** The `1.0.0-beta` label is doing real work. The June rewrite renamed core APIs (`createAgent` → `defineAgent`, `payload` → `input`) and bumped session persistence to a new on-disk format. Anyone who shipped on the May API had to migrate. The announcement is explicit that this is the cohesive-but-not-frozen moment, not GA — more breaking changes are possible before 1.0 final.

**Stream reconnect is still partial.** The Cloudflare deal pushes session durability down to Durable Objects, which covers state across requests. But resuming a single in-flight `prompt()` whose HTTP stream drops mid-generation remains a per-runtime concern rather than a framework primitive. For research and coding agents that run for minutes per call, this is the edge users will hit.

**TypeScript only.** The Python agent ecosystem (LangChain, LlamaIndex, CrewAI, AutoGen, smolagents) is enormous and not coming. Flue's bet is that the developer pool willing to write agents in TypeScript is the one growing fastest. With Vercel now backing eve in the same language, that bet looks better than it did in May — but it is still definitionally not the AI-research crowd.

# Where Flue lands

Agent harnesses are the unglamorous middle of the AI stack. The model gets the headline, the deploy target gets the press release, and the harness (the loop, the sandbox, the filesystem, the secrets boundary, the orchestration) is the thing every team rebuilds from scratch and nobody calls a framework.

Flue named the harness as a build target first. The May launch proved the idea resonated; the June 1.0 rewrite proved the team would tear up its own API to get the shape right; the Cloudflare deal proved a major infrastructure company believes the harness/runtime split is real enough to build a product around; and Vercel's eve proved the category is big enough to attract the most distribution-heavy player in frontend. Four months in, the question is no longer *"is the harness a real category?"* It is *"which framework hosts it, and on whose runtime?"*

For builders, the call has actually gotten easier since May. The framework is more capable, the runtime story is more credible, and the existence of a serious rival means the patterns are converging fast enough that learning one teaches you most of the other. The thing you give up by waiting is the same as it was at launch — the chance to be one of the first hundred teams who ship on it, learn its shape, and end up writing the patterns the next ten thousand will copy. The harness moment is no longer latent. Two frameworks and a CDN are now fighting over it in public. The right move is still to build something on it.

## Sources

- [Flue 1.0 Beta announcement](https://flueframework.com/blog/flue-1-0-beta/)
- [withastro/flue (GitHub)](https://github.com/withastro/flue)
- [flueframework.com](https://www.flueframework.com)
- [Flue 1.0 rewrite — v0.11.1...v1.0.0-beta.1 compare (335 commits)](https://github.com/withastro/flue/compare/v0.11.1...v1.0.0-beta.1)
- [Cloudflare — Agents platform + the Flue SDK](https://blog.cloudflare.com/agents-platform-flue-sdk/)
- [LangChain — The Anatomy of an Agent Harness](https://www.langchain.com/blog/the-anatomy-of-an-agent-harness)
- [@flue/sdk on npm](https://www.npmjs.com/package/@flue/sdk)
- [@flue/cli on npm](https://www.npmjs.com/package/@flue/cli)
- [Mario Zechner — pi-agent-core (npm)](https://www.npmjs.com/package/@mariozechner/pi-agent-core)
- [Astro PR #15476 — Auto-triage experiment (origin)](https://github.com/withastro/astro/pull/15476)
- [Astro PR #15545 — Triage security + sandbox refinements](https://github.com/withastro/astro/pull/15545)
- [Vercel — Introducing eve (the rival, June 17)](https://vercel.com/blog/introducing-eve)
- [just-bash (vercel-labs)](https://github.com/vercel-labs/just-bash)
- [Cloudflare Agents SDK](https://developers.cloudflare.com/agents/)
- [Mastra (TypeScript agent framework)](https://mastra.ai/)
- [Vercel AI SDK](https://ai-sdk.dev/)
- [@stretchcloud — Cloudflare makes the runtime the layer](https://x.com/stretchcloud/status/2067346544509235711)
- [@prince_twets — the harness is the product](https://x.com/prince_twets/status/2067620026002129285)
- [@badlogicgames — built on pi](https://x.com/badlogicgames/status/2050288716896247887)
- [@curonianai — sandbox as primitive](https://x.com/curonianai/status/2050307603637416077)
- [@alaymanguy — agentcn, built on Eve and Flue](https://x.com/alaymanguy/status/2068382433599439282)
- [@samgoodwin89 — the sandbox isn't first-class (Alchemy author critique)](https://x.com/samgoodwin89/status/2067868213069918404)
- [Flue beta.1...beta.2 compare (25 commits, Astro 7)](https://github.com/withastro/flue/compare/v1.0.0-beta.1...v1.0.0-beta.2)

---

Canonical: https://www.thedeepfeed.ai/posts/2026-05-02-flue-agent-harness-framework/
Site: https://www.thedeepfeed.ai
Full corpus: https://www.thedeepfeed.ai/llms-full.txt