Investment & Market Intelligence

The Investor

The Signal

Flue's creator deleted multi-agent routing because his biggest customers run one agent.

File-based routing shipped in May and was gone before the August stable release, which is one quarter from build to retreat and the strongest public counter-evidence yet to the orchestration multiplier that 2026 seed math has been quietly underwriting. It is one vendor reading his own account list, not a market study, so it lands as a diligence question rather than a verdict. The useful test is whether the orchestration-layer names in your book can point to a customer actually running more than one agent in production.

In Play

  1. Agent Frameworks Exit Into Hosts

    The layer developers adopt has separated from the layer that invoices. The first portfolio consequence: framework-layer deals in your pipeline should be underwritten to a strategic buy, not an independent platform. Fred Schott — creator of Astro, whose team Cloudflare acquired in January — shipped Flue 2, the second major release of his open-source agent framework, with no disclosed revenue model, per this week's Latent.Space interview. Each of the three rival lineages he names sits inside or beside an infrastructure vendor that bills for compute: Vercel owns the AI SDK and the new eve agent framework, Cloudflare owns the Agents SDK, and Mastra comes from the ex-Gatsby team. The deep dive below maps this lineage by lineage, with the pricing caveats that go with it.

    Ask Clarity
  2. The One-Agent Enterprise

    Schott removed file-based routing from Flue because, as he put it on Latent.Space this week, 'their whole company is one agent. They don't care about routing.' He was describing his largest customers, and he reversed his framework's core architecture over it. That is the strongest public counter-evidence yet to the multi-agent routing and registry thesis sitting under many of the 2026 seed decks in our own pipeline. It is also one vendor's view of its own accounts, so treat it as a diligence question rather than a settled fact.

    Ask Clarity
  3. Claude Code Became the Acquisition Channel

    Flue's onboarding is a prompt a developer pastes into a coding agent, and its documentation is markdown-native so machines can read it, per Latent.Space. Schott benchmarks the product against Anthropic's Claude Code — 'like Claude Code, but 100% headless and programmable' — while developers use Claude Code to stand up their first Flue agent. Anthropic is collecting distribution over a competitor's activation funnel for free. For dev-tool holdings, agent-assisted activation is now a funnel to instrument separately.

    Ask Clarity
  4. Agent-Infra Interfaces Underwrite to 2027

    Flue launched v1 in early May and reached its first stable release in August only after reversing its core architecture, per this week's Latent.Space interview — so what is new here is the interview, not the release. Bret Taylor, Sierra's CEO and OpenAI's chairman, calls this 'the jQuery era of agents, not the react era,' and Schott concedes nobody agrees what a 'meta-harness' — a layer of abstraction sitting above the harness that runs the agent loop — even means. Interfaces at this layer are changing faster than enterprise procurement cycles run. Agent-infra revenue models built on 2026 pipeline are underwriting a category that has not picked its abstractions.

    Ask Clarity

Deep Dives

The Agent Framework Layer Prices as a Talent Deal

Three of three lineages named in the interview landed inside or beside infrastructure vendors, and the only player billing for execution is the one that skipped the developer-ergonomics fight entirely.

The moat that becomes a checkbox

Flue's founding premise, as Schott put it on Latent.Space, was that 'there is no agent without a harness', the harness being the loop that decides what the model sees each turn, which tools it may call, and when the work is finished. It was a good early bet, and Schott is the one telling you it is being neutralized: he names Vercel AI SDK, Cloudflare Agents SDK and Mastra as all now adding harnesses of their own. A capability that arrives as a minor release from a competitor with a larger installed base is a feature, not a moat. Harness-native stops being a reason to pick one framework over another roughly when those ship.

The free layer and the billed layer

The asymmetry a fund should care about is where the meter sits. Flue and Pi (the minimal primitive Flue is built on) are open source with no disclosed revenue model, and a managed agents product is not on the roadmap, because, in Schott's words, 'It's so early for us, we're just focused on building the best harness.' Which is an honest answer and also a resource-allocation decision: the engineering going into the harness is engineering not going into hosted execution. In the same window LangChain shipped Managed Deep Agents, hosted agent execution billed by usage. A framework runs inside the customer's own process and generates no invoice. A runtime holds the execution, the state, the retries and the audit trail, and generates one every month.

PlayerLineage / ownerHarness postureWhat it bills for
Flue 2Astro team → Cloudflare (January)Harness-native, built on PiNothing disclosed
eveVercelHarness-nativeVercel hosting
Cloudflare Agents SDKCloudflareRetrofitting a harnessCloudflare compute
MastraEx-Gatsby team, independentRetrofitting a harnessUnclear
LangChain Managed Deep AgentsLangChainHarness abstracted awayUsage-billed hosted execution

What that prices at, and on what basis

