Wire blocks together in your browser, press Run to watch every value move, and publish the result as a live service. An Agentic AI can pick it up and use it as a tool right away — no servers to set up, no SDK to learn, no deploy pipeline.
Every step happens in Nodofi Studio, in the browser. Nothing to install to build and test; publishing sends the Flow to an NVM Service Manager you (or anyone you trust) run.
Explorer → New Flow. Start empty or from the sample (a product list filtered, sorted, totalled and checked against a budget).
~30 secondsDrop blocks from the palette and drag from an output dot to an input dot. Settings live in the right panel.
~2 minutesPress Run (Ctrl/⌘+Enter). Every wire shows the value it carried; every block shows ✓, × or skipped and its time.
secondsPublish compiles the Flow into one service and sends it to your Service Manager. It is live at the project's permanent UID.
~1 minuteAsk Studio's Agentic AI, call it from another Flow, an app, a web page, or any program on the relay.
immediatelyStudio's Agentic AI pane turns your saved Flow projects into tools. Describe a goal in plain language; the planner chooses a Flow, fills in its input, runs it, reads the result and answers — with a full trace of every step.
Goal: "Generate me a QR code for https://beezifi.net"
│
▼
Planner (JozieAI, on your own Ollama model) ── sees every Flow: name, description, blocks, input fields
│ {"tool":"studio.flow","args":{"flow":"Quick QR","input":{"text":"https://beezifi.net"}}}
▼
Quick QR Flow runs in Studio's sandbox ── Service input → Call QRCodeGen → Flow UI component → Service output
│ {"html":"<img src=…>","css":"…"}
▼
Answer + the QR code shown in the pane, plus a step-by-step traceNo tool schema to write. The planner is given each Flow's name, description, block list and the fields its Service input blocks read, so a clear name and input field is all a Flow needs to be usable.
Type use the Quick QR flow to answer: https://beezifi.net and the Flow runs directly — instant, and it works even when no planner model is online.
A Flow that replies with {html, css} (a Flow UI component) or an image is shown as a picture under the answer, in a locked-down frame with no scripts. Text answers show as text.
Local models make mistakes, so the runner repairs broken JSON, accepts a Flow's name where a tool name was expected, fits the input to the Flow's input field, stops on repeated calls and returns the Flow's result instead of failing.
Robot projects become robot skills the agent can run on the simulator or a robot you allow — with inputs ("forward 37 cm"), your approval before a real robot moves, and time limits. See Nodofi Robotics.
Every step's thought, tool calls and results are listed in the trace. Optionally include the open file, selection and errors as context. Stop cancels a run at once; runs are capped at 1–12 steps.
| Do this | Why |
|---|---|
| Give it a clear name and description | The planner picks tools by name and description: Quick QR or Current weather beats Flow 3. |
| Read named fields | Set each Service input's field (text, question, city). The planner sees these names and fills them in. |
| Reply with an answer | A Service output with field answer, or plain text, becomes the agent's answer directly. HTML and images are displayed. |
| Fetch live data for live questions | A language model's knowledge stops at its training date. For "current" questions, use an HTTP request or a relay worker so the answer comes from the source. |
| Test with the test request | Click the empty canvas and set the Flow's test request, e.g. {"text":"Ada"}; Run uses it as the caller's request. |
Each of these is a handful of blocks. Build it, run it, publish it, and your agent, app or page can use it the same day.
Service input (text) → Call flow / service (QRCodeGen) → Flow UI component (<img src="{{reply}}">) → Service output. Ask the agent for a QR code and see it in the pane.
Service input (question) → HTTP request to a CORS-enabled API → Get field → Template → Service output (answer). Live data for the agent, every time.
Service input (text) → Call relay worker (UtilityServices, ollama.prompt) → Service output. Private summaries on your own GPU.
Service input (amount) → MooChedda Create invoice → Service output (paymentUrl). A second Flow checks Invoice status and fires paid before you deliver.
Service input → Verify HMAC → If → Validate value → your logic → Service output. Rejects anything not signed with your secret.
A Flow that returns a list; a data-flow element on your page renders it as a card per item and refreshes every 30 seconds.
Every block is plain JavaScript you can open and change. The full reference, with pins, settings, examples and code for each block, is in the Flow block reference.
| Group | Blocks |
|---|---|
| Values | Number, Text, JSON data, Current time, Random number |
| Math & logic | Math, Formula, Compare, If, Merge |
| Text | Template, Join text, Split text |
| Lists & objects | Map list, Filter list, Sort list, Count / Sum, Get field, Make object |
| Web & time | HTTP request, Parse JSON, Wait |
| Output | Display, Table, Log |
| Service | Service input, Service output, Call flow / service, Call relay worker |
| Security | Validate value, Clean text, Hash, HMAC sign, Verify HMAC, Secure random token, Encrypt value, Decrypt value, Hash password, Verify password, Redact fields, Allowlist check |
| MooChedda | Create invoice, Invoice status, Get invoice, Verify payment, Pay invoice (signed), Send signed transfer, Wallet balance, Transaction history, Create wallet, Token prices, List tokens, Deposit instructions, Merchant profile |
| NodoCloudDB | Get row, Query rows, Add row, Set row, Update row, Delete row |
| Custom | Code block, Flow UI component — plus My blocks, your own saved blocks |
| Robot projects | Events & memory, Robot hardware, Camera & vision — see Nodofi Robotics |
Run executes the whole Flow once. A block starts as soon as everything wired into it has finished, so independent branches run in parallel.
Each wire shows the value it carried, each block its status and time. Errors appear in the Output panel with the failing line.
A block that leaves an output out of its result doesn't fire it — that's how If sends a value down one branch and Merge joins them again.
Stop ends a run at once, even an endless loop. Wiring blocks in a circle is refused with the loop named.
Write any value, a table of rows or a log line to the Output panel while you build; in a published Flow they go to the service's log.
Service input blocks read the Flow's test request in Studio, and the Output panel shows the exact reply a caller would get.
Full undo history; export a Flow as PNG, SVG, JSON or the compiled service file (.js) to read or run elsewhere.
Publish compiles what you saved — the blocks plus the same engine Studio uses — into one service file and sends it to your NVM Service Manager. A published Flow behaves exactly like Run: each request runs it once.
Every Flow is reachable at its project UID, which never changes. Optionally register a friendly name with the relay's name service (NVMDNS); Call blocks accept the name in place of the UID.
The publish dialog sends your test request to the live service and shows the reply, and gives you ready-to-copy code for apps.
<script src="https://nodofi.com/nodofi.js"></script> <script> NodoRequestAsync('<flow uid>', { functionType: 'async', text: 'https://beezifi.net' }, 'https://relay.nodofi.com') .then(reply => console.log(reply)); // whatever the Flow's Service output blocks send back </script>
// Flow: a "Call flow / service" block with the UID or registered name. // NVM service: const reply = await NodoRequestAsync('<flow uid>', { functionType: 'async', question: 'What happened?' });
In Studio's page preview, turn on Edit, click an element and pick a Flow in its Data (flow) section. Studio writes the attributes and adds the Flows runtime to the page for you.
<div data-flow="95d459c7bc254b05beb86715e42ba481" the Flow's UID (or registered name) data-flow-input='{"q": "{{#search}}"}' what its Service input blocks receive data-flow-render="template" auto | text | html | json | list | table | template data-flow-trigger="#search" load, click, a selector, or none data-flow-refresh="30"> reload every 30 seconds <div class="card"><h3>{{name}}</h3><p>{{price}} USDC</p></div> </div>
The element's own content is the design: {{field}} placeholders are filled (escaped) and a list reply repeats it once per item.
{{#id}} reads another element's value and {{query.x}} a URL parameter, so a search box can drive a Flow.
nf-loading / nf-loaded / nf-error classes, flowload / flowerror events, and NodofiFlows.call() from JavaScript.
Every block is an async function run(inputs, settings, ctx) that returns one property per output.
Double-click any block to edit its code and its pins in a full code editor.
async function run({ price, qty }, settings, ctx) {
ctx.log('pricing', price, qty); // Output panel (or the service log once published)
return { total: price * qty }; // one property per output pin
}
An empty block for your own logic, with whatever pins you need.
Select a block → Save to My blocks to reuse it, with its pins, settings and code, in every Flow. Saved to your account.
Design an HTML template visually; each {{placeholder}} becomes an input pin and the block outputs html and css for pages and agents to show.
The Call relay worker block talks to any program that joined the relay under a name — on your laptop, a server or a Raspberry Pi — with no open ports and no public address.
A ready-made worker you run yourself, for Flows that need more than the browser offers:
Your own AI model (Ollama, e.g. gemma4) on the relay: the planner behind the Agentic AI, the Assistant and robot missions, and a prompt tool for your Flows. Download · Docs
Anything that speaks the relay's simple {recp, sender, data} messages can be a Flow tool: a database, a printer, a GPU box, a robot. The Flow block sends data, the worker replies, the reply flows on.
The MooChedda blocks create invoices, check them, verify payments and read wallets in USDC — with zero transfer fees and settlement in about a second. No block ever holds a private key: customers pay on MooChedda's own page or sign in their own wallet.
Service input (amount) ──▶ Create invoice ── paymentUrl ──▶ Service output send the customer here
Service input (invoiceId) ──▶ Invoice status ── paid ──▶ fulfill the order
└─ notPaid ──▶ "still waiting"Block code never runs in the Studio page: it runs in a Web Worker inside a sandboxed iframe, so it can't use your session, cookies or the Studio API, and can't freeze the editor.
Validate and clean input, hash, sign and verify HMACs, encrypt and decrypt, hash and verify passwords, redact secrets before logging, and allowlist roles — all as blocks.
HTML a Flow returns to the Agentic pane is shown in a sandboxed frame with scripts disabled.
| You want to | You need |
|---|---|
| Build and run Flows | A browser and a Studio account. That's all. |
| Use Flows from Agentic AI | An AI Worker on the relay next to Ollama (for example gemma4), or Agent Starter. The use the X flow to answer: … shortcut needs neither. |
| Publish Flows as services | An NVM Service Manager on any computer, joined to a relay. |
| Local AI and utilities in Flows | UtilityServices, optionally with Ollama. |
| Payments | A free MooChedda wallet address. |
Open Studio, create a Flow, and have an AI agent using it before your coffee cools.
Open Studio Explore Nodofi Robotics