Nodes
A node is a machine you add to a workspace: your laptop, a Raspberry Pi in the lab, a server in your own rack, a Windows PC in the office. A scene you add it to can work on it by name, and a scene told to run on it runs its computer there. By default scenes run on machines we operate; a node is how a workspace brings its own.
One command adds a machine
On the machine, run the installer: curl -fsSL https://daslab.run/node | sh on Linux and macOS, irm https://daslab.run/node.ps1 | iex in PowerShell on Windows. It prints a pairing code. Open daslab.run/pair on your phone, type the code, pick the workspace and what the machine is allowed to do. It connects outward to Daslab; nothing opens on your side, no port, no DNS record, no firewall rule. Within seconds it appears in the workspace as a tile. daslab node leave takes it out again.
One machine can sit in several workspaces: pair it again and pick another. It gets a tile in each, with its own choices in each.
Three things describe a node
Every node's tile says three things, and the agent reads the same tile.
| On the tile | What it means | Who sets it |
|---|---|---|
| Offers | what the machine has | the machine, reading its own hardware |
| Allowed | what it is allowed to do | you, when you pair it |
| Publishes | what on its network and disk the workspace can reach | you, on the machine |
A tool shows up in a scene when the machine both offers it and is allowed to use it. What it publishes is everything the workspace can reach through it.
What each machine can do
The three things above land differently on different machines. This is what each kind offers out of the box.
| Capability | Pi · Linux box | Mac | Jetson · GPU box | Windows PC |
|---|---|---|---|---|
| Run the scene's computer (shell, build, files) | ✓ | ✓ | ✓ | ✓ |
| Reach your LAN, publish a database or service | ✓ | ✓ | ✓ | ✓ |
| Publish a folder or NAS share | ✓ | ✓ | ✓ | ✓ |
| Browse from your own address and logins | ✓ | ✓ | ✓ | ✓ |
| Cameras and microphones plugged in | ✓ | ✓ | ||
| ESP32 boards and sensors | ✓ | ✓ | ✓ | ✓ |
| Stage lights | ✓ | ✓ | ||
| Industrial read (OPC UA, Modbus) | ✓ | ✓ | ✓ | ✓ |
| Show a page on its display (kiosk) | ✓ | ✓ | ||
| See and drive its desktop apps | ✓ | ✓ | ||
| Mac apps (Messages, WhatsApp, Notes, Contacts) | ✓ | |||
| Serve a model to its scenes' picker | ✓ | ✓ | ✓ |
An ESP32 is a board a Linux node hears over USB or on the network, not a node of its own. Industrial reads work from any node on the plant network. A model is served like any service, below.
The tile says what the machine offers
The processor architecture, how much it can run at once, whether it reaches a local network and which one, the address its traffic leaves from, the devices plugged into it, a GPU if it has one, whether it can take live video, a screen it drives, a browser it can run, and on Windows or a Mac the desktop of whoever is signed in. A scene running on a node knows it can reach nas.local because the node says so, and knows when it cannot.
What is plugged in shows on the back of its cell
On a Linux machine, the back of its cell lists what is plugged into it: cameras, microphones, serial ports and CAN buses, each under a name that survives unplugging it and plugging it back in. Drag a camera into a scene and it becomes a camera cell that streams through the machine while someone watches. Drag a microphone and it becomes a microphone cell, which a meeting can take in as the room. The stage lights the machine drives are listed under Lights and become light cells the same way.
ESP32 boards show there too, on Linux, macOS and Windows alike: one plugged in on its own USB port, and, if you ticked Find its boards, the ESPHome boards the machine hears on its network, with what they run and where they are. A board is listed; it doesn't become a cell. daslab node devices prints the same list on the machine.
You choose what it is allowed to do when you pair it
The pair page asks what the machine is allowed to do: run commands and move files, take in camera streams, show pages on its screen, read plant equipment, show its cameras, hear its microphones, work its lights, find its boards, see its screen, work its screen. The machine stores that and refuses anything outside it, so nothing on our side can widen it later. A box next to a payroll database can run with no shell at all. Pairing again changes what is allowed, and daslab node allow microphones, run on the machine, adds one.
Cameras, microphones, lights, boards and the screen are never on unless you tick them, and a machine paired before these choices existed has none of them.
It reaches what you publish from it
Nothing on the machine's network or disk is reachable from the workspace until you publish it, by name, on the machine:
daslab node publish hrmi 192.168.1.20:1433
daslab node publish quotes /mnt/nas/quotesThe workspace sees what is published. Only the machine can add to it, and daslab node unpublish takes it away.
A service is a name for an address on the machine's network. A scene reaches it as hrmi.office-vm.daslab: a database driver or a web request connects through the node, which dials that address and nothing else. A connection the client encrypts itself, like most database drivers, stays encrypted the whole way. A plain web request is made by our server, so the server reads it.
A folder is a name for a directory the machine reads: a local folder, or a share it has mounted. Add it to a scene as a cell, Folder on a machine, and the agent lists and reads its files by address, acme/sales:quotes/2026/January/quote.xlsx, as it reads any cell's files. It is live: each read goes to the machine and gets the file as it is now, and nothing is copied or kept. A PDF reads as its text and a workbook as its sheets. Each read records the fingerprint of the bytes it saw, so the trace says exactly which version of a file the agent read. A folder is read-only, a read carries up to 10 MiB, and a path that leaves the folder, by .. or by a symlink, is refused by the machine.
A model server is a service too. Run one on the machine (vLLM, SGLang, Ollama, anything that speaks the OpenAI API) and publish its port:
vllm serve Qwen/Qwen3.8-27B-FP8 --served-model-name qwen3.8-27b --host 127.0.0.1
daslab node publish models 127.0.0.1:8000Then add a cell to a scene, Model on a machine, naming the machine and models. Every model the server lists shows in that scene's model picker, as qwen3.8-27b on lab-gpu, and a job there runs on it through the machine, with nothing billed per token. A server that is off lists nothing, so the picker only offers a model that can answer. A server that wants a key gets it from a scene secret the cell names.
Added to a scene, the model is that scene's; added at the workspace level, every scene in the workspace can pick it, for its members. A cell in your private layer serves only your own runs. A call from anywhere else is refused, never sent to another model instead. More on the own-model page.
A Mac's apps publish as folders too: Messages, WhatsApp, Notes and Contacts.
daslab node publish texts messages
daslab node publish ana messages:+15551234567
daslab node publish wa whatsapp
daslab node publish family whatsapp:Family
daslab node publish notes notes
daslab node publish people contactsmessages is every conversation in Messages, and messages: with a number or an address is only the conversations with that person. whatsapp is every chat in WhatsApp Desktop, and whatsapp: with a number or a chat's name is only that chat. notes is every note in Apple Notes, and contacts is the address book. Each conversation, chat and note is a file listed under a name, the person's, the chat's or the note's title, and reads as its text: a conversation as each day's messages in order, who sent each, attachments by name; a note as its title and text. The address book is one file, contacts.csv. Messages lists people by name where Contacts is published too; otherwise by their number. WhatsApp is read, never sent from, as far back as the Mac has it. Locked notes stay locked.
In a scene they are Messages, WhatsApp, Notes and Contacts in the picker, and parts on the Mac's cell. Until a Mac publishes them, each says the next step instead: add your Mac, update it, or the command to run on it. An agent reads the same step, so it can walk you through it.
They are their owner's alone. A cell reads them only from the private layer of the person who paired the Mac, which nobody else opens, admins included; added from the picker or from the Mac's cell, it starts there. A cell anywhere else, whoever made it, reads nothing, and a share link never shows them, nor the machine itself.
Like any folder, they are read when the agent reads them and nothing is copied or kept, so they are always current: a message that came in a minute ago is in the next read. It also means the Mac has to be on: asleep or offline, a read fails rather than showing an old copy. daslab node unpublish ana takes one away.
macOS has to allow it first. Messages, WhatsApp and Notes need Full Disk Access; Contacts asks you, on the Mac, the first time it is read; the rest of the node works without either. The first time you publish one that needs it, that setting opens beside the node's binary for you to switch on; switching it off later stops only these. Full Disk Access is wider than these apps: it opens the whole disk to the node. On a machine that also runs commands for the workspace, a command can reach whatever that opens, published or not. So a Mac whose apps you publish is best set up without commands: daslab node disallow commands.
These are read from a Mac's own apps; a Windows or Linux machine has none to publish.
A scene runs on a node when you tell it to
Add the node's tile to a scene and the scene can work on the machine by name: run a command there and move files to and from it, if the machine may run commands, and use what else it was paired for, its cameras, its screen, its plant reads. The scene's own computer stays where it was.
To move that computer onto the machine, tell the scene: *run this scene on lab-pi*. From the next job on, its shell, files and builds are on the machine. A scene nobody told runs its computer on our machines, whatever tiles it holds. Where a computer ran is recorded with every run, and minutes on your own node are not metered.
Some things only a node can do
Reach the machines on your local network. Make requests from your own address rather than a datacenter's. Read the files on the share in your office. Talk to hardware plugged into the node: a camera, a serial port, an arm. Run next to a GPU you own. Take a camera's live video in on your own network. Keep a scene's work inside your building.
A browser can run on the machine
A browser cell can run on one of your machines instead of in the cloud. It browses from that machine's network and address, keeps its logins there, and you watch it or take over from the scene: while you click and type in it, the agent waits, and it goes back to the agent half a minute after you stop. Pick the machine in the browser's settings: the ones you paired that may run commands. It uses the Chromium or Chrome already on the machine, and on most machines fetches one where none is.
A screen it drives can show a page
A Linux machine with a kiosk set up (daslab node display install: Chromium full screen on its display) can show a scene's page on a wall or a counter, reload it, and say what the screen shows with a screenshot. The page stays up across reboots.
Live video can come in on the machine
A machine with ffmpeg on it says so on its tile, and a camera in the scene can then publish into that machine instead of a cloud region. The scene hands you a short address on your own network, rtmp://192.168.1.23:1935/live/…, for the glasses, the phone, OBS or a Pi to publish to, and the machine forwards the stream into the camera's session. Live video, scrubbing back, and asking what the camera saw all work as before. What changes is that the first hop never leaves the building, and that a publisher types a short local address rather than a long one belonging to a region on the other side of the world.
The same capability can publish the machine's own screen into a scene, so the desktop shows up live and can be asked about. On macOS that needs Screen Recording granted to the node, in System Settings under Privacy & Security; until it is, the stream connects but stays black. A publisher has to be on the same network as the machine. A camera out in the world still publishes to a region.
A Windows machine or a Mac can be worked through its screen
With See its screen ticked, a scene holding a Windows machine or a Mac sees the signed-in desktop live and reads its apps through their controls: the window, its buttons, its fields and what they hold. With Work its screen ticked too, it clicks, types and uses those apps as the person signed in. Each action waits for approval unless the scene allows it, and one that sends, deletes, buys or touches a password manager has to be confirmed explicitly on top. While the agent works, an orange border runs around the screen. The person at the machine has priority: touch the mouse or keyboard and the agent pauses. The owner can watch the screen and take it over from the machine's page. While they have it, the agent's screen tools do nothing and return no picture, not even a screenshot. That holds for those tools, not for the machine: a scene that may also run commands on it can still capture the screen with a command. A machine where someone types codes while a scene works on it is best paired without commands. Clicking outside the picture or leaving the page gives it back; if their connection drops, it goes back on its own within a minute.
On a Mac, macOS has its own say. The first time a pairing shares the screen, the node asks for Screen Recording (to see it) and Accessibility (to read apps and act), and shows up switched off in System Settings → Privacy & Security under both. Turn it on there and restart the node; its log says how. The Mac shows no orange border, and the agent works whatever app is in front, moving the real pointer, so a Mac you are using yourself is shared with it.
A node on a plant network can read its machines
A scene holding a node can read the industrial equipment that node reaches, and only read it. Over OPC UA it browses a server's address space, reads the value, status and timestamp of named nodes, and records every change to them over a window of up to five minutes; security None or Basic256Sha256 with a username both work, and a server with security on has to trust the node's client certificate once, as it would any client. Over Modbus it reads holding and input registers, coils and discrete inputs, over TCP or on a serial line plugged into the node, and decodes register words as 16- or 32-bit integers or floats in either word order, with a scale. There is no write, no method call and no Modbus write function among these tools: a write to a PLC can move equipment. A password is never typed to the agent; the tool takes the name of a scene secret that holds it.
Who may use a node
A node is a tile, so it sits in a layer like everything else. A node you add lands locked: the whole workspace sees it, and only you can add it to a scene or run a scene on it until you open the lock or name people. Add it to your private layer and only your own runs can use it. A node serves the workspace it was added to and no other.
When a node is offline, its scenes wait
When a machine is off or offline, the scenes running on it say so and wait. Their computers are not moved to our machines: a scene told to run on a machine on your network stays on it. A folder on it says the machine is away until it is back.
What's next
- Sandbox: what a scene's computer is.
- Layers: who sees what.
- Your machines: guides for a Raspberry Pi, a Mac mini, a Jetson, an ESP32.
- Run your own: keys, machines and name.
Updated 2026-11-14