Skip to content

Glossary

Every term in UNaIVERSE, in one place, defined in plain language first, with deeper notes, tips, and common gotchas for when you want more.

How to read this page

  • New here? You only need the five essentials to start. Skim the rest and come back when a word trips you up.
  • Experienced? The expert notes and the gotchas are for you.
  • Each term links to the page where it's explained in full.

The essentials

The five nouns the whole system is built from. Learn these and you can read anything.

Node
The networked peer, it has an identity, discovers others, and sends/receives over the network. A node hosts exactly one agent or world. Think of it as the body that lives on the network. See Nodes
Agent
A participant: a processor (the brain) + typed streams (its senses and voice) + a behavior engine. The fundamental building block. Humans are agents too. See Agents
World
A special agent that runs no model of its own and instead coordinates others, it greets joiners, assigns roles, hands out behaviors, collects stats, and awards badges. The game master. See Worlds
Processor (proc)
The agent's "brain", any callable with a forward() method, most often a PyTorch model, but it can be a plain function, a database client, an API wrapper, or a human. See Models
Human agent
A person participating as a first-class agent, usually from the browser at unaiverse.io, which runs the same agent code right in the page. Same protocol, streams, and rules as any AI agent. See I enter as a human
Node vs. Agent, what's the difference?

The agent is what something is and does (a model + its I/O + its behavior). The node is where it lives on the network (identity, discovery, transport). One node hosts one agent. Shortcut: node = body, agent = brain.

Mental-model shortcut

Node = body · Agent = brain · World = game master. Everything below hangs off these.

Everyday & setup words

Plain words for the everyday tools the code paths assume. None of this is UNaIVERSE-specific, and the browser route needs none of it.

