LLM Index

Structured index of all Matrix documentation pages with descriptions, optimized for LLM and agent consumption.

This page provides a structured index of all Matrix documentation pages with descriptions, optimized for LLM and agent consumption.

Core Documentation

Introduction: Overview of Matrix, the two rails (Neo and MCL), and the full stack
Quickstart: Clone, build, compile your first intent, drive an end-to-end walk, run the daemon
Core Concepts: Intents, frames, verbs, skills, cortex memory, envelopes, attestation, replay invariant
Glossary: Definitions for all Matrix terms — rails, intents, frames, cortex, skills, envelopes, MCP, PAX

User Guide

Chat: How to interact with Neo through the chat interface
Skills: Using and authoring skills for Matrix
Wallet: Managing PAX credits, metering, LayerX settlement, spend caps

Developer Documentation

Architecture: Layered model, module boundaries, cross-cutting flows, invariants
MCL: Matrix Communication Layer — compiler pipeline, skill authoring, Intent IR
Cortex: Per-actor typed memory graph — journal, taxonomy, snapshots, replay
Executor: Plan walker, lifecycle machine, MCP tool dispatch, daemon
Neo: Default conversational agent — tool-calling loop, memory, recovery
Determinism & Replay: Byte-deterministic replay invariant and CI enforcement
Build, Test & Lint: Makefile targets, CI pipeline, linting
Contributing: Ground rules, commit format, PR workflow
Deployment: Docker image, Fly Machine topology, environment config

API Reference

Overview: Service table, auth patterns, common request/response shapes
Daemon: HTTP + SSE surface — /chat, /events, /messages, /intents, /me
Gateway: Metered LLM proxy, PAX credit ledger, rate card
Router: JWT verify, Fly Machine wake, reverse proxy
Chronos: Agent scheduler — alarms, wakes, cron expressions
Deus: Agent-service marketplace — registry, discovery, metered invoke, receipts
LayerX: Settlement fabric, custody spine, agent balances
UWAC: Universal Web Agent Connector — OAuth vault, per-user MCP tools
Tachyon: Agent-native Solidity/EVM engine — compile, test, simulate, deploy
CLI: Command-line interface subcommands and flags

Model Context Protocol (MCP)

Overview: URI scheme, transport (stdio/streamable-HTTP), credential rules
Agent Manifests: DID-bound JSON schema, field table, locked rules
Tool Servers: Catalog of 12 MCP servers and their tools
Writing a Tool Bridge: Step-by-step guide to building a new MCP bridge
Server Templates: Reusable templates for common tool patterns

Deep Reference: Cortex

Overview: Architecture and design decisions
Store & Journal: Pebble DB, append-only journal, canonical CBOR
Memory Taxonomy: 9-type taxonomy, deterministic rendering forms
Write API: Mutation operations, seq monotonicity
Find & Query: Semantic search, HNSW vector index, filters
Context Bundle: Assembling context for agent consumption
Embedder & Vector: Embedding model, pure-Go HNSW
Edges & Graph: Relationship modeling, graph traversal
Snapshot & Proofs: Merkle-anchored snapshots (MMR + SMT-256)
Salience: 5-factor cold score, EMA weight learner
Attest & Compact: Terminal state attestation, compaction
Scope: Per-actor isolation, multi-tenant design
Replay: DropDerived + rebuild, OverallRoot verification

Deep Reference: MCL

Overview: Compiler architecture and design decisions
Compiler Pipeline: Prose → Intent IR → PlanTree
Intent IR: Frame structure, verbs, objects, constraints
Envelope: Signed lifecycle records, ed25519, canonical CBOR
MatrixScript: SKILL.mtx syntax, §PROCEDURE blocks
Skill Authoring: Writing SKILL.mtx + SKILL.md
mclc CLI: Compiler CLI reference
LLM Client: LLM integration, prompt structure

Deep Reference: Neo

Overview: Agent architecture and design decisions
Control Loop: Tool-calling loop, decision logic
Memory System: Paged cortex memory, recall
Recall Lane: Memory retrieval and ranking
Conversation Store: Thread management, history
Core Execute: Delegation to MCL for irreversible work
Writeback & Consolidation: Memory updates, compaction
Tool Surface: Available tools, MCP integration
LLM Client: LLM provider integration
Config System: Configuration options

Deep Reference: Chronos

Overview: Scheduler architecture
Architecture: System design, components
API Reference: Endpoints, request/response
Auth System: Authentication, authorization
Config System: Configuration options
Data Model: Alarm, wake, schedule structures
Dispatch Worker: Wake delivery, retry logic
Schedule Engine: Cron parsing, fire-time calculation
Tool Surface: MCP tools for scheduling
Wake Delivery: Wake message format, delivery guarantees

Deep Reference: Tachyon

Overview: EVM engine architecture
Daemon: Background service, lifecycle
API Server: HTTP endpoints
RPC Server: JSON-RPC interface
MCP Server: MCP tool integration
Compiler: Solidity compilation
Engine: Execution engine
ABI Encoder: ABI encoding/decoding
EVM Client: Blockchain interaction
Deployer: Contract deployment
Wallet: Key management, signing
Registry: Contract registry
Simulate: Transaction simulation
Tester: Testing framework
Chains: Multi-chain support
Config: Configuration
Types: Type definitions

Deep Reference: Deus

Service Entrypoints: API server, docs, migrations
Discovery & Embedding: Service discovery, embedding, indexing
Receipts & Metering: EIP-712 receipts, vouchers, channels
Chain Access & Auth: Wallet clients, registries, manifests
Hosting & Budgets: Hosting backends, budget controls
Solidity Contracts: Contracts, deployment, tests

Deep Reference: LayerX

LayerX Daemon: Auth, chain accumulator, store, ledger
Settlement Contracts: SettlementAnchor, IERC20, EIP712
Forge Integration: Forge std, fixtures, test support

Deep Reference: Skills

Agent Engineering: API design, architecture, evaluation
Planning & Review: Planning, QA, code quality, CLI, performance
React & Design: React, design system, styling, writing
Brand & Self-Improvement: Brand, learning, commits, patterns
Tooling & Manifests: Tooling, manifests, index building

Deep Reference: Standards

Contribution Workflow: Code review, changelog, licenses
Testing Rules: Testing rules, QA guidance
Patterns & Architecture: Patterns, heuristics, performance
Hook & Lifecycle: Lifecycle conventions, language rules
Security Policies: Security rules, disclosure

FAQ

General: General questions about Matrix
Users: Questions for end users
Developers: Questions for developers
Ops: Questions for operations
Billing & PAX: Questions about billing and PAX credits
Security: Security questions and policies