Implementation Architecture

This section maps the source-code architecture that turns matic from an ontology and set of schemas into a runnable multi-agent operating system. It shows where the hard contracts live, how signals become executions, how filesystem and git boundaries are enforced, and where the CLI, daemon, channels, runtimes, and verification layers meet. For founders, platform engineers, and operators, this is the quickest way to understand which subsystem owns which responsibility before reading the deeper implementation pages.

System Shape

Start here for the repo-level layout, package dependency rules, and the top-level split between shared libraries and runnable processes.

Core Contracts and Type System

Read this for the canonical primitives, schemas, interfaces, and adapter contracts that keep the rest of matic aligned across packages and workstreams.

Persistence and Source Control

This page covers the filesystem-first storage model, append-only records, worktree-aware writes, and the git layer that preserves matic's operational boundaries.

Signal Flow and Execution Engine

Use this to follow the main runtime path from inbound signal through routing, activation, planning, execution, iteration, and budget control.

Integration Surfaces

This page explains how matic connects to agent runtimes, human channels, MCP tooling, and plugins without collapsing its core contracts.

Runnable Processes

Read this for the thin application layer: the CLI, the daemon, their IPC split, and the host-side processes that make the runtime operable day to day.

Cross-Cutting Decisions and Verification

This page captures the architectural decisions that cut across packages and the verification strategy used to prove the whole system behaves as intended.