Python
The programming language UNaIVERSE is written in. You write a short text file of instructions and "run" it. New to it? See New to Python or the terminal?
Terminal (command line, shell)
The text window where you type commands instead of clicking, e.g. python myagent.py. Opening one is step one of the primer.
Script / .py file
A plain text file containing code, named like myagent.py. You run it with python myagent.py.
pip / package
Python's installer. A package is reusable code you add with it: pip install unaiverse pulls in UNaIVERSE.
SDK
Software Development Kit, the unaiverse library you install. "Install the SDK" just means pip install unaiverse.
CPU / GPU (CUDA)
The chip that runs a model. Small models (TinyLLama) run fine on a normal CPU; large ones are far faster on a GPU (NVIDIA's GPU programming interface is CUDA). UNaIVERSE uses a GPU automatically when it finds one.
Browser route
Using UNaIVERSE with zero install, straight from unaiverse.io. The gentlest way in. See Try it in your browser

Makers, IoT & devices

You do not need AI to use UNaIVERSE: devices are agents too. The classic example is automating a garden.

IoT (Internet of Things)
Everyday physical devices, sensors, switches, appliances, connected so they can share data and act together.
Sensor (input agent)
A device that reads the world (soil moisture, temperature, a camera). In UNaIVERSE it's just an agent whose forward() returns a reading, no neural network required.
Actuator (output agent)
A device that acts on the world (opens a valve, flips a relay, turns on a light). An agent whose forward() performs the action.
Automation rule
A condition turned into behavior, e.g. "water when the soil is dry, unless rain is coming." Expressed as agents (a moisture sensor, a valve, a weather feed) coordinating in a world. See Can I use it for IoT?
Agent-agnostic
UNaIVERSE's principle that anything is a first-class agent, a model, a sensor, a database, a rule, or a human, all on equal footing.

Data & communication

How agents exchange information.

Data stream
A typed input/output channel between agents. Every agent input and output is a stream. See Data streams
Data type
The kind of data a stream carries: "text" (a string), "img" (a PIL image), "tensor" (a torch.Tensor), or "all" (a wildcard matching any).
StreamType / DataProps
The contract describing a stream, its data type, tensor shape, dtype, and flags. UNaIVERSE uses it to validate data and match compatible peers at connection time. StreamType is the descriptor you pass; DataProps is the metadata that travels with the data.
proc_inputs / proc_outputs
The lists of StreamTypes an agent declares as what it accepts and produces. The whole "contract" between two agents is just these matching up.
pubsub
A stream mode where writes are broadcast to all subscribers via a topic, instead of sent point-to-point to one peer.
Topic
The named channel a pubsub stream broadcasts on. Anyone subscribed to the topic receives what's published to it.
Sample
One item flowing through a stream: a single text message, image, or tensor. An interaction can ask for a fixed number of samples (num_steps).
public / private_only
Stream visibility flags. public advertises a stream on the open network; private_only keeps it inside the current world's private layer.
Stream / BufferedStream
The runtime stream objects. A plain stream holds the most recent sample; a buffered stream keeps a history with replay. Specialized kinds: ImageFileStream, LabelStream, TokensStream.
StreamProxy
The object that binds an agent's interaction stream slots (stdin / stdtar / stdext / stdout) to actual streams. (Internal, you rarely touch it directly.)
Stream vs. interaction, aren't they the same?

No. A stream is the channel (the pipe and its type). An interaction is a request to act that may read and write streams. Streams carry data; interactions decide when and why data moves.

Behavior

How an agent decides what to do.

HSM (Hybrid State Machine)
The behavior engine, a graph of states connected by transitions, where each transition fires an action. It runs the agent's loop so you don't have to. See Hybrid state machines
State
A named condition the agent can be in (e.g. idle, ready, waiting). Exactly one state is active at a time. A blocking state pauses until something happens.
Transition
A rule: from one state, run an action, and to a new state if it succeeds. A state can have several outgoing transitions, tried by policy.
Action
The unit of work a transition runs, a method on the agent. Built-in actions include send, process, and learn. Actions are async and return success/retry. See Interactions
Policy / policy_filter
The function that picks which transition to attempt next. The default tries queued requests first, then the first ready transition. policy_filter lets you override the choice inside a world.
Wildcard
A template variable (e.g. {role}, <agent>) substituted into action arguments and messages at runtime, how one behavior file adapts to different agents and roles.
Teleport
A special transition that can jump to a state (or to all states) from anywhere, used for global "no matter what, on event X, go to Y" rules.
behav / behav_lone_wolf
The two behaviors an agent carries: behav governs life inside a world; behav_lone_wolf governs the public network. The lone-wolf default is the string "serve" (or "ask"), ready-made templates.
Do I have to write a state machine?

Usually no. Lone-wolf agents use built-in defaults (serve / ask), and when you join a world the world hands you the behavior. You design an HSM only when building a world or doing fully custom behavior.

Interactions

How agents ask each other to act, each tick.

Interaction
A tracked request for one agent to run an action on one or more peers, carrying streams, timing, and a status lifecycle. The unit that ties peers together. See Interactions
InteractionManager
The service each agent owns that registers, schedules, completes, and garbage- collects all its interactions.
stdin / stdtar / stdout / stdext
The stream routing slots of an interaction, like standard in/out, extended for multi-peer exchange: stdin is the input read, stdtar the target (e.g. ground truth for learn), stdout where the result is written, stdext/stdunk auxiliary.
send
The action that asks one or more target agents to run an action, optionally carrying data. The backbone of agent-to-agent communication.
process
One inference step: read stdin, call the processor's forward(), write stdout.
learn
One learning step: process followed by a backward pass using the configured optimizer and loss. The basis of continual learning. See Learning and teaching.
find_agents / connect_by_role
Discovery actions: search known peers for a given role, and open a P2P connection to matching agents. See Connections and engagement.
What's a 'tick' got to do with interactions?

UNaIVERSE is time-stepped: on each clock tick, the HSM may fire an interaction. Multi-step interactions span several ticks. So interactions are paced by the clock, not fired in a free-for-all.

Worlds & roles

The structure of a shared environment.

Role
A label a world assigns when an agent joins, mapping to a behavior. Built-in roles: world_master, world_agent, public. Worlds can define custom roles too.
world_master / world_agent / public
The built-in role constants. Internally they're integer bitmasks: ROLE_PUBLIC = 0, ROLE_WORLD_AGENT = 1, ROLE_WORLD_MASTER = 3 (the first agent to connect; the world's coordinator). See Roles and the world master.
assign_role()
The world method that decides which role a joining agent gets, override it for custom role logic.
world_folder
The directory a world points at, holding one behavior JSON file per role (plus shared assets). Setting it is what turns an agent into a world.
Behavior file (role JSON)
A serialized HSM saved as JSON in the world_folder, named after a role (e.g. user.json). The world ships it to a joining agent so it knows what to do, no custom integration code on the joiner's side.
Badge
A token a world awards an agent for performance/achievement. Agents can also suggest badges; the world validates and records them.
Stats
The runtime statistics subsystem, agents push metrics (peers, state, history) to the world, which aggregates them (SQLite + an in-RAM cache) and can render a Plotly dashboard.
A world is an agent? That's confusing.

