MIND Flow

Compiled graph orchestration for AI systems, built on the MIND stack.

MIND Flow is a commercial product, currently in pilot with design partners, that lets you author multi-node AI pipelines in a typed .flow.mind DSL and compile them to native binaries for Linux, macOS and Windows. 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.

.flow.mind DSLYou describe the topology
Type checkThe compiler type-checks every edge
mindc MLIR pipelineLowers the whole graph to machine code
Native ELFSelf-contained, runs on mind-runtime

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.

Orchestration Plane: MIND FlowCommercial
Graph authoring, compilation, and multi-node execution. Compiled from .flow.mind DSL.
Control & Verification Plane: mind-runtimeCommercial
SENSE → THINK → ACT → VERIFY → LEARN execution cycle. Constraint engine, saga coordinator, audit logger.
Memory Plane: mind-memApache 2.0
Versioned, contradiction-safe memory. Hybrid BM25 + vector retrieval. Cryptographic audit chain.
Compiler Foundation: mindcApache 2.0
MIND source → canonical IR → native backend or MLIR → LLVM → deterministic native binary. Type checker, shape verifier, autodiff.

MIND Stack: four planes. Each plane builds on the planes below it.

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.

Request a pilot Cognitive Kernel docs Ecosystem overview