Skip to content
Symbiote Engine
Menu

Symbiote Engine Portable graph execution, made observable.

Define a portable graph once. At runtime, registered behavior, cache decisions, lifecycle failures, and execution results stay explicit to the host without binding the graph to a product shell.

How it works

One graph. Every branch stays visible.

Graph data meets registered behavior at runtime. Engine resolves cache identity, chooses reuse or execution, and returns lifecycle failures as node-scoped output.

01 / Graph shape

A graph stays portable until the host supplies behavior.

JSON carries node types, parameters, and connections. The registry maps those types to behavior at runtime, so graph data remains independent of a product shell.

graph.jsoninputtransformoutputregistrygraph.jsoninputtransformoutputregistry
02 / Cache identity

Inputs and parameters become one repeatable identity.

For lifecycle-enabled nodes, the default cache key is exactly JSON.stringify({ i: inputs, p: params }). Execution context reaches execute, but it is not part of that default key.

inputsparams{ i, p }inputsparams{ i, p }
03 / Cache branch

Validation comes first; then the cache chooses the path.

After validation and key resolution, a matching auto-mode entry returns stored output. A miss executes, may post-process the output, and then stores it under the resolved key.

validatereuseexecutepostProcess?storevalidatereuseexecutepostProcess?store
04 / Observable outcome

A lifecycle failure becomes output, not a hidden stop.

Validation, execution, or post-processing errors become node-scoped { _error } output and a structured execution-log record. The traversal loop continues; later nodes still depend on their resolved inputs.

{ _error }execution record{ _error }execution record

Ready to run a graph?

View source on GitHub

Part of the Symbiote stack