Video summary

Flue vs Claude Code vs Mastra — Which Agent Framework Wins?

Main summary

Key takeaways

Technology

Technological concepts & core idea

  • Flue (Flu) agent framework is positioned as an agent runtime that can run thousands of AI agents concurrently without the usual cost of spinning up containers per agent.
  • The key enabling concept is that an “agent” requires a “harness”: tooling + sandbox access + reusable skills + tool integrations (as opposed to a plain chat UI).

“Harness” as the definition of a real agent

The video contrasts Flu’s approach with other systems (notably Claude Code style tooling):

  • A harness typically:
    • scans instruction files
    • connects to tool servers via MCP servers
    • provides sandbox access
    • loads reusable skills
  • Without the harness, it’s “just a chat box,” meaning the model lacks the machinery to safely perform real work.

How Flu works (product features / developer workflow)

Installation / setup

  • Install two packages:
    • @flu/runtime (runtime import)
    • @flu/cli (compiles/serves)
  • Provider-agnostic in the description: the demo uses Anthropic, but multiple providers are supported.

Build targets

Same code can deploy to:

  • Node: an HTTP server (via Hono)
  • Cloudflare: a worker + Durable Object for persistence

Defining and running an agent

  • A very short agent definition (about ~5 lines).
  • Start it with something like flu connect using filename + instance ID.
  • Prompts stream output and include a receipt with:
    • input/output token counts
    • total cost
    • model used

Why running “thousands” is cheap: in-memory sandbox instead of containers

  • Each Flu agent gets a sandbox by default so it can safely access files.
  • Standard approach: sandboxing usually means booting containers, which becomes expensive at scale.
  • Flu’s “sandbox trick”:
    • avoids container boot entirely
    • uses a TypeScript-implemented bash runtime (described as “bash in TypeScript” / Verses just bash)
    • runs the sandbox in memory
  • Result claim: concurrency scales to thousands of agents with minimal incremental overhead (with a caveat that exact numbers are illustrative).

Workflow support (beyond agents)

  • Workflows are exported similarly, but instead of exporting an agent, you export a run function and provide a skill.
  • Demo workflow:
    • runs a Python script to generate and score YouTube titles
    • returns ranked results (like a “FitIQ style” ranking)

Tutorial-like debugging: in-memory sandbox vs local filesystem access

Issue demonstrated

  • The workflow/skill fails saying there are no files on the filesystem.

Explanation

  • The in-memory sandbox only registers the skill’s description, not its actual filesystem contents.

Fixes

  1. Use local from the Flu runtime to run with real machine file access and point at the skill folder.
  2. Avoid local access by wrapping the Python script as a custom tool (tool validation/registration is described via a “Valle Bot” step in the subtitles).

Deployment model

HTTP triggers

  • Add root middleware.
  • Build, choose target + port, and run a server.

Compilation output

  • Flu compiles into a single server.mjs file that can be deployed anywhere Node runs.

Triggering

  • Start a workflow via an HTTP curl POST.
  • Receive a workflow ID.
  • Curl again with the ID to retrieve results (example uses jq).

Streaming

  • Flu supports WebSockets for streaming output.

Comparison with Mastra / Claude Code / other frameworks

  • Claude Code: described as having a harness under the hood (scan instructions, tool loading, MCP, sandbox, skills).
  • Mastra (and Versal AI SDK): presented as powerful and capable, but Flu differs in starting point:
    • Flu is harness-first: pre-assembled scaffolding for sessions/memory/sandbox/tool loading.
    • Mastra requires more manual wiring (sessions, memory, sandbox, tool loading), at least in the tutorial context.

Video’s framing claim

  • Flu asserts: “An agent without a harness is not a real agent.”
  • It challenges whether “Cloud Code” is truly a framework or just a programmable harness.

Caveats noted

  • The video emphasizes that Flu provides the mechanism, not a guaranteed “benchmark dollar figure.”
  • Displayed scalability claims should be treated as illustrative.

Main speakers / sources (as inferred from subtitles)

  • Fred Schott (named as part of the Astro team / Astro connection)
  • Astro team (creator/source of Flu)
  • Amplitude engineer (named indirectly as the person who brought attention to “every agent should have access to this”)
  • Hostinger (sponsor mentioned)

Other systems mentioned

  • Claude Code, Mastra, LangChain, Open Cloud, Versal AI SDK
  • MCP servers, Anthropic

Sponsors/brands example

  • Hostinger

Original video