The handful of ideas you need before building anything. No prior experience assumed. If you want a quick definition of a single word instead, the Glossary is faster.
What NodeTool is
A visual way to use AI. Instead of writing code, you place boxes on a page and draw lines between them. Each box does one job, and the lines carry results from one box to the next.
- You can ask instead of place. An agent lives in the app and builds those boxes and lines for you when you describe what you want. What it produces is the same picture you would have drawn, so you can read it and change it.
- It runs on your computer. Models that run locally use your own hardware, and what they produce stays on your disk.
- You bring your own accounts. When a workflow uses an online AI service such as OpenAI, Anthropic, Gemini, FAL, KIE, or Replicate, the request goes straight from your machine to that company and they bill you their normal price. NodeTool adds nothing on top.
- You can mix the two. One workflow can use a local model for one step and an online service for the next.
- It’s open source. Licensed AGPL-3.0. The code we host is the code you can run yourself.
The building blocks
The agent
The agent is the assistant you talk to in the Chats panel. Give it a goal in plain English and it works out the steps, calls tools, and edits your documents: it plans a graph, checks it against the node library, saves it as a workflow, runs it, and tells you what came back.
Two things make it different from a chatbot that writes instructions for you:
- It acts on the document you have open. A workflow, a sketch, a timeline, a storyboard, a script, a mini app. It uses the same actions the interface offers, so you see each change land and can undo it.
- It leaves everything editable. There is no generated artifact you can only regenerate. Whatever it builds, you can open, read, and rewire.
A permission chip on each thread sets how far it may go on its own: propose only, ask before acting, or run everything. See Chat.
Nodes
A node is one box that does one thing.
| Node | What it does | Example |
|---|---|---|
| Image Generator | Turns a description into a picture | “Sunset over mountains” → an image |
| Agent | Works out the steps for a task and carries them out | “Summarize this document” → an organized summary |
| TextToSpeech | Reads text aloud | A blog post → an audio file |
| Filter | Throws away items that don’t match a rule | Keep only the good results |
Every node takes things in on its left side, sends results out its right side, and has settings that appear in the panel on the right when you click it.
Workflows
A workflow is a set of nodes joined by lines. When you run it, your input enters on the left, each node starts as soon as everything it needs has arrived, and results appear on the right as they are produced.
Examples of what a workflow can be:
- A description, into an image model, saved as a file.
- A PDF, split into pieces, filed away, then searched to answer a question.
- A story, turned into character descriptions, then portraits, then a video.
Reach for a workflow when you want to do the same thing repeatedly: produce media, convert files, ask a model something, index documents, or prepare material for one of the other editors below.
Connections
The lines between nodes. Drag from a node’s output on the right to another node’s input on the left. NodeTool checks that the two ends match, so an image output only connects to an input that accepts images and you can’t wire something nonsensical. Hover over a line to see what is passing through it.
Assets
An asset is any file NodeTool stores for you: an image, video, audio clip, PDF, text file, 3D model, or anything else a node can read or write. Assets live in the Asset Explorer and can be used again in any workflow, sketch, timeline, or chat.
Assets are the common currency between the different editors:
- Drag an image asset onto a workflow and it becomes an input.
- Save a workflow’s result as an asset to use later.
- Drag video, audio, or images onto a timeline to become clips.
- Open an image asset in the Sketch Editor to paint on it.
- Group document assets into a collection so an AI can search them.
Sketches
A sketch is an image made of stacked layers, the way Photoshop or GIMP work. Use it to paint, hide parts of an image, retouch, combine images, or have AI generate a layer in place.
A sketch sits between editing by hand and automating with a workflow:
- Start from a blank page or an image you already have.
- Paint, or build the picture up in layers.
- Attach a layer to an image workflow so it regenerates when its inputs change.
- Flatten the sketch back into an ordinary image asset.
- Use that image in a workflow or a timeline.
Timelines
A timeline arranges media over time on parallel tracks, the way a video editor does. It holds video, audio, still images, overlays, and clips generated by AI.
Timelines are where results become finished media:
- Drag existing assets onto tracks.
- Add a clip that is produced by a workflow.
- Trim, split, reorder, and stack clips.
- Regenerate a generated clip after you change its settings.
- Export the whole sequence as a video asset.
Agent nodes
The agent above builds workflows. An Agent node is an agent placed inside one: it takes a goal written in plain English, works out the steps itself, and uses tools such as web search, file access, or running code to get there. Use one when a step of your pipeline is describable but not scriptable. A normal node does one fixed thing; an Agent node decides what to do.
Mini-Apps
A Mini-App is a form or dashboard built on top of one or more workflows, with the nodes and lines hidden. Create and open them from the Apps panel. Give one to someone who should never have to look at a canvas. See Mini Apps.
How everything fits together
Most work in NodeTool follows one loop:
- Get some material. Upload files, produce them with a workflow, paint a sketch, or export a timeline. All of it becomes assets.
- Build a workflow around them. It reads assets, calls models, converts media, and writes new assets.
- Polish the result in the right editor. Sketches for still images, timelines for anything with a duration.
- Feed the polished result back in. A flattened sketch or an exported video is just another asset a workflow can read.
- Share it. Keep the workflow to run again, wrap it as a Mini-App, or publish the finished file.
The editors are separate because painting an image and cutting a video are different problems, but they share one pool of assets and one set of AI services. The agent works in every one of them, so any step of the loop is something you can do by hand or ask for.
Worked example: a short product video
- Upload your product photos as assets.
- Run a workflow that writes the copy, makes background images, and records a voiceover.
- Open the main photo in a sketch to touch it up and cut out the background.
- Drag the image, the voiceover, and the generated clips onto a timeline.
- Attach one clip to an image-to-video workflow and regenerate it until it looks right.
- Export the timeline as your finished video.
Models
A model is a trained AI you call from a node. You don’t train it; you use it.
| Kind of model | Produces | Used for |
|---|---|---|
| Image | Pictures | Posters, concept art, mockups |
| Video | Clips | Animation, motion |
| Audio | Sound | Narration, music, effects |
| Text | Words | Scripts, summaries, analysis |
On your machine, or online
| On your machine | Online service | |
|---|---|---|
| Cost | Free once downloaded | The provider’s price, billed to your account |
| Where it runs | Your computer | Their servers |
| Speed | Depends on your hardware | Depends on theirs |
| Internet | Works offline | Required |
| To set up | Download 4-20 GB per model | Paste an API key |
You can mix them and choose per node, so an expensive online model can handle the one step that needs it while the rest runs locally.
Words you’ll see
| Term | What it means |
|---|---|
| Workflow | Nodes joined by lines |
| Node | One box that does one job |
| Edge / connection | A line carrying data between nodes |
| Input / output | Where data enters and leaves a node |
| Preview | A node that displays whatever reaches it, for checking your work |
| Run | Execute the workflow |
| Asset | A stored file used by workflows, sketches, timelines, chats, or collections |
| Sketch | A layered image document for painting, masking, and combining |
| Timeline | Tracks for arranging video, audio, and images over time |
| Clip | One piece of media placed on a timeline track |
| Generated clip / layer | A clip or layer produced by a workflow instead of imported |
| Stale | A generated result whose settings changed since it was last produced |
| Agent | The assistant you ask for changes, and the node that plans its own steps |
| Permission mode | How far the agent may act without asking: Plan, Default, or Auto |
| Model | The trained AI a node calls |
| Provider | Whoever runs the model: your own machine, OpenAI, FAL, and so on |
What happens when you press Run
On Ctrl/⌘ + Enter:
- NodeTool reads the lines to work out which node depends on which.
- Each node starts the moment its inputs have arrived. Nodes that don’t depend on each other run at the same time.
- Results appear in preview and output nodes while they are still being produced, rather than only at the end.
Here the Agent goes first. Image Generator and Text Writer both wait only on the Agent, so once it finishes they run side by side.
Data always flows one way and a workflow can never loop back on itself. That restriction is what lets NodeTool figure out the running order for you, so you never specify it.
If you write code
Everything above is also available as a TypeScript API, so you can build and run the same workflows from code.
| Piece | What it is |
|---|---|
| Graph | Nodes plus connections. Build one with workflow(...), run it with run(...) or runGraph(...) (@nodetool-ai/dsl, packages/dsl/src/core.ts). |
| DSL | The TypeScript DSL (@nodetool-ai/dsl), typed factory functions for building graphs in code. |
| WorkflowRunner | Schedules the nodes, manages the GPU, streams progress back. |
| ProcessingContext | Everything a running node can reach: user, auth, assets, cache (@nodetool-ai/runtime). |
How a node type is found
A saved workflow refers to nodes by a type string (package.Namespace.Class).
The runner resolves it in this order:
- The in-memory registry, with and without a trailing
Node - A dynamic import of the type path
- The installed packages registry
- A fallback match on class name
That is why loading a graph doesn’t require importing every node module first.
See the Developer Guide and Custom Nodes.
Next
- Quick Start — run something in 10 minutes
- Chat — the agent, its tools, and permission modes
- Glossary — single-word definitions
- Workflow Editor
- Asset Management
- Sketch Editor
- Video Editor
- Models & Providers
- Cookbook