Flows is a deterministic substrate for AI-native software teams. Code extracts facts. Narratives cite facts by hash. Humans seal what they've vouched for. Drift becomes visible the moment it happens — not six months later in a production incident.
"Agents are retrieval-bound, not reasoning-bound. They fail at the substrate, not the reasoning layer. The scarce resource at the top of an agentic stack isn't a better model or a bigger context window — it's machinery that separates what is from what we say about it, and makes the gap between them loud.
Compute is cheap. Tokens are cheap. Plausibility is a commodity.
The substrate that tells you — or your agent, or your auditor — this is actually true, pinned to a specific commit, vouched for by a specific person on a specific date is the load-bearing layer every other part of the stack depends on.
Systems that manufacture verified truth at the rate modern teams change become infrastructure. Systems that don't become fiction.
A subagent reads 10k lines and proposes a doc change in 30 seconds. A human needs 20 minutes to review and commit. If your system requires humans to keep docs in sync with code, you've installed a 40× bottleneck between what agents produce and what your team can trust. The fix is not faster humans — it's flipping which side moves at agent speed.
Agent A writes a spec. Agent B reads it and writes code. Agent C reads the code and updates the spec. Agent D reads the updated spec and writes more code. Somewhere in that chain, A hallucinated a constraint — and now the hallucination has been cited, built on, and compounded into the codebase. Every agent-authored artifact needs to be falsifiable against a deterministic source.
Co-located teams with tenured engineers know what the docs meant to say. Remote teams with contractors, agents, and rapid onboarding don't have that social cushion. If the docs are stale, the docs are the knowledge — and stale knowledge compounds into wrong decisions, shipped, in production, in weeks not years.
Agents are retrieval-bound, not reasoning-bound. Conflating the substrate (what is true) with the orchestration (who does the work) is why agentic systems stall after the demo. Flows separates them with an explicit contract. Each half compounds independently — and the substrate outlives any specific executor.
extract → status → apply. The invariant across languages, domains, and editors. Make and Nix applied to knowledge artifacts. If it doesn't fit the triplet, it's not a Flow.
SHA-pinned source references — not footnotes, not audit logs. A first-class interface element. Clients tap a claim, see the commit, the file, the line, the date a human last vouched. Compliance-compounding. EU AI Act-ready before the deadline.
The verb triplet, the lockfile format, the extractor interface, the retrieval contract — all MIT. We're not asking you to bet your stack on our hosted dashboard.
Flows is a protocol first. The system is the convention, not the tooling. The reference implementation is the most complete today; it won't be the only one tomorrow.
We sell orchestration, sandboxes, and the managed surface for teams that want to ship, not assemble. The substrate stays open. The commercial layer stays honest. Walk away with your flows/ directory any time.
The substrate. CLI, extractors, provenance, lockfile, dashboard. Drop it in any repo. The truth layer your agents query.
The execution layer. Multi-tenant orchestration, sandbox pools, agent routing, cost attribution — all consuming Flows as substrate.
Every system has a shape. Ours is narrow on purpose. The list below is not a roadmap; it's a contract with the reader about what you're buying.
If a controller's internal logic changes while the route signature stays constant, the hash doesn't move. That's what integration tests and behavioral assertions are for. A future behavior::* fact type could narrow this gap; not there yet.
An agent can propose phasing; a human still decides P1 vs P3. Flows surfaces drift; it doesn't tell you whether a feature is worth building. Judgment is load-bearing here, and on purpose.
If metadata.json is full of wishful thinking, the lint can't tell you — it only catches code-doc divergence, not internal-doc-vs-reality divergence. Domain ownership and validator review do that work.
You can seal without reviewing. The system makes it harder — clear warnings, visible lockfile diff in PRs — but a determined rubber-stamper can defeat it. Social norms and PR culture do their part.
Eventually the number of fact types or deliverable tables exceeds what a two-dimensional taxonomy can hold. Probably a graph, probably nested kinds. A problem for 50+ projects, not 3.
Flows tells you "this doc cites this fact and the fact's hash changed." It doesn't tell you what to write instead. Humans with domain knowledge still do the writing. That's a feature, not a bug.
Read the spec, run the CLI, watch your agents stop hallucinating. No signup, no telemetry, no waiting.