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 via WebAssembly. 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.

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.
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.
find_agents / connect_by_role
Discovery actions: search known peers for a given role, and open a P2P connection to matching agents.
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).
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).
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 (transport)

The machinery you can ignore until you're curious.

P2P (peer-to-peer)
The architecture where nodes talk directly to each other, with no central server in the middle.
libp2p
The mature peer-to-peer networking stack UNaIVERSE embeds (as a Go library, shipped pre-compiled in the wheel) for transport, discovery, and pub/sub.
DHT (Distributed Hash Table)
The decentralized lookup mechanism libp2p uses so peers can find each other without a central directory of addresses.
Multiaddress
A self-describing network address format (transport + address + peer ID) used to reach a specific peer.
NAT traversal / relay
Techniques that let peers behind home/office routers still connect, including relaying through a helper peer when a direct link isn't possible.
WebRTC signaling
The handshake that lets browser peers (human agents) join the P2P network.
Protobuf (message.proto)
The wire format (schema) peers use to serialize what they send, stream samples, tensor/image/text/file payloads, stats.
Msg
The Python wrapper around the Protobuf schema that serializes stream data for transmission.
Go bridge (ctypes / CGo)
The seam where Python calls the embedded Go/libp2p library, Python loads the compiled shared library at runtime via ctypes.
Sandbox
An isolated Docker environment in which untrusted agent code can run safely, so a world can host behavior it didn't write.

You never install Go

The Go/libp2p transport is bundled pre-compiled in the Python wheel. You get a battle-tested P2P stack with a plain pip install, no Go toolchain.

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.
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.