Glossary

App handoff

Transferring a running app from one device to another so the user continues at exactly the same point, without interruption.

Like Apple's Handoff, but working across any devices in your cohort.

Asset

Any non-code file that an app uses: images, fonts, icons, audio files. In Legion, assets are stored by content hash and loaded locally, never from the internet.

Beacon

A periodic “I'm here!” message sent by every node to let others know it's online. Beacons include the node's identity, capabilities, and cohort membership.

BFT (Byzantine Fault Tolerance)

A type of consensus protocol that can reach agreement even when some participants are unreliable or actively trying to cheat. Inspired by Tendermint. Requires more than 2/3 agreement.

Bridge node

A relay service that connects devices on different networks (for example, your home server to your laptop at a hotel). It establishes encrypted tunnels between remote devices and home nodes. No VPN setup needed.

Capability

A specific skill that a node can provide, like speech-to-text, AI chat, or audio output. Capabilities are advertised by nodes and discovered by the network. Examples: ai.llm, audio.in, storage.kv.

Capability manager

The system that tracks which nodes offer which capabilities, routes requests to the right node, and enforces permissions.

CBOR

A compact binary data format (like JSON but smaller). Legion uses it for DID documents and service certificates, with a hand-rolled encoder and no external library.

CLI

Command Line Interface. A text-based way to interact with Legion from your terminal. Example: legion identity certify --node … --cap ai.llm.

Cohort

Your personal network of devices. All nodes in the same cohort share data, conversation history, and capability discovery.

Like a WhatsApp group, but for devices cooperating to serve their owner.

Command

A unit of work or data change that gets agreed upon by the cohort. Examples: “user sent this message”, “update this setting”, “install this app”.

Consensus

The process by which all nodes in the cohort agree on what data is correct and in what order. Legion uses epoch-based ordering with optional BFT for critical decisions.

Content CID

The permanent identity of an app, computed as the SHA-256 hash of its code. The same bytes always produce the same CID; different bytes always produce a different CID. Also called “content hash” or “content identifier”.

Decay

The gradual reduction of a trust score over time when a peer has no recent activity. Trust never drops below 0.1 — you're never fully forgotten, just forgotten.

Delegation

The process of asking another node to perform a task on your behalf. When your smartphone needs speech-to-text, it delegates that task to a node that has the ai.stt capability.

DID (Decentralized Identifier)

A unique, permanent identity string. There are two types in Legion: did:legion:user:… (for people) and did:legion:node:… (for devices). Not stored on any blockchain — fully offline and self-sovereign.

Epoch

A numbered round of agreement. Each epoch contains a list of commands that all nodes agree on. Epochs are numbered sequentially (0, 1, 2…) and cryptographically linked to each other.

ESP32

A popular, very low-cost microcontroller (about $5). Legion can run on it for minimal display interfaces (Tier 1 rendering).

Gossip

A peer exchange mechanism where discovered nodes share their own contact lists with each other. Information spreads person-to-person until everyone knows everyone.

Like meeting someone at a party and getting introduced to their friends.

Hash chain

Each epoch's hash is computed from the previous epoch's hash, creating a chain. If anyone tries to modify data in an old epoch, the chain breaks and everyone knows.

Interface node

A node whose primary job is to interact with the human user. Examples: phone app, desktop app, CLI tool. Interface nodes don't do the actual work — they start processes and display results.

LNMP (Legion Node Message Protocol)

The transport framing layer for UDP messages. Every UDP packet in Legion has an LNMP header (36 bytes) containing sender ID, sequence number, timestamp, encryption flags, and a checksum.

Module

A self-contained piece of code that provides one or more capabilities. Modules can be built-in or loadable (separate .so files loaded on demand).

Node

A Legion program running on a device. Every process in Legion is a node — daemons, CLIs, mobile apps, embedded devices. All the same shape: an identity, a cohort, and a set of capabilities.

Orchestrator node

A node that runs long-lived workflows by delegating tasks to specialist nodes. It's the “brain” — it knows how to connect different capabilities together to form complete processes.

Pairing

The process of adding a new device to your cohort. Requires your approval (via PIN plus biometric confirmation on the master device). After pairing, the new device can participate independently.

PAL (Platform Abstraction Layer)

A compatibility layer that provides a uniform interface to different operating systems. Legion calls PAL functions instead of calling Linux/Windows/FreeRTOS directly, so the same code runs everywhere.

Peer

Another node in your cohort. “Peer-to-peer” means all nodes are equal — no servers, no clients. Just peers talking to each other.

Plugin

A small piece of code that extends a node's capabilities. Plugins are discovered dynamically, have declared access controls, and can be chained together.

Poisoned epoch

An epoch where the average trust score of all peers dropped below 0.5. The system pauses new commands and investigates which peers are causing the problem.

Quorum

The minimum number of nodes needed to reach agreement. In BFT, the quorum is more than 2/3 of validators. In epoch consensus, the quorum is implicitly all non-poisoned peers.

Reliability

A classification of a peer's trust score: “healthy” (trust ≥ 0.7), “degraded” (trust 0.4–0.69), and “unhealthy” (trust < 0.4).

Rust

Not used in Legion's core (which is C), but mentioned in the specs as a potential language for bridge node implementations.

Seed node

A known address that a new node contacts on startup to bootstrap discovery. Like a phone book — you ask for a list of other peers, and the seed gives it to you.

Service certificate

A signed document from the user (or auth node) authorizing a device to act on their behalf. It lists the device's DID, granted capabilities, and maximum data tier.

SPAKE2

A password-authenticated key exchange protocol. Legion uses it for device pairing: two devices prove they share a PIN without revealing the PIN to eavesdroppers. Implemented using libsodium point arithmetic (~120 lines of C).

Specialist node

A node dedicated to one or two capabilities. Small, simple, deployable on very low-power hardware. Examples: an audio-only node, a speech-to-text node.

Stream

A continuous flow of data (like audio). In Legion, streams are routed through topics (pub/sub), not direct connections. This makes it easy to add intermediate processing steps.

Tier

There are two different kinds of tiers in Legion, and they're often confused:

Data tiers (1–4) are privacy levels for data: Tier 1 Sovereign (private), Tier 2 Pragmatic (personal), Tier 3 Group (shared), Tier 4 Interface (public).

Display tiers (1–3) are rendering capability levels: Tier 1 Minimal (custom renderer, microcontrollers), Tier 2 Standard (litehtml, Raspberry Pi), Tier 3 Full (WebView, smartphones).

Topic

A named channel in the pub/sub system. Nodes publish data to topics and subscribe to topics they care about. Example: legion://audio/in/phone-123/utterance.

Trust score

A number from 0.0 to 1.0 representing how reliable a peer is. It starts at 0.5 for new peers, and is adjusted by successful and failed interactions and time decay.

VM (Virtual Machine)

Legion's custom execution engine for internal system programs. A stack-based bytecode interpreter with 100+ opcodes for data, control flow, trust operations, distributed compute, and plugin invocation. Deterministic, metered, and snapshot-able — different from a general-purpose JS engine.

Wire format

Legion's custom binary serialization format for network messages and persistent storage. An 8-byte header plus type-length-value fields. Forward compatible (unknown fields are skipped) and about 4× smaller than JSON.

Zero-config

The ability to set up Legion without manual configuration. Default cohort derived from the OS username, multicast discovery finds peers automatically, and bridge discovery via the registry. You install and go.