Determinism for the agent economy.

Matrix Configuration Language

MCL is the declarative configuration system that defines how Matrix agents behave, what tools they can access, how memory is structured, and what execution policies govern their actions. Rather than writing imperative code to configure agents, you declare intent in MCL and the Matrix runtime interprets it deterministically.

MCL configurations are versioned, composable, and auditable. Every agent behavior — from tool selection to memory retrieval to execution constraints — traces back to an MCL document that can be reviewed, diffed, and rolled back.

// Example MCL agent definition
agent "researcher" {
  model        = "claude-4-sonnet"
  system       = file("./prompts/researcher.md")
  tools        = [web_search, fetch, fs_read, fs_write]
  memory       = cortex.research
  policy       = "read-only-unless-approved"
  max_turns    = 50
  timeout      = "30m"
}

Tool Definitions

Every tool available to a Matrix agent is declared in MCL with its full interface: parameter schemas, return types, permission requirements, and rate limits. The runtime uses these declarations to validate tool calls before execution and to present structured tool descriptions to the LLM.

tool "web_search" {
  description = "Search the public web"
  parameters  = {
    query       : string(required)
    max_results : int(default: 5, range: [1, 20])
    topic       : enum("general", "news")
  }
  returns     = { results: array, answer: string? }
  permission  = "read"
  rate_limit  = "30/min"
}

Memory Schemas

MCL defines how agent memory is structured through Cortex schemas. Memory isn't a free-form blob — it's typed, namespaced, and queryable. Each memory domain (knowledge, observations, user preferences, task state) has its own schema that determines what gets stored, how it's indexed, and when it expires.

• Knowledge notes — Persistent facts and observations the agent accumulates across sessions, stored as typed key-value pairs with confidence scores
• Conversation context — Working memory for the current session, automatically summarized and compressed as context windows fill
• User profile — Long-term preferences, communication style, and workflow patterns that persist across all sessions
• Task state — Structured checkpoints for multi-step work, enabling resumption after interruptions or context refreshes

memory "cortex.research" {
  namespace  = "research"
  retention  = "90d"
  
  schema {
    findings    : array<{ claim: string, source: url, confidence: float }>
    open_q      : array<string>
    bibliography: array<{ title: string, url: url, accessed: datetime }>
  }
  
  indexing = "semantic"    // vector similarity search
  eviction = "lru"         // least recently used when at capacity
  max_size = "50mb"
}

Execution Policies

Execution policies are the security and governance layer of MCL. They define what an agent can do autonomously versus what requires human approval, how failures are handled, and what audit trail is maintained. Policies are composable — you can layer a base policy with domain-specific overrides.

policy "standard-agent" {
  autonomy   = "read-free"     // reads are autonomous, writes need approval
  budget     = { session: "$5", daily: "$20" }
  
  on_failure = {
    retry     = 3
    backoff   = "exponential"
    escalate  = "after-retries"
  }
  
  audit      = {
    log_level = "verbose"
    retention = "365d"
    export    = ["stdout", "file://./audit.log"]
  }
  
  // Monetary operations always require user approval
  sign_rule  = "always-approve"
}