Hosts do not buy these teams off a profit-and-loss statement; they buy distribution into developer workflows that pulls compute onto their platform. Priced that way, the interesting terms in a framework-layer deal are ownership and the valuation you pay in, not the TAM slide. Our working band for an outcome of that shape is $50–250M, and it is worth saying plainly that the band is this desk's prior from earlier developer-tooling acqui-hires rather than a figure in the source: no price was disclosed for the Astro team's move to Cloudflare, and none is public for the other lineages in the table above. It needs a comparable-transaction pull before it goes near a model. Same caution on reach. Three named lineages support a claim about these teams and this cohort, not a ceiling for every framework in the category.

The framework layer is where developers arrive. The runtime layer is where they get billed. Frameworks in this lineage are talent deals with documentation.

What is corroborated, and what is not

Today's read rests on one long interview, so separate the checkable from the asserted. The load-bearing structural facts are public transactions and product ownership: the Astro team's move to Cloudflare in January, Vercel's ownership of the AI SDK and eve, Mastra's ex-Gatsby founders, LangChain's hosted product. What is not corroborated anywhere is demand. No revenue, retention or account counts exist publicly for any framework named here. Hold the exit-shape argument at medium-to-high confidence and treat every adoption claim as unverified until a diligence call produces numbers.

This is probably right rather than certainly right, and it has a clean falsifier. If a framework converts developer love into a metered product before the incumbents finish retrofitting harnesses, it escapes the talent-deal ceiling. LangChain is the existence proof that the conversion is available. Flue is declining to attempt it.

What to do

  1. Rewrite the exit assumptions on every open agent-framework and agent-DX deal to a strategic-acquisition base case this week, then re-derive the valuation at which each deal still clears fund math.

  2. Pull the last comparable developer-tooling acqui-hires from our own transaction file this week and test the $50–250M working band against them before it goes into any model.

  3. Add one question to the agent-infra diligence template before the next investment committee: show harness differentiation that survives incumbents shipping harnesses within two quarters.

  4. Open sourcing conversations this quarter at the hosted agent runtime layer — managed execution, agent state and durability, evaluation, and privilege gating for dynamically attached tools.

One Agent Per Company Is the Number That Breaks Orchestration TAM

Flue's largest users had nothing to route, so its creator deleted the routing layer — and with it the multiplier sitting under the 2026 seed math in our own pipeline.

What was actually deleted

File-based routing is the convention where the directory layout of a project decides which specialised sub-agent handles which request, which is to say the pattern a decade of web frameworks trained developers to expect and therefore the pattern nobody had to argue for. Schott shipped it in Flue v1 in early May and pulled it out before the August stable release, and the stated reason was not mechanics but demand: 'their whole company is one agent. They don't care about routing.' Nothing broke. The customers he cares most about had nothing to route.

Why the deletion travels further than the feature

The interesting part is the causal chain, which runs from deployment shape to revenue model rather than the other way round. If an enterprise runs one agent instead of a fleet, there is no fleet to schedule, no inter-agent protocol to standardise, no registry to resolve agents in, and (this is the part that shows up in a model) no per-agent runtime or per-agent seat to invoice. Orchestration TAM is arithmetic on agent count, agents per company multiplied by companies, and setting the first term to one collapses the layer above the harness from a market into a feature of the harness. Schott performed that collapse in code when he deleted routing instead of fixing it. It is the first time a vendor has removed the multiplier from its own product rather than from someone else's forecast.

How much weight it carries

On its own, not much, and the arc is the reason. A core-architecture reversal roughly three months after v1 is one vendor reading its own largest accounts, inside a product early enough that its creator says a managed offering is not on the roadmap. The competing reading, or rather the more interesting version of it, is that consolidation is a phase and not an endpoint: early adopters concentrate logic in a single agent because that is the cheapest thing to reason about, then fragment as teams, permissions and audit boundaries multiply. Both readings fit the evidence in front of us, which is why this belongs in diligence this quarter rather than in a mark-down this week. The check is cheap. One agent per company is a claim about named accounts, and named accounts can be counted.

What to do

  1. Add the concurrency test to every orchestration diligence memo this quarter — named accounts running more than three concurrent production agents for ninety days or longer — and run it against existing orchestration holdings, not only new deals.

  2. Commission a two-week check with three enterprise architects on whether one-agent designs fragment as deployments scale, before the next orchestration deal reaches committee.

The bottom line

In agent tooling, the layer developers adopt and the layer that sends an invoice have come apart. That breaks the habit of reading developer adoption as evidence of pricing power: ergonomics accrue to whoever gets hired, while distribution accrues to whoever owns the compute and the model. Commission one re-underwriting pass across your agent-tooling exposure that asks each company to name the metered unit it bills for, and treat an inability to name one as the finding rather than a gap in the memo.