n8n's canvas was the spark, so we built one for our own actor system. Drag actors and stream stages onto a board, wire them into a pipeline, and it generates the Akka.NET C# and runs it. Then it became something n8n isn't: every node reports how it changed the system's understanding of the task, so the router can learn which nodes to trust. It turned out to be crazy good for running agents.
Categorize fans into claims, authorizations, medical records, member documents, and marketing, each with its own downstream pipeline. Every edge carries a typed message contract.
01 · Substrate
Every node is an Akka.NET actor or Akka.Streams stage, so concurrency, supervision, mailboxes, and streaming backpressure are the substrate, not a plugin. Nodes are fetched live from the running actor system over the VirtualQAEngine API, alongside MCP tools.
02 · Output
A flow is not trapped in a runtime. Generate the C# for the actor system and check it in, or execute the flow adhoc straight from the canvas to watch it run. Export and import the whole design as JSON. No lock-in, no black-box scheduler you can't leave.
03 · Control
IFTTT rule stages apply explicit if-this-then-that logic to each item before the next stage: match a field, then route, tag, drop, or set a property. Control flow is inspectable and versioned, not buried in a prompt. It is business rules as tolerances, right there on the board.
Drag from the sidebar. Actors and tools come from the live system; sources, flows, and sinks are the streaming vocabulary.
n8n asks how fast a node runs. Node Bench asks a different question: how did this node change the system's understanding of reality? A signal tap on each side of a node captures a worldview snapshot before and after, and the difference is the thing we grade.
Worldview snapshot · before
Cognitive diff · what the node did
This node earned its keep: it caught a rollback risk and raised a review flag a fast, cheap node would have missed. That is a signal worth training on.
Fitness score
fitness = correctness + stability + signal_quality + explainability − hallucination_rate − operational_risk − cost
Each node gets a production-readiness score from replayed runs against fixed scenario packs. The router reads fitness at routing time, so the flow prefers the node that has earned the position, not the one that happens to be cheapest.
What gets stored
position → move → outcome
Not raw conversation history. Deterministic, replayable artifacts. That is the training set: it feeds routing heuristics and becomes Mempack™ lineage, so a node's judgment compounds across versions instead of resetting every run.
Orchestration was the start. Measurable, replayable, evolving judgment is why it stuck. It is how our agents run in production, and it is where the routing and Mempack™ work becomes real.