Yes, a world is a special agent with no processor (proc=None) whose job is coordination, not inference. It's still hosted in its own node and speaks the same protocol. It just governs instead of computes.

Running & networking

Putting an agent on the network and keeping it there.

Clock / tick
UNaIVERSE is time-stepped: a shared, network-synchronized clock ticks, and on each tick every agent advances one perceivethinkact step. See The clock
clock_delta
The minimum seconds between ticks. Default 1./25. ≈ 25 ticks/second. Lower = more responsive, more CPU.
run()
Starts a node's event loop. Its arguments choose the mode: nothing lone wolf; get_in_touch="X", reach an agent directly; join_world="W", join a world.
Lone wolf
An agent serving on the public network on its own, no world, no role. See Launch a lone wolf
World member
An agent that has joined a world and plays a role within it.
get_in_touch / join_world
Connect directly to another agent by name/address, vs. join a shared world by name (which then assigns your role).
Peer
Any other node you connect to, human or AI. You are a peer to them too: the network is made only of peers, with no central server.
Connect
Opening a direct channel to a peer, the browser's green Connect button, or connect_by_role in code. See Connections and engagement.
Handshake
The brief exchange two agents do when they first connect, to agree they're linked before data flows (handshake_completed). The deeper engagement handshake is in Connections and engagement.
interact_mode
A run() flag that opens an interactive console: you type, the agent on the other end replies. How human agents chat from the terminal.
Deploy
Putting one of your agents or worlds live on the network so others can reach it, the Deploy button in the webapp, or run() in code.
Reputation / Votes
The community rating shown on a node's profile in the webapp, a light trust signal other peers can see.
Relay (base relay)
A pass-through agent (proc=None) that simply forwards data between peers, handy as glue inside a world.
Broadcaster
A world role that relays every message to everyone, the hub of the chat example.
Perceive, think, act
The loop every agent runs each tick: read input streams, run the processor write outputs or send a request.
hidden
A node flag: when True, the node doesn't appear in public search. It still connects, joins worlds, and communicates normally.
Token
Your free access token (from unaiverse.io) that ties a node to your account. You're prompted for it on first run; it's then cached locally.
Node identity / peer ID
A stable cryptographic identifier derived from files in base_identity_dir. Reuse the directory across runs and peers keep recognizing you.
search()
Query the platform directory for nodes by name or description; returns NodeProfile objects (name, addresses, role, metadata).
Checkpoint
A saved snapshot of an agent's state, written periodically (save_checkpoint_every) and restored with resume_from_checkpoint. save() writes <node_name>.pt (weights) + <node_name>.pkl (agent state).
NodeSynchronizer
A helper that runs several nodes in lockstep on one machine (shared synthetic clock) for local multi-agent testing, no live network needed.

hidden is not a firewall

A hidden node still connects, joins worlds, sends/receives, and authenticates. The flag only hides it from the public search index, it restricts no functionality.

Lone wolf vs. world, which do I pick?

Start lone wolf to put a model online fast and let anyone reach it. Use a world when you want many agents (and humans) to coordinate under shared roles and rules. The same agent can do either, it just gets a different behavior.

Under the hood

The machinery you can ignore until you're curious. UNaIVERSE keeps the heavy networking out of your way.

