FloMorphic

Business processes govern how AI operates

The prevailing model puts an autonomous agent in charge of a business process. FloMorphic inverts it. The process is defined first — its valid states, its allowed transitions, its policies, its approval points — and the model operates inside that definition.

The result is AI that remains visible, controllable, auditable, and adaptable while still benefiting from modern reasoning models. Judgment is what you want from a model. Control is what you want from the system around it.

        LLM
         │
   ┌─────┴─────┐
   │           │
 tools      decisions
   │           │
   └─────┬─────┘
         │
      outcome

     Process
         │
    ┌────┼────┬────────┐
    │    │    │        │
 policy  LLM  human  tools
    │    │    │        │
    └────┼────┴────────┘
         │
      outcome

Instead of autonomous agents controlling business processes, business processes govern how AI operates.

A smart contract for AI-powered systems

The same idea a smart contract applies to value, FloMorphic applies to behavior: the rules are declared up front, they are enforced by the runtime rather than by good intentions, and what happened is inspectable afterwards.

Six primitives, and nothing reserved

FloMorphic is a product layer on the Inflowenger runtime. Its canvas nodes speak the language of what you are building; the runtime underneath knows only six node types. Every node records which one it lowers to — and that annotation is visible in the product, not buried in a compiler.

Five of the six are compiled artifacts. Plugin is the exception — it never compiles away, because it is a real external process with its own connections, its own background loops and its own configuration form. That is why a model call, an MCP client and a field-mapper can all be plugin nodes without the runtime knowing what any of them mean.

From canvas to execution

1. AuthorCompose nodes on the canvas, configure them, connect their handles.
2. SaveThe raw editor graph is persisted verbatim. No translation happens in the browser.
3. CompileA per-node hook reads each node's configuration and builds the matching primitive; edges become transitions.
4. ExecuteA Fractal fetches that node map and walks it, asking the backend for flows and context as it goes.

The hook is the only place product-specific knowledge lives — which is why a different palette on the same primitives requires no runtime change. See the full reduction →

Thirteen nodes, grouped by intent

Each one annotated with the primitive it becomes on compile.

One vocabulary, composed from the same parts

What the field treats as distinct capabilities, and the composition each one is here.

What is not in that list is a runtime feature invented for any single row. Composable primitives over specialized abstractions is a design commitment, and this is what it buys.

The model routes the diagram

The model node's bound functions are outbound ports on the canvas. You declare a function — approve, escalate, search_docs — and it renders as a port you can draw an edge from.

At run time those functions are handed to the model as tools. When the model answers with a tool call, the runtime fires only the matching port. No tool call, and the flow takes its default route.

The model's decision is a visible edge in the diagram, not a hidden branch inside an agent's control loop.

Every route the model is permitted to take — and everything downstream of each one — is inspectable before it runs. Behavior is bounded by construction rather than by prompt. And the "function" never has to be implemented as a function: it is a routing tag, and its implementation is whatever you compose after it.

Context as a first-class system artifact

Patterns, not special-purpose nodes

The behaviors other platforms ship as dedicated features are compositions here. Two examples carry most of the weight.

There is no Loop node

   ┌───────────────────────────────────────────────┐
   │                                        no     │
   ▼                                               │
[ LLM ] ─────► [ Rule: is the task satisfied? ] ───┘
                          │
                          └── yes ──► [ next step ]

The model node appends to the message stack on the context. The Rule node checks whether the task is done. If not, an edge routes back. That cycle is the loop — with every iteration observable, every exit condition explicit, and a human review step insertable anywhere inside it.

There is no Observer node

[ LLM ] draft ──► [ LLM ] observer / critique ──► [ Rule ] accepted?
                                                    │      │
                            ┌── no ──────────────────┘      └── yes ──► [ continue ]
                            ▼
                        back to draft

An observer is a model node reading another node's output against explicit criteria, with a Rule deciding what happens next. It is a pattern composed from primitives, not an abstraction the platform provides — which is precisely why you can change what "acceptable" means without waiting for the platform to support your definition.

Integration with existing systems, not replacement

FloMorphic ships no catalogue of branded connectors, and that is deliberate. A connector catalogue is a maintenance liability whose value decays with every upstream API change. What a process actually needs is a small number of general ways to reach outward.

The Extrinsic primitive is how the runtime reaches a service you own: a request/reply against a subject your backend registered, where your handler's response becomes the node's output. It is the mechanism FloMorphic's own storage, approval and scheduling nodes are built on — one wildcard registration can back a whole family of operations.

Four actors, talking over NATS

FloMorphic's backend never executes a flow. It answers the engine's questions — what is this flow, what is this run's context — and runs the domain logic a node calls out to. Fractals do the traversal. Plugins live on their own isolated accounts with narrowly-scoped credentials, able to publish and subscribe only on the subjects they own.

 ┌────────────────────┐   REST: creds, accounts, resources   ┌────────────────────────┐
 │  Infra             │◄────────────────────────────────────►│  FloMorphic API        │
 │  control plane     │                                      │  imports inflow-fusion │
 │  NATS + registry   │   NATS: get flow / get, set context  │  owns the data         │
 └─────────┬──────────┘◄────────────────────────────────────►└───────────┬────────────┘
           │ registered engines                                          │ HTTP + WebSocket
           ▼                                                             ▼
 ┌────────────────────┐   NATS: flow + context, svc.* calls  ┌────────────────────────┐
 │  Fractal (engine)  │─────────────────────────────────────►│  FloMorphic canvas     │
 │  walks the graph   │                                      │  the browser           │
 └─────────┬──────────┘                                      └────────────────────────┘
           │ NATS on an isolated, scoped plugin account
           ▼
 ┌────────────────────────────────────┐
 │  Plugin nodes:  llm  ·  mcp  ·  …  │
 └────────────────────────────────────┘

Every event the engine emits is streamed to the canvas over a WebSocket and traced back onto the nodes and edges that produced it — so a run is observed on the same diagram it was composed on, with its process row recording status, duration and error. Full architecture →

From a laptop to a cluster

The same artifact runs at every size. Nothing about a process changes as the deployment grows — only how many processors are attached to it.

Scaling is adding processors, not re-architecting. The graph, the context model and the node semantics are identical at every stage — so the process you composed on day one is the thing that runs in production, not a sketch of it.

Open source, and open at the seams

Being readable is the easy half. FloMorphic is open where it matters — at the joints you would reach for to build something of your own.