What the ecosystem is for

You have a model that can genuinely do a piece of the work, and a pilot that demos well and never ships. The hold-up is everything around it: which step runs next and who decided, what each step may see, what happens when an approval takes four days.

That layer, drawn instead of assembled. The process holds the authority, the model is one participant inside it, and an AI node decides between states and transitions somebody drew rather than inventing a path at runtime. Approvals are real steps the process waits on, not notifications sent afterwards.

Your automation tool can't do the two things the work actually needs: loop until a condition holds, and stay alive for days while it waits on a person, an event or a batch window. So the real process lives in a cron job, a spreadsheet and somebody's memory.

Processes that loop and that survive. A loop is a backward edge and a condition, not a special node; resumption is a primitive, not a checkpointing feature bolted on. A run can wait a week, call a child flow, crash, come back, and still report what it did.

The data is in a department nobody integrates with, a database undocumented since 2011, a folder of weekly spreadsheets, and a branch server that legally cannot be copied to a cloud. Every project starts by proposing to move all of it somewhere central, and that project never finishes.

A fabric that makes each of those addressable from one place without moving, rewriting or replacing any of it. A plugin per handle, one wire protocol, and the resource arrives as a row with a name and a type. Then the process gets drawn across it.

Posture is spread across four consoles that each tell you a different version of the truth. A finding arrives with a severity and no answer to the only question that matters: what does this thing drag with it — the service on it, the database it talks to, the on-call team.

A nervous system rather than another console. An EDR agent on every resource turns the fleet into a live database, so a host's state is a SQL query away when you ask it. Senses return raw frames with no opinions and no stored secrets; correlation, enrichment and reasoning happen in flows; actions run only on edges somebody drew.

Before every audit somebody rebuilds the evidence by hand from screenshots and email threads. The control you need isn't in your vendor's product, so you write a requirement, wait for a slot, review a build that approximates it, discover the threshold was wrong, and start again.

An authoring substrate for governed data: records that come in, cases somebody has to act on, a flow per control, and the execution record of each run as the evidence. A catalog governs the description of data; a flow governs its use — each node reaches one resource under the credential declared on it, so composing the flow is composing the access.

Your agent answers confidently from a nightly export, and stale context is worse than no context because it's confidently wrong. Meanwhile every new process starts its context work from scratch, because the last one's lives in a prompt file.

Two tiers. An ambient organisation brain where the data is analysed, vectored and tagged over time — itself a durable flow on a schedule, so it survives crashes and keeps current. Then query-nodes that pull the relevant slice into a process's context at the moment a decision needs it, scoped, not all of it.

The cloud-hosted compliance product wants to hold your evidence. The cloud AI vendor wants your decisions to pass through their account. Your regulator, your board or your country's law says no, and the whole modernisation stalls on a procurement question nobody can answer.

The same stack, inside the building. A single-container appliance, your own Postgres, local or self-hosted models where policy requires it, and providers behind one interface so the choice stays yours. A plugin per branch reporting to a core the data has to stay in.

The integration you need doesn't exist, or it exists and nothing in your stack can reach it. And the machine it runs on is somewhere the platform can't get to.

A capability of one system published as a node, in Go, Python or Node over one wire protocol. For hosts nothing can reach, Legate is a plugin node that is itself an agent — handed an instruction rather than a script, workspace-jailed, shell opt-in, publishing that host's capabilities as its own MCP server.

You've looked at n8n or Zapier or Dify and had the thought everyone has: I could build that. Or you bought one and hit the wall — the canvas is somebody else's product, your vocabulary doesn't fit their palette, your data sits in their cloud, and the thing you most need is to wait four days for a person and carry on.

FloMorphic is one product on this runtime, not its privileged tenant — the engine reserves nothing for it. So you can build a peer, not just something downstream. The canvas isn't the hard part; the durable, cyclic, resumable engine underneath is, and it already exists. You bring the canvas, your data, and a compiler hook: one function mapping your node types onto runtime primitives, and the only place your vocabulary lives.