MIND Flow
Compiled graph orchestration for AI systems — built on the MIND stack.
MIND Flow is a commercial product that lets you author multi-node AI pipelines in a typed .flow.mind DSL and compile them to native ELF binaries. It sits above mind-runtime and mind-mem, inheriting the same determinism and auditability guarantees as the rest of the MIND stack.
What it is
Most AI orchestration tools treat pipelines as interpreted graphs — nodes are resolved at runtime, edges carry untyped data, and execution order can shift between runs. MIND Flow takes a different approach: every graph is a program. You describe the topology in the .flow.mind DSL, the compiler type-checks every edge, and mindc lowers the whole graph to machine code through its standard MLIR pipeline.
The result is a self-contained ELF binary that runs on mind-runtime. It carries the same SHA-256 build identity and deterministic execution guarantees as a hand-written MIND program. The graph structure — nodes, edges, flow conditions — is fixed at compile time. There is no interpreter, no dynamic dispatch layer, and no hidden state outside mind-mem.
MIND Flow is part of the commercial tier. It is distributed under a separate license and is not open-source. Contact sales to request a pilot binary or discuss deployment terms.
Where it sits
MIND Flow occupies the Orchestration plane — above the compiler, runtime, and memory system, but still within the same determinism boundary.
MIND Stack — Four Planes
Orchestration Plane — MIND Flow
Graph authoring, compilation, and multi-node execution. Compiled from .flow.mind DSL.
Control & Verification Plane — mind-runtime
SENSE → THINK → ACT → VERIFY → LEARN execution cycle. Constraint engine, saga coordinator, audit logger.
Memory Plane — mind-mem
Versioned, contradiction-safe memory. Hybrid BM25 + vector retrieval. Cryptographic audit chain.
Compiler Foundation — mindc
MIND source → MLIR → LLVM IR → deterministic native binary. Type checker, shape verifier, autodiff.
How it’s different
Four properties set MIND Flow apart from interpreted orchestration approaches.
Offline-first
Graphs compile to standalone binaries. No network calls at startup, no registry lookups, no interpreter download. Deploy the binary and it runs. Useful for air-gapped environments, embedded deployments, and reproducible CI pipelines.
Deterministic trace
Every edge in the graph carries an evidence record. Given the same inputs and the same mind-mem snapshot, the execution trace is bit-identical. You can replay any historical run, audit which node produced which output, and diff two runs at the edge level.
Governed memory
Memory is not an ambient service bolted on after the fact. mind-mem is the declared memory plane for every Flow graph. Reads and writes are typed, versioned, and cryptographically logged. Memory mutations that violate declared invariants are rejected at the verify node before they reach the next edge.
Compiled, not interpreted
The graph topology is resolved at compile time. Edge types are checked by the MIND type system — the same type system that enforces static tensor shapes in native MIND programs. There is no dynamic routing layer that can change behaviour between calls.
Node kinds
A .flow.mind graph is composed of exactly seven node kinds. Each kind has a fixed contract — declared inputs, outputs, and any side-effect surface — enforced by the type checker.
| Kind | Purpose |
|---|---|
| native | Calls a compiled MIND function. Deterministic by construction. |
| llm | Sandboxed call to an external language model. Output is event-sourced and passed to verify before continuing. |
| tool | Typed side-effect — file I/O, HTTP call, database write. Registered with the saga coordinator for rollback. |
| branch | Compile-time-declared conditional. Both paths are type-checked; only one executes at runtime. |
| memory | Explicit read or write to the mind-mem plane. Returns a versioned handle. |
| verify | Constraint check node. Rejects outputs that violate declared invariants; triggers saga rollback on rejection. |
| agent / fleet | Delegation to a sub-graph or a fleet of parallel agents. Outputs are aggregated by the parent graph before the next edge. |
Request a pilot
MIND Flow is available to qualified design partners. Reach out to discuss your use case, target deployment, and compliance requirements.