Nodes

A node is a service you drag onto the canvas. It connects an Agent to another system. There is a marketplace of nodes. When none of them suits your situation, build your own.

Check the marketplace first. It ships with a library of ready-made nodes. They cover AI, Voice, Go To Market, Search, Web Scraping, Media & Design, Documents, Knowledge & Vectors, Storage & Data, Communication, Flow and Output. Adding one takes a click, and most of what an Agent needs is already there.

A node you build is a folder of YAML files. You describe the API call, and the platform makes it. Never built one? Create your first node walks a real one from an empty folder to a run. Then Anatomy of a node is the place to start.

The shape of a node

nodes/<package> in your studio project workspace

package.yaml what the package is and may call

credentials the credentials its nodes ask for

shared fragments more than one node reuses

nodes

YourNode

node.yaml what it is

interface.yaml what it connects to

config.yaml the settings form

api

run.yaml the calls it makes

events.yaml everything that leaves it

service.yaml methods other nodes call

test.yaml sample data to run it with

One folder is one node. The package around it holds anything its nodes share.

File	What it does
`package.yaml`	Names the package and lists the hosts its nodes may call. A call to anywhere else is refused
`credentials/`	The credentials its nodes ask for. The shape of each one, never a value
`shared/`	Fragments more than one node reuses, such as a base URL or a list of models
`node.yaml`	What the node is: its name, colour, and the words that decide when an Agent picks it
`interface.yaml`	What it connects to: its inputs and outputs, the dots on the node a line attaches to, and the credentials it needs
`config.yaml`	The settings form someone fills in on the canvas
`api/`	What the node calls, what comes out, and what it offers to other nodes
`test.yaml`	Sample settings and inputs, so you can run the node for real before wiring it up. The docs call this a fixture

A node that calls a service needs four of these: node.yaml, api/run.yaml, api/events.yaml and test.yaml. Lint refuses a node with calls but no events table, and a node with no sample data, because neither can be run. Everything except api/ can be written inside node.yaml instead of its own file, so a small node can be two files.

Inside `api/`

One file per job, and a node uses the ones it needs.

File	What it does
`run.yaml`	The calls the node makes when the workflow triggers it
`events.yaml`	Everything that leaves the node, one row per output connector
`service.yaml`	Methods this node offers to other nodes over a service edge
`toolExchange.yaml`	The protocol for a node that lets a model call tools over several turns
`narrate.yaml`	A second, cheaper model writing a status line while the main call runs

A node the workflow triggers has run.yaml and events.yaml. A node that exists to be called by other nodes has service.yaml instead, and no outputs at all. Some have both. A voice node adds audio.yaml, and the reference lists every file. Anatomy of a node walks through each of them with a real example.

Which files your node needs

Your node	Files
Calls one API and answers	`node.yaml`, `interface.yaml`, `config.yaml`, `api/run.yaml`, `api/events.yaml`, `test.yaml`
Streams its reply	The same, with `transport: sse` on the last call and `match` on its events rows
Is called by other nodes, not by the workflow	`node.yaml`, `interface.yaml`, `api/service.yaml`, `test.yaml`. No outputs, no `events.yaml`
Hands tools to an Agent	The service shape above, with an `mcp` connector in `interface.yaml`
Needs a key	Any of the above, plus one file in the package’s `credentials/`

Every node’s package carries package.yaml with the hosts its nodes may call.

How you build one

Create the folder under a package’s nodes/
Describe the node: node.yaml, interface.yaml, config.yaml
Describe the calls in api/run.yaml, and what comes out in api/events.yaml
Add the host to the package’s allowedHosts
Run it against the real service, on the Nodes screen in studio
Check it before you deploy:
unoverse lint

unoverse deploy studio runs the same check first, then ships every node in the workspace alongside your components and skills.

Nodes to learn from

Every published node is public. Find the one closest to what you are building and mirror it. marketplace/definitions/nodes

Read it for	Node
The simplest case: one call, one answer	SearchWeb
Walking pages and accumulating the results	AirtableFetch
Writing a collection in batches the API accepts	AirtableInsert
A cheap existence check before an insert	AirtableExists
Caching an answer between runs	ApolloCompany
Two calls, where the second uses the first	HunterEnrich
Starting a job and waiting for it to finish	HyperbrowserCrawl
Tokens streaming in as they are produced	OpenAIStream
A request whose shape changes with the settings	OpenAIStructuredOutput
A node other nodes call, rather than a workflow step	OpenAIEmbeddingService
Offering tools to an Agent	HubspotMCP
A tool loop, and a second model narrating progress	OpenAIAgent

Whole packages worth reading: airtable, apify, aws-dynamodb, aws-s3, gtm, hubspot, hyperbrowser, openai, salesforce, search, slack and x-search.

Getting Started

Building Blocks

Ship & Extend

The shape of a node

Inside `api/`

Which files your node needs

How you build one

Nodes to learn from

Next steps

Anatomy of a node

Reference

​The shape of a node

​Inside api/

​Which files your node needs

​How you build one

​Nodes to learn from

​Next steps

Anatomy of a node

Reference

The shape of a node

Inside `api/`

Which files your node needs

How you build one

Nodes to learn from

Next steps