NodeFox is live: [https://nodefox.ai]
I built NodeFox around a simple idea:
The network is the agent.
Most AI workflow tools still treat the model call as the center of the system. A prompt becomes the workflow. A chain becomes the architecture. A hidden loop becomes the “agent.” That works for small demos, but it breaks down when workflows need memory, branching, files, APIs, human review, structured outputs, code, or repeatable execution.
NodeFox takes a different approach.
It is a browser-based runtime for building local AI workflows as executable graphs. The graph is not just a diagram of the system. It is the system.
A NodeFox workflow is a network: nodes connected by routes, running across explicit steps. Each node has inputs, outputs, and a role. Routes move values. Activation edges trigger behavior. State, memory, tools, files, schemas, functions, code, and integrations are part of the same executable structure.
That is what I mean by “the network is the agent.”
The agent is not one LLM call. It is not a prompt chain. It is not a webhook sequence. It is the full graph: the way data moves, the way behavior is triggered, the way state is preserved, the way outputs are typed, and the way real systems are touched.
NodeFox gives builders multiple ways to create those networks.
You can build visually on the canvas. You can define networks with the DSL. You can generate runnable networks with AI. Those are separate capabilities, but they work toward the same goal: turning intent into something visible, editable, runnable, and reviewable.
That matters because AI-generated systems should not stay trapped inside text. A generated workflow should become something you can inspect, change, version, debug, and run.
The runtime is built around 10 core nodes:
Conversation, Buffer, Reader, Writer, Decision, Data, Code, Global, Wait, and Network.
Conversation nodes call models. Reader and Writer nodes connect the workflow to files and external data. Decision and Data nodes handle routing, branching, extraction, and structured transformation. Code nodes give you deterministic logic when precision matters. Buffer, Global, and Wait nodes provide memory, state, coordination, and synchronization. Network nodes let workflows call other workflows, so larger systems can be composed from smaller reusable pieces.
One of the most important primitives is the activation edge.
Data routes move values. Activation edges trigger behavior.
That distinction is subtle, but it changes how workflows are structured. Most automation systems blur data flow and control flow. Something happens, a trigger fires, another step runs, and the chain continues. That model is useful, but it can become brittle when AI workflows need to hold context, wait for multiple inputs, pause for review, loop, branch, or coordinate state.
In NodeFox, a node can receive or preserve data separately from the moment it is told to execute. That gives the graph more control. A workflow can keep context loaded, wait for the right condition, coordinate multiple paths, and trigger actions intentionally.
This is especially important for AI systems because LLM calls are not enough by themselves. Useful AI workflows usually need structure around the model: typed JSON, schemas, functions, files, APIs, tools, code, retries, human review, and deterministic execution.
NodeFox is built for that layer.
It runs locally in the browser through a Rust/WASM runtime. It supports typed JSON, schemas, functions, custom nodes, MCP servers, files, APIs, reports, GitHub, team channels, dashboards, integrations, and Git-compatible versioning and diffing.
The versioning piece matters too. If AI workflows are going to become operational systems, they need to be reviewed more like software. Changes should be visible. Networks should be diffable. Teams should be able to understand what changed before something touches real data or real systems.
NodeFox is visual when you want speed and code-friendly when you need precision. You can prototype quickly, but the output is not just a disposable automation. It is a structured executable graph.
The broader thesis is that AI workflows need better structure.
Prompts are powerful, but prompts alone are not architecture. Agents are useful, but black-box loops are hard to inspect. Webhook chains are practical, but they are not enough for stateful AI systems that need branching, memory, typed output, tools, and human review.
NodeFox is my attempt to make that structure visible, local-first, modular, and executable.
The network is the agent.
NodeFox is live now: [https://nodefox.ai]
I’d appreciate feedback from builders working on agents, automation systems, workflow engines, local-first tools, visual programming systems, or AI infrastructure.
Top comments (0)