NodeFox
Technology & architecture

The graph is
the program.

NodeFox executes structured workflows through a Rust core. Data routes, activation conditions and typed operations define how work progresses. The host connects that execution to models, systems, code and people.

Deterministic orchestration does not make AI responses deterministic. It makes the surrounding computation and control flow explicit.

Execution architectureConceptual view
Visual graph
Workflow DSL
AI assistance
Operator Apps
Define or invoke
Executable graph definition
Submit

Rust execution core

State · dependencies · scheduling

WebAssembly in browserNative host implementation
Request ⇄ response

Environment-specific host & worker interfaces

AICodeFiles / APIsMCPHuman input
Configured services and business systems

Shared execution model; different host capabilities. External providers and connected systems may receive data.

01 / Executable structure

Data movement and execution control are different relationships.

A route can deliver information to an input. An activation relationship controls eligibility to run. Node types, required inputs and configured flags determine what happens next.

Data route

Carries a value between output and input slots.

Activation route

Signals an execution condition; it does not transport the data payload.

Explore a dependencyInteractive explanation · no external requests

Contract lookup

Ready

Receipt lookup

Ready

Compare records

Waiting · both inputs required

Data routes carry the two reference records.

Submit the graph

The runtime receives the graph and inputs. Required data and activation conditions determine which operations are eligible.

submit(graph, inputs)

Two independent lookups have the inputs they need.

Discrete steps, explicit progress

The documented execution model routes values, evaluates readiness, executes eligible work and cleans up step state. Independent work can proceed together; dependent work advances when its requirements are satisfied.

This is a BSP-style model: a useful way to reason about steps and synchronization, not a claim that NodeFox is a distributed BSP compute cluster.

Structure around intelligence

A Conversation node may use a model and tools for a bounded task. The larger workflow still declares its inputs, checks, branches and downstream actions. A model response does not replace the process definition.

Branches, repeated steps and synchronization

Decision variants route by conditions or solicit human input. Required inputs, activation conditions, input retention and delays shape repeated execution. Wait nodes express configured waiting conditions; a Network node invokes another network.

Concurrent external work is not a claim of multithreaded JavaScript or guaranteed lower latency. The graph’s dependencies and the services it calls determine useful concurrency.

02 / Mediated external effects

The engine coordinates. The host acts.

A workflow needs to interact with the world without hiding those interactions inside its scheduler. NodeFox separates runtime commands and state transitions from the capabilities that fulfill external requests.
  1. 01

    Request

    The runtime emits a typed request for work it cannot complete internally.

  2. 02

    Dispatch

    The host routes it to a model, code runner, file/API capability or human input handler.

  3. 03

    Respond

    The result is associated with the request and returned through the host boundary.

  4. 04

    Resume

    The runtime consumes the response, updates execution state and determines what can happen next.

An explicit integration boundary

The browser bridge uses submit, resume, stop and failure commands through a runtime port. Host handlers fulfill requests and relay execution events. This separation creates a concrete interface for adapters, testing and inspection.

Control still needs configuration

Credentials, tool access, approval paths and write permissions belong to the deployment and workflow design. The boundary does not imply exactly-once external writes, universal sandboxing or automatic rollback.

03 / Rust, WebAssembly and data

A focused core. Deliberate data ownership.

Rust implements execution state and control. WebAssembly brings that core into the browser; a native host connects the execution model to a different operating environment.

The data representation uses reference-counted Arc values for text, binary and JSON payloads. Text and binary slices can refer to an existing allocation. Sharing these values avoids a deep payload copy for each cloned reference inside the Rust representation.

Share a value inside the Rust core
Arc<JSON value>

One shared allocation

Branch A · reference
Branch B · reference

Cloning a reference is different from copying its payload. Serialization and host transfers can still allocate and copy.

What “lightweight” can responsibly mean

The orchestration core is distinct from the full application, model services and host dependencies. Rust ownership and shared allocations are concrete design choices; Rust alone does not establish superiority over another runtime.

We do not publish a binary-size, startup-time or throughput number here. A useful comparison would need a pinned build, workload, host environment and repeatable measurement.

Where copying still happens

