Skip to main content

We Don't Know What the Best AI Agents Look Like Yet

· 5 min read
flow-state.dev team

Most AI frameworks start from the same premise: here's how agents work, here's the pattern, fill in the blanks. ReAct loops. Tool-calling chains. RAG pipelines. These are well-understood patterns, and there are plenty of good frameworks for executing them.

We're building something different. flow-state.dev exists because we believe the most powerful AI agent architectures haven't been discovered yet — and the only way to find them is to give developers the right primitives to explore.

The frontier is wide open​

We're still in the early days of what AI agents can do. The patterns that dominate today — single-agent loops, linear chains, fixed tool sets — are starting points, not endpoints. The teams pushing boundaries are the ones experimenting with novel architectures: agents that spawn sub-agents with their own tool pipelines, workflows where a single tool call triggers a multi-step research process, systems where AI has a persistent workspace it can read, write, and organize across conversations.

But experimenting is hard when your framework assumes you already know the shape of your solution. Most tools lock you into their mental model. You can configure what they anticipated. Everything else is a workaround.

Primitives, not patterns​

flow-state.dev takes a different approach. Instead of prescribing agent architectures, we give you four composable primitives — handler, generator, sequencer, router — and a powerful composition system. That's it. Every AI workflow you can imagine reduces to combinations of these four blocks.

The constraint is liberating. Want an agent whose tools are themselves multi-step pipelines? Compose a sequencer, pass it as a tool. Want a router that dispatches to entirely different agent architectures based on runtime state? That's just a router block with sequencer routes. Want to give your AI a persistent workspace with rich documents and structured metadata it can manipulate across sessions? That's resources — hybrid memory that combines text content with atomic state.

// A tool that's a full research pipeline — not just a function wrapper
const deepResearch = sequencer({ name: "deep-research" })
  .then(searchIndex)
  .then(rankResults)
  .then(summarize);

// An agent whose tools are as sophisticated as the agent itself
const agent = generator({
  name: "agent",
  model: "gpt-5-mini",
  tools: [deepResearch, readDoc, writeDoc],
  // ...
});

We didn't design this to make existing patterns easier to implement (though it does). We designed it so you can explore patterns that don't have names yet.

Built to build together​

Exploring new boundaries alone is slow. The real acceleration happens when discoveries compound — when one team's novel tool pipeline becomes another team's building block, when an agent architecture that works brilliantly in one domain gets adapted to another.

That's why flow-state.dev is built for an ecosystem from day one. Every block has the same contract: typed input, typed output, declared state dependencies. A handler, a sequencer pipeline, an entire agent flow — each is a portable unit that composes with anything else. Connectors bridge incompatible types with a single function. No wrappers. No adapters. No inheritance hierarchies.

When someone discovers a powerful new pattern — a novel retrieval strategy, an innovative agent coordination mechanism, a breakthrough in structured output handling — they can package it as blocks and share it. And those blocks compose with yours immediately, because the contracts are universal.

Solid ground for bold experiments​

Exploring new frontiers requires solid infrastructure underneath. You shouldn't have to reinvent streaming, state management, and error handling every time you want to try a new agent architecture. So we made these framework-level concerns:

  • Resumable SSE streaming with sequence-number cursors — disconnect mid-experiment and pick up exactly where you left off
  • Scoped state at four isolation levels with atomic operations — your agent's workspace is reliable even under concurrent access
  • Resources that combine rich text with structured state — give your AI a real workspace, not just a chat log
  • Type safety from schema to screen — one Zod schema flows from server blocks through client SDK to React hooks
  • Deterministic testing — mock generators, seed state, assert on items and state changes without real LLM calls

The framework handles execution semantics — retry, rescue, lifecycle hooks, streaming — so you can focus entirely on the architecture of your AI. Every experiment runs on battle-tested infrastructure.

Where we are​

Phase 1 (Foundation) is largely complete: core contracts, block builders, server runtime with stores and streaming, client transport, React hooks and renderers, and a testing package with deterministic generator mocks. CLI and devtool are in active development.

Come build with us​

We're not here to tell you how AI agents should work. We're here to give you the tools to figure that out — and to make it easy to share what you discover.

The best agent architectures of 2027 probably don't look like anything we'd design today. But they'll be built from composable primitives, on solid infrastructure, by developers who had the freedom to experiment.

Get started and see what you can build.