What Is Flue Framework? A TypeScript Agent Harness From the Astro Team, Launched June 2026 on Cloudflare Agents SDK / Pi / Durable Objects Write Once, Deploy Anywhere, Use Any LLM — With 25+ Channel Integrations (Slack / GitHub / Linear / Discord / Notion / Stripe / Shopify) and React Hooks (useFlueAgent / useFlueWorkflow)
Flue Framework (official site / 1.0 Beta blog / Cloudflare partnership blog) is a TypeScript AI-agent harness framework from the Astro team, published as 1.0 Beta the week of June 17, 2026. Its slogan — write once, deploy anywhere, use any LLM — is backed by 25+ built-in channel integrations (Slack, GitHub, Linear, Discord, Notion, Stripe, Shopify, Teams, Telegram, Twilio, WhatsApp, and more).
Three-layer stack:
- Framework layer: Flue (project structure, conventions, integrations, CLI)
- Harness layer: Pi (the agentic loop — tool calls and context management)
- Runtime layer: Cloudflare Agents SDK (compute, state, storage)
The Cloudflare integration: when Flue deploys to Cloudflare, each agent becomes a Durable Object (see our Durable Objects deep dive). runFiber() / stash() / onFiberRecovered() checkpoint state into SQLite so agents resume cleanly after interruptions. It composes @cloudflare/codemode (Dynamic Workers that safely execute agent-generated TypeScript, isolates in under 10 ms, ~$0.002 per load), @cloudflare/shell (SQLite-backed virtual filesystem), and @cloudflare/dynamic-workflows (persistent workflows with retry and external-approval support).
Five core primitives:
1. Agents — autonomous, context-aware
2. Workflows — deterministic step execution
3. Sandboxes — safe tool-execution environments
4. Channels — Slack / GitHub / Linear / Discord / Notion / Stripe / Shopify — 25+
5. Durable Streams — event transport where accepted work never disappears
Supporting layers: @flue/react (useFlueAgent / useFlueWorkflow hooks for direct front-end integration), @flue/sdk (client for talking to deployed agents), flue add (shadcn-style integration scaffolding), Subagents, Tools & Skills (typed API actions plus reusable expertise packages), MCP integration, and observability via OpenTelemetry / Braintrust / Sentry.
Deploy targets: Cloudflare Workers, Node.js, AWS, Docker, Railway, Render, Vercel, Fly, GitLab CI, SST. Databases: PostgreSQL, Supabase, MongoDB, MySQL, Redis.
Backstory: Flue started life as the internal engine for AI workflows inside Astro's own GitHub repos and was subsequently generalized. The Astro team is known for exceptional developer experience, and that shows up in the CLI and integration polish.
Positioning: Flue is the first major agent framework built on Cloudflare's Agents SDK, sits inside the same harness-driven architecture family as Claude Code, and doesn't belong to the LangChain / LlamaIndex / AutoGen / CrewAI / Mastra lineage — its wedge is the framework-layer polish plus the breadth of integrations. The official demo implements a bug-triage agent in under 25 lines.
TL;DR — What Is Flue Framework?
Flue Framework is a TypeScript AI-agent harness framework from the Astro team (the makers of the Astro web framework), published as 1.0 Beta the week of June 17, 2026 (official site / 1.0 Beta blog).
Four takeaways:
1. "Write once, deploy anywhere, use any LLM" — TypeScript-based, LLM-agnostic, deployable to Cloudflare, Node.js, AWS, Vercel, Fly, Docker, and more
2. Three-layer stack — Framework (Flue) + Harness (Pi) + Runtime (Cloudflare Agents SDK / Durable Objects)
3. 25+ channel integrations built in — Slack, GitHub, Linear, Discord, Notion, Stripe, Shopify, Teams, Telegram, Twilio, WhatsApp
4. On Cloudflare, each agent becomes a Durable Object — SQLite checkpointing for automatic recovery, and Dynamic Workers execute agent-generated code in under 10 ms
This column continues our 2026 agent-platform primitives series alongside Cloudflare Durable Objects, agmsg, Sakana Fugu, and Claude Code Agent View.
What Flue Is — Born as an Astro Internal Tool
Flue started life as the engine driving AI workflows inside the Astro team's own GitHub repositories and was subsequently generalized into a framework.
The Astro team's reputation for developer-experience polish carries through: the CLI, integration scaffolding (flue add), React hooks, and typed APIs all show unusual attention to detail.
Cloudflare's official blog frames Flue as "the first major agent framework built on Cloudflare's Agents SDK" (Cloudflare Blog: Bringing more agent harnesses and frameworks to Cloudflare, starting with Flue), signaling a real strategic partnership.
Three-Layer Architecture
The key to understanding Flue is its three-layer stack:
| Layer | Role | Implementation |
|---|---|---|
| Framework layer | Project structure, conventions, integrations, CLI, DX | Flue |
| Harness layer | The agentic loop — tool calls, context management | Pi |
| Runtime / Platform layer | Compute, state, storage | Cloudflare Agents SDK (other runtimes supported) |
Why the separation matters: the Framework (Flue) is loosely coupled to the harness implementation (Pi), and the harness is loosely coupled to the runtime (Cloudflare). Each layer is independently swappable. That's why Flue also runs on Node.js, AWS, Vercel, and Fly.
Cloudflare Integration — Deep Reliance on Durable Objects
Cloudflare deployment is where Flue is most differentiated:
(1) Each agent = one Durable Object. Flue makes full use of the "name-addressed, stateful, globally-unique instance" primitive we covered in the Durable Objects column. Agent IDs map to DOs; single-master semantics comes for free.
(2) runFiber() / stash() / onFiberRecovered() checkpointing. Agent progress is checkpointed into the DO's built-in SQLite, so sessions resume automatically across failures, deploys, and cold-starts. This delivers the durability that used to require Temporal / Airflow / Prefect-class engines as a side effect of the runtime.
(3) @cloudflare/codemode — dynamic TypeScript execution in isolates. Agent-generated TypeScript runs safely in Dynamic Workers with under 10 ms isolate startup and about $0.002 per load. What used to require Docker / Firecracker / gVisor sandboxes is now a platform primitive.
(4) @cloudflare/shell — SQLite-backed virtual filesystem. grep / read / write without spinning up a container, so agents handling file operations (log parsing, config edits, code edits) don't pay full-container overhead.
(5) @cloudflare/dynamic-workflows — durable workflows. Multi-step workflows generated by agents can be persisted, retried, and paused on external approvals. Human-in-the-loop approval or long external-API waits are handled transparently.
Five Core Primitives
(1) Agents — context-aware, autonomous goal-seekers. Pi runs the LLM-call / tool-call / reasoning / error-handling loop, and Flue wraps it in ergonomic TypeScript APIs.
(2) Workflows — deterministic step execution. Agents (for open-ended problems) and Workflows (for precise, defined steps) coexist inside the same framework.
(3) Sandboxes — safe execution environments for tools, file edits, and autonomous work. On Cloudflare, @cloudflare/codemode + @cloudflare/shell implement this.
(4) Channels — 25+ external integrations across Slack, GitHub, Linear, Discord, Notion, Stripe, Shopify, Teams, Telegram, Twilio, WhatsApp, and more. Agents expose themselves as Slack bots, GitHub Actions, Discord bots, or webhook APIs out of the box.
(5) Durable Streams — event transport that guarantees accepted work never disappears. An event bus that leans on Durable Objects' transactional properties.
Additional Building Blocks
@flue/react: useFlueAgent / useFlueWorkflow hooks call deployed agents from the frontend with real-time streaming built in. No custom WebSocket infrastructure required.
@flue/sdk: client library for talking to deployed agents. HTTP / RPC wrapper.
flue add: shadcn-ui-style scaffolding CLI. Adding an integration generates the needed code, config, and dependencies automatically.
Subagents: delegate specialized tasks. A parent agent can spawn many child agents that work in parallel.
Tools & Skills: typed API actions (Tools) and reusable expertise packages (Skills). Skills are effectively npm packages that carry expertise across projects.
MCP integration: full support for Anthropic's Model Context Protocol so existing MCP servers (Datadog, Slack, internal CRM, etc.) work unchanged.
Observability: OpenTelemetry, Braintrust, and Sentry are supported out of the box. Traces, evaluation, and error tracking are production-grade from day one.
Deploy Targets
Cloudflare isn't required:
Compute:
- Cloudflare Workers (recommended, full Durable Objects benefits)
- Node.js
- AWS Lambda
- Docker
- Railway, Render, Vercel, Fly
- GitLab CI, SST
Databases (for state outside Cloudflare):
- PostgreSQL, Supabase
- MongoDB, MySQL
- Redis
Off Cloudflare, you lose Durable Objects' single-master benefits and must design state management around an external DB. Cloudflare is recommended if you want the full experience.
Sample Code — Bug Triage Agent in Under 25 Lines
The official Cloudflare demo:
import { defineAgent, tool } from '@flue/runtime';
import { github } from '@flue/channels';
const bugTriage = defineAgent({
name: 'bug-triage',
channels: [github({ events: ['issues.opened'] })],
system: 'You triage bug reports. Reproduce the bug in a sandbox, then diagnose.',
tools: [
tool('reproduce', async ({ code }) => {
return await sandbox.run(code);
}),
tool('comment', async ({ issue, body }) => {
return await github.postComment(issue, body);
}),
],
});
export default bugTriage;What this code delivers:
- Automatically fires the moment a new GitHub issue opens
- The LLM parses the bug report and generates TypeScript that reproduces it
- The sandbox on Cloudflare Dynamic Workers isolates in under 10 ms and executes it
- The LLM diagnoses the result and posts a comment back on the issue
- The whole pipeline runs on a Durable Object, so any interruption resumes from checkpoint automatically
The equivalent in GitHub Actions + Docker + Node.js + Redis would be hundreds of lines of infrastructure code plus ongoing operational work. This is where Flue's design philosophy shows through most clearly.
Competitive Positioning
Agent-framework market map:
| Framework | Notable | Runtime | Gap vs Flue |
|---|---|---|---|
| LangChain | Python-centric, huge ecosystem | Generic | Flue is TypeScript-first, DX-focused |
| LlamaIndex | RAG / retrieval-focused | Generic | Flue is a general agent/workflow framework |
| AutoGen (Microsoft) | Multi-agent conversation | Python | Flue is TypeScript, broader channels |
| CrewAI | Role-based multi-agent | Python | Flue is lighter, wider integrations |
| Mastra | TypeScript agent framework | Node.js / Cloudflare | Closest neighbor. Flue's edge is deep Cloudflare Agents SDK integration |
| Claude Code | Anthropic's official CLI | Anthropic cloud | Flue is LLM-agnostic; Claude Code is Anthropic-only |
| agmsg | CLI-agent messaging | Local SQLite | agmsg is just the messaging layer; Flue is full-stack |
| Sakana Fugu | Orchestration model | API service | Fugu is an "LLM that calls LLMs"; Flue is a framework layer |
| Flue Framework (this column) | Astro DX + Cloudflare Agents SDK + Pi harness + 25+ integrations | Cloudflare Workers etc. | — |
Flue's three-part wedge:
1. Deep Cloudflare Agents SDK integration (native use of Durable Objects, codemode, shell, dynamic-workflows)
2. Astro-team DX quality (CLI, scaffolding, React hooks polish)
3. 25+ channel integrations built in (Slack, GitHub, Linear, Discord, Notion, Stripe, Shopify from day one)
Representative Use Cases
- Internal GitHub automation (Astro's original use case) — issue triage, PR review, dependency updates
- Customer-support automation — questions arriving via Slack / Discord / Intercom, handled by Flue agents
- Business workflows — approvals, financial transaction processing, long-running external-API integrations
- Backend for agent products — implementation framework for products like Cursor iOS and Claude Code
- Developer tools — custom coding agents (internal-repo understanding, auto-PR generation)
- Multi-agent swarms — dividing large tasks across specialized subagents
Operational Caveats
(1) 1.0 Beta: released the week of June 17, 2026. APIs may still shift. For production, decide whether to wait for stability. The roadmap emphasizes polish, documentation, and multi-node scaling.
(2) Cloudflare dependency: full-feature deployment recommends Cloudflare Workers. Other runtimes miss Durable Objects benefits. Effectively you're accepting Cloudflare vendor lock-in.
(3) TypeScript / Node.js only: no interoperability with the Python ecosystem (LangChain / LlamaIndex / AutoGen / CrewAI). Organizations with heavy existing Python investments face migration cost.
(4) Pi harness maturity: Flue depends on Pi, which is also young. Both projects evolve together, which carries dual-evolution risk.
(5) Operational learning curve: using all 25+ channels, durable execution, and sandboxes well means understanding Cloudflare Workers, Durable Objects, and Pi. For a single lightweight script, this is overkill.
Strategic Context — H2 2026 Agent-Framework Market
H1 2026 saw the agent-framework market split cleanly into Python (LangChain, AutoGen) and TypeScript (Mastra, Flue) camps. The TypeScript camp is gaining share where web/SaaS teams live and where edge runtimes (Cloudflare / Vercel) are the deployment target of choice.
Flue's strategic footing:
1. The Astro team brand — a DX-respected team is a real distribution advantage in developer communities
2. The Cloudflare Agents SDK official showcase — expect marketing support from Cloudflare
3. The appeal of "write once, deploy anywhere, use any LLM" — in the current LLM turbulence (Fable 5 shutdown and return, Sonnet 5, Grok Build), avoiding LLM lock-in is a real feature
4. Breadth of channel integrations — having Slack / GitHub / Linear / Discord / Notion / Stripe / Shopify from day one is a competitive moat
Related services from us — software development, AI consulting, and OpenClaw setup. For help designing TypeScript agent stacks with Flue Framework or Cloudflare Agents SDK, or automating internal workflows, get in touch.
Bottom Line
Flue Framework is a TypeScript AI-agent harness framework, published by the Astro team as 1.0 Beta the week of June 17, 2026. With "write once, deploy anywhere, use any LLM," a three-layer Framework (Flue) + Harness (Pi) + Runtime (Cloudflare Agents SDK) stack, 25+ channel integrations, and durable execution powered by Durable Objects, Flue arrives as a new-generation agent framework deeply rooted in the Cloudflare ecosystem.
Three enduring impacts:
1. First real showcase on the Cloudflare Agents SDK — Durable Objects / codemode / shell / dynamic-workflows all used natively at the framework level
2. DX-driven design from the Astro team — CLI, React hooks, and scaffolding at a polish level that stands apart from prior agent frameworks
3. Bug-triage agent in under 25 lines — distributed-system, durability, and sandbox complexity absorbed by the framework
Caveats: 1.0 Beta API risk, Cloudflare dependency, TypeScript / Node.js-only, Pi maturity, and the operational learning curve.
References
Official:
- Flue Framework
- Flue 1.0 Beta announcement
- Getting Started docs
- Astro web framework
Cloudflare:
- Cloudflare Blog — Bringing more agent harnesses and frameworks to Cloudflare, starting with Flue
Third-party:
- Developers Digest — Flue: The Agent Harness Framework and Why It Feels Different
- Better Stack Community — Flue: Headless, Programmable AI Agent Framework from the Astro Team
- Openflows — Flue: Open-Source Agent Harness Framework
- Open Source Alternatives — Flue Framework: Open Source Alternative to Devin AI
Related columns:
- Cloudflare Durable Objects deep dive
- agmsg — cross-vendor CLI agent messaging
- Sakana Fugu — orchestration model
- Claude Code Agent View — parallel orchestration
- Cursor iOS — mobile coding agent
- Claude Sonnet 5 release
- Claude Fable 5 returns
- Grok Build — xAI CLI coding agent
- Loop Engineering — Maker-Checker paradigm
- Ornith-1.0 — DeepReinforce agentic-coding LLM
Feel free to contact us
Contact Us