Build robot skills with the same blocks as Nodofi Flow, then let the Agentic AI use them — "go forward half a meter, then dance" — from Studio or running on the robot itself. Watch them drive a simulated robot beside the canvas, wire real parts with automatic pin assignment, then press Start to run the exact same program on your robot — or Deploy it so the robot runs it on its own, from boot.
The same program runs in the simulator and on the robot: Studio sends the blocks, the hardware and its own engine together, so what you saw is what the robot does.
Explorer → New Robot. Start from the line-follower sample or an empty canvas.
~30 secondsWhen started, Every 50 ms, read sensors, decide, Drive. Variables keep state between ticks.
~5 minutesPress Start: the robot drives the world beside the canvas while wires show live values.
secondsPick a starter kit or boards and parts in the Hardware tab; pins are assigned and checked for you.
~2 minutesRun on → your robot, then Start (live, tethered) or Deploy (runs on its own, starts at boot).
one clickRobot projects keep running. Trigger blocks start everything wired after them, again and again, and every Flow block (math, logic, text, lists, HTTP, security, your own code) works alongside these.
| Group | Blocks |
|---|---|
| Events & memory | When started (once), Every N ms, When sensor… (becomes true, changes, goes below/above a value), Set variable, Get variable |
| Robot | Drive (left/right −100…100), Drive (speed & turn), Stop motors, LED, Say, Distance sensor, Line sensors (left/center/right and a −1…1 position), Bumper, Compass, Wheel odometer, Motor, Servo, Switch on / off, Button, Analog input, Encoder, Stepper, Temperature & humidity, Joystick, Show on screen, Color sensor, Read part |
| Camera & vision | Find color, Motion in view, Read QR code, Take photo, Light level |
| My hardware | Every part you add in the Hardware tab appears in the palette as a ready-made block set to that part. Rename a part and its blocks follow. |
A two-wheeled, differential-drive robot with every part you add simulated — test behaviors in seconds, without batteries, cables or a robot falling off the table.
The chosen world is saved with the project.
Run at 0.5×, 1×, 2× or 4×. Drag the robot to move it, scroll to turn it, and push the balls around mid-run to test edge cases.
Drive motors move the robot; distance, line, color, bumper, compass and encoders read the world. Buttons and PIR/hall/flame sensors get a hold-to-trigger button, analog sensors a slider, the joystick two sliders, climate sensors temperature and humidity sliders; servos, steppers, screens and relays show their state.
The simulator renders a first-person camera view with colored balls, QR-code signs and obstacles. The vision blocks use one piece of code everywhere — the robot gets a copy of Studio's own vision code — so the simulator and a real camera give the same answers.
Red, orange, yellow, green, cyan, blue, purple, pink, white or black: x, y and size fire when it's in view. Steer toward a ball in a few blocks.
Read a QR sign's text to choose a route; Motion in view reports whether and how much the picture changed.
Raspberry Pi Camera (rpicam-vid / libcamera-vid) or a USB webcam (ffmpeg on Linux, macOS or Windows). Take photo captures a picture; Light level reads brightness.
A Robot project has two tabs: Behavior (the blocks) and Hardware (what the robot is made of). Every board comes with its real pin map — PWM, analog, I²C, interrupt, input-only, serial and boot pins, logic voltage and analog range.
Raspberry Pi 5, 4 Model B, 400, Compute Module 4, 3 Model B+, 3 Model B, 3 Model A+, Zero 2 W, Zero W; NVIDIA Jetson Nano and Orin Nano; BeagleBone Black; any board with a Pi-style 40-pin header (Orange Pi, Rock Pi, Banana Pi…); or a PC / laptop on Windows, macOS or Linux.
Arduino Uno R3, Uno R4, Nano, Nano Every, Leonardo, Micro, Mega 2560, Due; ESP32 DevKit, ESP32-S3, ESP8266 NodeMCU; Raspberry Pi Pico / Pico W / Pico 2; Teensy 4.0 / 4.1 — driven over Firmata.
| Motors | DC motor on a 3-pin (L298N / TB6612) or 2-pin driver (DRV8833 / L9110S), continuous-rotation servo, servo (SG90 / MG996R), stepper on ULN2003 or A4988 / DRV8825, brushless motor (ESC) |
| Distance & line | Ultrasonic HC-SR04, Sharp IR distance, VL53L0X laser ToF, 3- and 5-channel line sensors, single IR line/edge sensor, TCS34725 color sensor |
| Motion & position | Bump switch, limit switch, MPU-6050 IMU, BNO055 orientation, QMC5883L / HMC5883L compass, wheel encoder |
| Environment | DHT11 / DHT22, BME280, light (LDR), sound level, soil moisture, gas (MQ-2 / MQ-135), PIR motion, hall-effect, flame |
| Inputs | Push button, touch pad, potentiometer, joystick, rotary encoder |
| Outputs & displays | LED, RGB LED, NeoPixel strip, buzzer, relay, laser module, vibration motor, 16×2 LCD, SSD1306 OLED, TM1637 7-segment |
| Cameras | Raspberry Pi Camera, USB webcam |
Raspberry Pi + Arduino Uno, Raspberry Pi only, or PC / laptop + Arduino Uno. Part names match across kits, so your blocks keep working when you switch.
Adding a part wires it to free pins that can do the job: precise-timing parts (ultrasonic, encoders) on the computer's own pins, everything else on the USB board first. Change any pin from a list showing what each pin can do.
Shared pins, pins that can't do PWM, analog or I²C, I²C address clashes, 5 V signals into a 3.3 V board, outputs on input-only pins, encoders off interrupt pins, ESP32 boot pins, missing drive wheels and more — listed above a wiring diagram.
Run on in the toolbar picks where Start runs: the simulator, or a robot you've paired.
Studio (browser) ── Start / Deploy / STOP ──▶ relay ──▶ Robot Agent ──▶ GPIO (pigpio / libgpiod)
◀────────── live block states, wire values, sensor readings ──┘ └──▶ USB board (Firmata)Live block states, wire values and logs stream back to the canvas, and the simulator column shows the robot's own readings. Studio sends a heartbeat every second; close the tab or lose Wi-Fi and the robot stops itself within seconds.
Saves the program on the robot. It runs on its own with no Studio open, and starts again whenever the agent starts — at boot, as a system service. Undeploy removes it.
The robot joins the relay under a name, so it needs no public address or open port. Pair it once with its key; the key stays in your browser, never in the project.
A small Node.js program that runs on the robot's own operating system — Raspberry Pi OS, Jetson Linux, any Linux board, or a PC — and owns its hardware.
cd robot-agent npm install # also tries the optional hardware libraries cp .env.example .env # set RELAY_URL and a unique ROBOT_NAME npm start # prints the robot's name and its pairing key # Start at boot, so a deployed program starts with the robot: sudo systemctl enable --now nodofi-robot
| Board | Library | What it drives |
|---|---|---|
| Raspberry Pi 1–4, Zero 2 W | pigpio | Digital, hardware and software PWM, servo pulses, microsecond timing (ultrasonic, encoders) |
| Raspberry Pi 5, Jetson, BeagleBone, other Linux | node-libgpiod | Digital in/out; put motors, servos and analog parts on a USB board |
| I²C on a Linux board | i2c-bus | Every I²C part: MPU-6050, BNO055, compass, BME280, VL53L0X, TCS34725, LCD, OLED (I²C also works on a USB board) |
| Arduino / ESP32 / Pico / Teensy on USB | firmata, serialport | Motors, servos, analog sensors — upload StandardFirmata once; the port is found automatically |
The Robot panel's Check asks the robot what it is and lists any part that is simulator-only on it. A missing hardware library means those pins are simulated, and Studio tells you before the run. HARDWARE=mock tries everything without touching a pin.
The program arrives with Studio's own engine, so the robot behaves like the simulator. The agent's tests run the engine, every part driver against a recording mock board, and the whole agent over a local relay.
The program runs in a child process while the agent owns the hardware. Stopped, crashed, hung, killed, heartbeat lost or shutting down — every motor stops and every output switches off.
STOP is on the toolbar in every Robot project and cuts all motors, buzzers and relays at once, in the simulator and on the robot.
A live run stops by itself if Studio goes away (default 3 seconds without a heartbeat).
Tell the robot what to do in plain words. The Agentic AI runs your tested Robot projects as skills — from Studio, or on the robot itself — and never sends motor values of its own.
"Go forward half a meter, then dance once"
│
▼
Planner (gemma4 on Ollama) ── sees your skills: name, description, inputs (cm 1–100, required)
│ {"tool":"robot.skill","args":{"skill":"Forward","inputs":{"cm":50}}}
▼
Forward runs on the Simulator or the robot ── stops at 50 cm, reports "Traveled 50 cm"
│
▼
Next step: "Spinning dance" … then "mission complete", with a step-by-step logEach Robot project is a skill the AI picks by its name and description: "Follow line", "Find red ball", "Return to dock". You test every skill in the simulator first, so everything the AI can make the robot do has been tested.
An Agent input block turns "Forward" into "forward 37 cm". Min and max are enforced inside the program on the robot; a value the AI leaves out stops the step instead of guessing; units are converted ("half a meter" → 50 cm).
Only robots you allow; you confirm before a real robot moves; a time limit per skill; at most three skills per goal; STOP always wins.
Send a robot a mission and the skills it may use, and it works on it on its own — planning each step, running a skill, reading what happened — with Studio closed.
gemma4 on a Jetson or Raspberry Pi 5) — keeps working with no network.A Studio robot can join Persona's Drone Operations companion as a ground vehicle: register it in Persona's Fleet tab, paste two values into the robot's settings, and it reports in.
Heading, front distance and speed every couple of seconds, plus photos and soil readings on request.
Pause, abort and emergency stop, and Manual Control with the sticks — speed-capped, stopping by itself if the stream pauses.
Every command from Persona is signed with the vehicle's token and must be fresh; anything else on the relay is ignored.
The HTTP request block works in Robot projects: fetch a schedule, a weather reading or a command, and act on it.
Code blocks and My blocks work in robots too — package a PID controller or a state machine once and reuse it everywhere.
Build the services around your robot — dashboards, agent tools, payments — with Nodofi Flow, on the same relay as the robot.
| You want to | You need |
|---|---|
| Program and simulate | A browser and a Studio account. No robot needed. |
| Run on a real robot | A Raspberry Pi (3 or newer, 64-bit OS), Jetson, Linux board or PC with Node.js 18+, the Robot Agent, and a relay. |
| Motors and analog sensors | A motor driver and, for analog or many motors, an Arduino / ESP32 / Pico / Teensy running StandardFirmata. |
| Camera vision | A Raspberry Pi Camera or a USB webcam. |
| Let the AI drive it | A planner: Ollama with gemma4 behind a worker on the relay, or on the robot itself for missions. Skills with clear names, descriptions and Agent inputs. |
| Join a Persona fleet | A vehicle registered in Persona's Fleet tab (Remote, Ground) and its two values in the robot's settings. |
Open Studio, start the line-follower sample, and watch it drive — then put it on a real robot.
Open Studio Explore Nodofi Flow