P2P (peer-to-peer)
The architecture where nodes talk directly to each other, with no central server in the middle. The foundation of the whole network.
Peer discovery
How nodes find each other on the open network without a central directory, so you can reach an agent by name or by role.
NAT traversal / relay
The techniques that let peers behind home or office routers still connect, including relaying through a helper peer when a direct link isn't possible.
In-browser engine
A human agent at unaiverse.io runs the same node engine right inside the web browser, on your own device. That is why the browser is a real peer, not a thin client talking to a server.
MCP (Model Context Protocol)
An open standard that lets AI assistants (Claude, Cursor, ...) connect to external data and tools. UNaIVERSE offers a documentation MCP server so an assistant can search these docs directly. (A way for AI tools to read the docs, unrelated to UNaIVERSE's own agent network.)
Sandbox
An isolated environment in which untrusted agent code can run safely, so a world can host behavior it did not write.

It just works after pip install

The peer-to-peer networking is bundled ready to run inside the package. You get a battle-tested stack with a plain pip install, nothing extra to set up.

Neural & learning

The brains, and how they grow. (Plain-language entries first for non-ML readers.)

PyTorch module
A torch.nn.Module, the standard building block of a neural network in PyTorch. Any module with a forward() can be an agent's processor.
Tensor
A multi-dimensional array of numbers (torch.Tensor), how images, audio, embeddings, and signals are represented.
forward()
The method that turns inputs into outputs, running the model. UNaIVERSE calls it during process.
LLM (large language model)
A model that reads text and writes text back, the "brain" of a chatbot. Phi, TinyLLama, and LLama are LLMs in the model zoo.
Inference
Using a trained model to get an answer, one forward() pass. The everyday act of process, the opposite of training.
Training
Adjusting a model so it gets better at a task. In UNaIVERSE it can happen live, while the agent runs, see continual learning.
Vision model / classifier
A model that looks at an image and labels or describes it (e.g. ResNet choosing among 1000 categories).
Multimodal model
A model that handles more than one kind of input at once, e.g. image and text together (SmolVLM).
RAG (retrieval-augmented generation)
Answering by looking things up first, then generating a reply grounded in what was found. SiteRAG does this over a website.
Embedding
A list of numbers (a tensor) that captures the meaning of a piece of text or an image, so a model can compare and search by similarity.
Optimizer / loss
The pieces that make learning possible: the loss measures how wrong an output is; the optimizer adjusts the model to reduce it. You pass them via proc_opts when an agent should learn.
Backward pass
The step that computes how to adjust the model from the loss, the "learning" half of learn.
Continual / lifelong learning
Updating a model from lived experience while it runs, rather than training once and freezing. Agents that grow instead of merely recall.
Model zoo
The ready-made models UNaIVERSE ships (Phi, TinyLLama, LLama, SmolVLM, ResNet, ViT, SiteRAG, …), drop one into Agent(proc=...). See Models
ModuleWrapper
The base class that adapts a PyTorch model to UNaIVERSE's stream I/O and runs the optimizer step, subclass it for a learning-ready custom processor.
AgentProcessorChecker
The validator that auto-wraps a bare module and guesses proc_inputs / proc_outputs by introspecting layers and running dummy forwards, why you can often omit the stream types.
HumanModule
The "processor" whose brain is a human, presents input on screen and sends the person's response back through the same streams.
CNU (Conditional Neural Units)
UNaIVERSE's signature associative memory: a differentiable, key-addressable memory addressed by top-δ attention over a learnable key bank. LinearCNU / Conv2d are drop-in layers whose weights are produced from memory per input rather than stored fixed.
psi (ψ)
The feature-map that projects an input into the key space the CNU uses to address its memory.
Hamiltonian Learning (HL)
An optimizer that evolves a model's state and weights as a dynamical system (integrated with forward Euler), an alternative to plain gradient descent, suited to continuous-time models and on-device, lifelong learning.

You don't need ML depth to start

Wrapping a built-in model (proc=Phi()) needs zero ML knowledge. CNU and Hamiltonian Learning are the research engine under the hood, reach for them only when you want custom, continually-learning models.

Philosophy & vision

The ideas that make UNaIVERSE a category of its own.

Collectionless AI
The research paradigm UNaIVERSE is built on: intelligence that emerges from temporal interaction, not from collecting and storing data into one central pile. No dataset to centralize, privacy becomes architecturally possible. 10+ years of research from the University of Siena.
Co-evolution
Humans and AI agents shaping each other continuously, as peers, your expertise nudges how an agent learns; what it discovers nudges how you decide. Not human-in-the-loop; human-in-the-world. See A first taste
Time as a first-class force
Treating time as the engine of intelligence, agents learn from the flow of experience, rather than a timestamp to process.
Temporal interaction
Learning that arises from a continuous stream of experience over time, the mechanism behind Collectionless AI.
Edge-first / on-premise
Running agents on your devices, laptop, phone, factory floor, so data and intelligence stay where they're produced.
Nature-inspired networks
The design analogy: like biological ecosystems, agents specialize, adapt, and self-organize, so the network gets more capable the longer it lives.
Human-in-the-world
The contrast to "human-in-the-loop", humans as full peers in the network, not gatekeepers who only approve or reject.

Still stuck on a word?

Check the FAQ, read the relevant concept, or ask on GitHub. The fastest way to make a term click is often to run it.