Glossary

Definitions for all domain-specific terms used across the chatixia-mesh curriculum.

---

A

ADR (Architecture Decision Record) — A short document capturing a single architectural decision: context, decision, and consequences. Creates a decision log so future contributors understand why the system is built this way. Lesson 16

Agent — A Python AI process with skills, LLM integration, and mesh networking. Each agent has one sidecar, registers with the registry, and executes tasks from the hub queue or via direct P2P messages. Lesson 01

API Key — Pre-shared credential (e.g., ak_dev_001) exchanged for a JWT. Stored in api_keys.json, maps to a peer_id and role. Lesson 08

C

C10K Problem — The challenge of handling 10,000 simultaneous connections, driving the shift from thread-per-connection to event-driven architectures. Lesson 04

CGNAT — Carrier-Grade NAT. ISP-level NAT placing entire neighborhoods behind a single public IP. Often requires TURN relay. Lesson 02

Cone NAT — A NAT type allowing replies from varying external addresses depending on sub-type (full, restricted, port-restricted). More permissive than symmetric NAT. Lesson 02

Control Plane — Discovery, routing, authentication, and coordination. In chatixia-mesh: the registry. Knows who is connected but does not carry application data. Lesson 01

Cooperative Multitasking — Tasks voluntarily yield control via await. If a task never yields, it blocks all others. Used by tokio and asyncio. Lesson 04

D

DashMap — A concurrent hash map using sharded locking. Used throughout the registry for state management. Lesson 12

DataChannel — WebRTC primitive for arbitrary data transfer. DTLS-encrypted, peer-to-peer. Runs over SCTP over DTLS over UDP. Lesson 03

Data Plane — Carries application data between agents via WebRTC DataChannels. Separated from control plane so the registry never sees message content. Lesson 01

Defense in Depth — Multiple protection layers so no single failure compromises the system. Lesson 14

DTLS — Datagram Transport Layer Security. TLS-equivalent encryption over UDP for WebRTC DataChannels. Lesson 03

E

Event Loop — Core of an async runtime. Polls for I/O readiness and runs ready tasks until they yield. tokio is multi-threaded; asyncio is single-threaded. Lesson 04

Eventually Consistent — All replicas converge given time, but reads may return stale data. The registry derives agent health from heartbeat recency. Lesson 12

F

Full Mesh — Every node connects to every other. N nodes = N(N-1)/2 connections. Simple but scales quadratically. Lesson 02

G

Graceful Degradation — Three-tier fallback: P2P DataChannel (fastest) -> TURN relay (slower) -> HTTP task queue (slowest, always works). Lesson 01

H

Health — Agent status from heartbeat recency: active (<90s), stale (90-270s), offline (>270s). Lesson 09

Heartbeat — Periodic HTTP POST from agent to registry. Updates metadata and picks up pending tasks. Default: 30 seconds. Lesson 09

HOL Blocking — Head-of-line blocking. A lost packet at the front delays all subsequent packets. WebRTC DataChannels can avoid this with unordered delivery. Lesson 03

Hub — Monitoring/control plane: task queue + React dashboard. Hub API lives in the registry; UI is served as static assets. Lesson 13

I

ICE — Interactive Connectivity Establishment. Discovers the best network path by gathering candidates (host, STUN, TURN) and testing connectivity. Lesson 02

IPC — Inter-Process Communication. JSON-line protocol over Unix domain socket between sidecar and agent. Lesson 06

IpcMessage — JSON-line message between sidecar and agent. Has type and payload fields. Lesson 06

J

JSON-lines — Each line is a valid JSON object. Natural message framing without length prefixes. Lesson 06

JWT — JSON Web Token. Short-lived (5 min) bearer token for WebSocket auth. Contains sub (peer_id), role, exp, iat. Lesson 08

M

MCP — Model Context Protocol. Standard for connecting LLMs to external tools. Agents can expose skills as MCP servers. Lesson 09

Mesh — The network of WebRTC DataChannel connections between sidecars. Full mesh = every sidecar connected to every other. Lesson 01

MeshMessage — Application-level JSON over DataChannels. Fields: type, request_id, source_agent, target_agent, payload. Lesson 07

Multi-stage Docker Build — Earlier stages compile artifacts; final stage copies only outputs into a minimal base image. Lesson 15

N

NAT — Network Address Translation. Maps private IPs to public IPs, preventing direct inbound connections. Lesson 02

P

Peer — A sidecar identified by peer_id, connected to all other peers via DataChannels. Lesson 02

Process Isolation — Running components as separate OS processes so a crash in one does not bring down others. Lesson 10

Protocol Layering — Organizing communication into stacked layers, each with a specific responsibility. Lesson 07

Q

QUIC — UDP-based transport with multiplexed streams, built-in TLS 1.3, and faster connection setup than TCP+TLS. Lacks P2P NAT traversal. Lesson 11

R

Reactor Pattern — Demultiplexing I/O events from multiple sources into a single loop, dispatching to handlers. Foundation of tokio and asyncio. Lesson 04

Registry — Central Rust server (port 8080) providing signaling, discovery, task queue, and hub API. Lesson 01

Request/Response Correlation — Including a request_id so responses match originating requests. Lesson 07

S

SCTP — Stream Control Transmission Protocol. Transport for DataChannels. Supports reliable/unreliable and ordered/unordered delivery. Lesson 03

SDP — Session Description Protocol. Describes media/data capabilities, exchanged as offers and answers during WebRTC negotiation. Lesson 03

Sharded Locking — Dividing a data structure into independently-locked shards for concurrent access. Used by DashMap. Lesson 12

Sidecar — Rust process handling WebRTC on behalf of a Python agent. Communicates via Unix socket IPC. Lesson 10

Signaling — Exchanging SDP and ICE candidates via registry WebSocket to establish WebRTC connections. Lesson 05

Skill — A named capability (Python function) an agent can execute, used for task routing. Lesson 09

State Machine — Finite states with event-driven transitions. Tasks: pending -> assigned -> completed/failed. Lesson 12

STRIDE — Threat modeling framework: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege. Lesson 14

STUN — Session Traversal Utilities for NAT. Discovers public IP/port mapping. Works with cone NATs; symmetric NATs require TURN. Lesson 02

Symmetric NAT — Creates unique mappings per destination tuple. STUN-discovered addresses are useless for other peers. Requires TURN. Lesson 02

T

Task — Unit of work in the hub queue. Lifecycle: pending -> assigned -> completed/failed. Has TTL, target skill, and optional agent IDs. Lesson 09

Tool-use Loop — LLM generates tool call, agent executes it, returns result, LLM decides next step. Lesson 09

TTL — Time To Live. Maximum seconds a task can remain before expiring. Default: 300s. Lesson 09

TURN — Traversal Using Relays around NAT. Relays traffic through a server when direct/STUN fails. chatixia-mesh uses coturn with ephemeral credentials. Lesson 02

U

UDP Hole-Punching — NAT traversal where peers simultaneously send packets to create NAT mappings. Works with cone NATs, fails with symmetric. Lesson 02

W

WebTransport — Bidirectional communication over QUIC. Potential DataChannel successor for client-server, but lacks P2P and NAT traversal. Lesson 11