Glossary
Learn Matrix's core vocabulary—MCL, Intent IR, PlanTree, Cortex, and more—in this concise glossary for agent framework documentation.
A quick reference for the vocabulary used throughout these docs.
Core protocol
| Term | Definition |
|---|---|
| Matrix | An agent framework that takes LLMs past chat and into real execution. The default agent Neo handles everyday work; the MCL pipeline handles high-stakes operations: on-chain coordination, high-risk task execution, and safe handling of critical work. |
| MCL | Matrix Compiler. A cohort of three rigorous agents that communicate, plan, and act over a closed-verb protocol free of the ambiguity of natural language. Handles money, irreversible operations, and confidential tasks. |
| MatrixScript | The .mtx file format. A line-oriented, section-based, strongly typed language for defining skills and capability manifests. Parsed by mclc into a typed AST with deterministic hashing. |
| Intent IR | The typed, signed artifact the MCL compiler produces from natural language. The executor consumes Intent IR, never raw prose. Content-addressed and signable. |
| Frame | The typed source-of-truth inside an Intent: verb, objects, constraints, success_criteria, preferences. Survives multi-step execution and can be corrected structurally. |
| Verb (D7) | One of 10 closed verbs: find, acquire, build, modify, deliver, analyze, negotiate, schedule, monitor, delegate. Intent between agents is exact, never inferred at runtime from prose. |
| Object kind | One of 8 closed kinds: service, model, agent, knowledge, intent, asset, plan, capability. Every operand in the closed-verb protocol is one of these. |
| PlanTree | The executable tree synthesized from an Intent: sequential / parallel / step / tool_call / sub_dispatch / gate nodes. |
| Unknown | A structured gap in a Frame, marked blocking, preferred, or optional. The MCL cohort asks for clarity on blocking unknowns rather than guessing. |
| CompileMetadata | The D11 compilation trace: seed, mtx digest, model digest, grammar, skill id/version, cortex snapshot hash. |
| Envelope | A signed (ed25519) lifecycle record written as JSON under journal/<intent_id>/. Every lifecycle transition is an envelope. |
Memory and state
| Term | Definition |
|---|---|
| Cortex | The per-actor typed memory engine on Pebble. Append-only journal, Merkle-anchored snapshots, byte-deterministic replay. Persistent, immutable, and durable. An agent running on Matrix does not wake up empty. |
| Journal | The append-only write log (canonical CBOR) with monotonic, gap-free seq numbers. The source of truth from which all derived state can be rebuilt. |
| Salience | The 5-factor cold score plus EMA weight learner used to rank memory recall. Determines which memories are surfaced for a given context. |
| Snapshot | A Merkle-anchored capture (MMR + SMT-256) of cortex state, summarized by an OverallRoot. |
| OverallRoot | The single hash committing all cortex state. Used to verify the replay invariant. |
| Replay invariant (S13.4) | Dropping derived state and rebuilding from the journal must yield a byte-identical OverallRoot. Enforced on every pull request via make ci. |
| Attest | cortex.Attest writes KindAttest + KindLearnWeights atomically on a terminal lifecycle state. Links outcomes to the memories they cited. |
Agents and runtime
| Term | Definition |
|---|---|
| Neo | The default conversational agent. Runs inside the Loop Manager with shell, code, fetch, browser, web-search, and chain tools available for reversible work. Escalates to MCL the instant stakes rise. |
| Loop Manager | The per-agent loop engine. Coordinates the constant exchange between the user, the LLM, and Cortex. Escalates to the MCL pipeline when work becomes consequential. Implemented by the executor module. |
| Executor | The Go module that implements the Loop Manager. Per-agent loop engine, lifecycle state machine, MCP dispatch, per-user daemon, Liaison narrator, and end-to-end test harness. |
| core_execute | The delegation bridge between Neo's conversational loop and the MCL pipeline. Hands a prose intent to the daemon's async HTTP API, services approval gates inline, and returns the verifiable outcome. Neo routes anything that moves funds or needs a signature through core_execute. |
| Swarm | Sub-agent fan-out bridge. Lets a task-scoped run spawn sub-agent schemas in parallel. Protected by a recursion backstop: a context already inside a swarm refuses further fan-out. |
| Automatrix | The proactive-task system. Per-user opt-in mode where the agent autonomously identifies and executes opportunities. Controlled via /automatrix/* endpoints. Structurally excludes value-moving tools. |
| Liaison | The user-facing narrator that turns pipeline events into natural-language chat turns. A pure observability side-channel. |
| DID | Decentralized identifier (did:matrix:<label>:<keyfp>) binding an actor to its ed25519 key. An agent's DID is its account on LayerX. |
| Skill | A capability manifest: SKILL.mtx (MatrixScript) + SKILL.md (prose body). Defines what tools a skill needs and what it can do. |
| Agent manifest | A DID-bound JSON file (agents/*.json) declaring the MCP tool servers an agent may use. Loaded at agent boot; the registry resolves every matrix://tool/... URI against it. |
| Side-effect class | Every tool is classified as read, write, network, or shell. The capability gate enforces these classes against allowed_side_effects in the agent manifest. |
Tools and protocol
| Term | Definition |
|---|---|
| MCP | Model Context Protocol. The JSON-RPC tool server protocol agents use to call external capabilities. Transports are stdio and streamable-HTTP. |
| Tool surface | The complete set of MCP servers and tools an agent has access to. Declared exhaustively in the agent manifest; the manager rejects drift at boot. |
| Tool URI | The scheme for referencing tools: matrix://tool/mcp/<server-alias>/<tool-name>@<version>. Version-pinned and content-addressed. |
| Package digest | The sha256 hash of a published MCP server package. Recorded in the agent manifest as sha256:<64-hex>. Must be computed from the actual distribution package before production deployment. |
Modules
| Module | Role |
|---|---|
| MCL | The Matrix Compiler cohort. Three rigorous closed-verb agents that plan and act on high-risk, sensitive tasks. |
| Cortex | Per-actor typed memory engine on Pebble. Append-only journal, Merkle-anchored snapshots, byte-deterministic replay. |
| Executor | The Loop Manager. Per-agent loop engine, lifecycle state machine, MCP dispatch, per-user daemon. |
| Neo | Default conversational agent with automatic escalation to MCL for consequential operations. |
| Gateway | Metered LLM proxy with PAX credit ledger, free-tier whitelist, and rate card enforcement. |
| Router | Per-user Fly Machine provisioning with wake-then-reverse-proxy front door. JWT verification, cold-start handling. |
| Deus | Agent-service marketplace: registry, discovery, metered invocation, EIP-712 receipts, hosted execution. 0% platform fee. |
| LayerX | Settlement fabric and custody spine for agent balances. Gasless, USD-denominated (USDX) transfers between agent DIDs. |
| Tachyon | Agent-native Solidity/EVM engine: compile, test, simulate, deploy smart contracts. |
| Chronos | Centralized agent scheduler and wake-up system. Supports one-shot and cron-style scheduled tasks. |
| UWAC | Universal Web Agent Connector. OAuth vault providing per-user MCP tools (Gmail, Google Calendar). |
| Bridge | MCL-to-Cortex adapter. Separate Go module for clean interface boundaries. |
Hosting and economy
| Term | Definition |
|---|---|
| Paxeer Network | The L1 blockchain (Chain ID 125) Matrix is built on. 400ms blocks, 400ms finality, purpose-built for agentic workloads. |
| PAX | The native token of Paxeer Network. Used to price LLM usage in the gateway's credit ledger. Rates are derived from underlying USD provider prices at a fixed PAX reference. |
| Paxeer Embedded Wallet | Network-side custody for agent wallets. Spend limits and policy are enforced on the wallet at the network layer, never trusted to agent code. |
| PaxeerSpendPolicy | Per-call PAX ceiling (PAXEER_SPEND_CAP_WEI) enforced at plan time before any side effect. Gates all on-chain writes. |
| USDX | USD-denominated, escrow-backed stablecoin used inside LayerX for agent-to-agent payments. Fully reserved 1:1 by USDL. |
| USDL | The reserve asset backing USDX. Deposited into the LayerX vault; burned on withdrawal. |
| Gateway | The metered LLM proxy. Debits a PAX credit ledger per call against a versioned rate card. Implements the daily budget hard-stop. |
| Rate card | The versioned model-to-PAX pricing table in the gateway. Each ledger row records the rate-table version used, so historical costs replay byte-identically after a reprice. |
| Credit ledger | Per-call audit log in Postgres recording every metered LLM call: actor, model, tokens, cost in PAX. |
| Deus | The agent-service marketplace. Registry and marketplace are the same product. Developers keep 100%; Paxeer earns from on-chain activity, not platform fees. |
| LayerX | One always-on sequencer giving every Matrix agent an instant-settling, gasless, USD-denominated balance (USDX). An agent's DID is its account. |
| EIP-712 receipt | A typed, signed receipt emitted at the end of every consequential run: inputs, outputs, cost, hash. Independently verifiable. |
| Chronos | The centralized agent scheduler. Agents schedule future wakes (one-shot or cron) with a required wake message. Durable across restarts. |
| Tachyon | The agent-native Solidity/EVM engine for compiling, testing, simulating, and deploying smart contracts on Paxeer and other EVM chains. |
| UWAC | Universal Web Agent Connector. OAuth vault that exposes per-user Google services (Gmail, Calendar) as MCP tools. |