Reference cloning is not the same as zero-copy transport. String conversion, JSON serialization and binary materialization can allocate. Moving data across JavaScript/WASM, worker, process or network boundaries can require additional copies.

Shared payloads help within the core; they do not remove the cost of external services or large serialized results.

04 / Typed building blocks

Ten node families. Composable behavior.

Each family has a defined role, configuration and supported variants. Their combinations express the process; the graph is not a collection of interchangeable AI prompts.

Buffer

Hold, accumulate or combine inputs.

Reader

Retrieve files or configured API data.

Writer

Write to a configured destination.

Conversation

Invoke an AI model with context and tools.

Decision

Route by rules or request a human choice.

Data

Select and structure values.

Code

Run custom JavaScript logic.

Global

Read and write scoped named values.

Wait

Wait for configured conditions.

Network

Invoke a reusable subnetwork.

Shapes and colors follow the NodeFox product. Individual variants, external providers and tools have their own configuration requirements.

Open the node reference
05 / Authoring and composition

Different authoring tools. One explicit workflow.

Visual editing, the JavaScript-based workflow DSL and AI-assisted changes produce structured workspace assets. Review the graph that will execute, regardless of how it was created.
Script Console · illustrative authoring example
const net = new Network("Review input");
net.Buffer("input").label("Review material");
net.Conversation("review")
  .Claude()
  .system("Identify terms needing human review.");
net.Route().from("input").to("review");
bundle.network(net);

Review material

Model review

This script creates a Buffer, a Conversation and their data route. Import the assets, configure the model credentials and supply input before running.

Authoring the graph does not execute it. This example organizes review material; it does not authorize a contract or replace human judgment.

Reuse a network

A Network node calls another network with named input and output mappings. Reuse a review, extraction or validation component inside a larger process.

Composition boundaries

Configure the child network and its input/output variables explicitly. Named mappings define the interface. Reuse is not a guarantee of distributed execution, identical host access or automatic version migration.

Use AI to help author

AI assistance can propose DSL-based creation and edits, including nodes, routes and configuration. The authoring pipeline evaluates proposed changes and surfaces errors before application.

Review before execution

A valid generated script does not prove that the resulting business process is correct. Inspect the changes, test sample and exception paths, and verify external actions. Reusable patterns provide starting structures, not guaranteed outcomes.

Explore reusable patterns

Give operators an App

Forms map user inputs into a configured network. Automations run configured input sets. Operators can use the process without editing the underlying graph.

From inputs to operation

Configure field validation, named values and the network to invoke. Set credentials, plan access and operating responsibilities separately. A form is an interface to the workflow, not a replacement for its execution rules.

06 / Portable core, specific hosts

Local orchestration is not the same as offline execution.

NodeFox’s browser application runs the Rust/WASM engine through a worker layer. Model calls, connected APIs, authentication and other external services can still require network access and receive data.

Browser execution

The interface submits a graph to the worker/host layer. WebAssembly executes orchestration in the browser. Separate capabilities handle AI, code, files and user interaction.

A live browser session, configured providers and browser access restrictions remain part of the operating model.

Native headless host

The native implementation exposes CLI and service execution, deployment artifacts and run records. Its engine host receives runtime commands and dispatches work through native host capabilities.

Deployment needs a compatible build, runtime access and credentials. Browser-only APIs, file access, MCP configuration and interactive prompts require a separate compatibility review.

07 / Execution visibility

Inspect the work behind the result.

Follow live execution, inspect outputs and investigate where a process stopped. With recording configured, captured runs can be opened in a read-only replay view.

Recorded playback projects captured graph state, steps and available artifacts. It does not rerun the workflow or repeat its external actions. What can be inspected depends on the recording policy and retained data.

Explore product evidence
Actual product footage · 20-second silent excerpt. A sample contract-review network runs model, code and routing steps; execution logs appear alongside the graph. This is a product demonstration, not a customer result.

Live state

What is active, waiting, completed or failed during this run.

Recorded evidence

The captured inputs, outputs and decisions available for later inspection.

Operational recovery

A separate decision about retrying or resuming work, with external side effects considered.

Evaluate the architecture against your workflow.

Bring the systems, data, execution requirements and exceptions. Explore how an explicit workflow could coordinate them—and where the integration work belongs.