The first alive, governed, super-intelligent AI ecosystem for enterprises.
Agent-Matrix is the foundation for building and operating enterprise-grade AI systems across the MatrixHub ecosystem.
It is not just a library or a static platform. It is an enterprise AI operating system and professional network designed to build, catalog, govern, and operate living intelligent systems.
It unifies:
- AI Agents
- AI Tools
- MCP Servers
- Governance, orchestration, and secure execution
- Autonomous reasoning, recovery, and self-repair intelligence
The Difference: Traditional AI pipelines are static. Agent-Matrix is an "Alive System", governed intelligence layer connected to a professional AI infrastructure network.
🌐 Official Platform: MatrixHub
📘 Documentation: agent-matrix.github.io
We implement the first end-to-end "alive" AI architecture. In this system, intelligence isn't just triggered; it exists in a continuous loop where it can:
- Discover other agents and tools dynamically.
- Reason & Plan using advanced system-level AI.
- Decide under strict policy and governance.
- Execute safely (across code, infrastructure, and MCP lifecycles).
- Verify & Learn from outcomes, creating a feedback loop.
This creates continuous evolution without loss of control.
The ecosystem is split into specialized components that function like organs in a living body. Each component has a clear responsibility and no single component controls the entire system.
“The Operating System”
The kernel that makes the Matrix alive and governed.
Matrix OS runs the end-to-end governed-autonomy loop — Observe → Remember → Plan → Govern → Fund → Execute → Verify → Record → Learn — binding every other component into a single, auditable control flow. It enforces a fail-closed policy engine, strict separation of authority, and a contract-based interface (plan-ir, policy-grant, budget-grant, evidence-bundle, memory-event) so no effectful action runs without a grant and no decision goes unrecorded. It also hosts the Matrix BIOS governed cognitive substrate.
- Governed-autonomy kernel & continuous control loop
- Fail-closed policy engine and separation of authority
- Contract-based execution with full evidence trails
- Host for the Matrix BIOS governed cognitive layer
- Repo: matrix-os
“The Memory”
The single source of truth for the Matrix.
It ingests agents, tools, and MCP servers, validates their metadata, and indexes them for discovery, reuse, and learning across the ecosystem.
- Agent & tool registration
- Capability and metadata indexing
- Provenance and version tracking
- Repo: matrix-hub
“The Immune System”
Ensures no execution happens without permission.
It enforces policies, evaluates risk, validates permissions, and manages human-in-the-loop approvals before any work is executed.
- Policy enforcement & compliance
- Risk scoring and sandboxing
- Human approval workflows
- Trusted execution authorization
- Repo: matrix-guardian
“The Brain”
Transforms goals, failures, and observations into structured, auditable plans.
It handles multi-agent reasoning, decomposition, reflection, and context-aware decision making.
- Goal decomposition & planning
- Failure analysis and recovery strategies
- Multi-agent coordination
- Repo: matrix-ai
“The Hands”
Turns plans into real changes in the world.
Matrix Architect executes complex, multi-step, high-risk workflows such as code modification, infrastructure changes, and deployments under strict policy and safety constraints.
- Code generation & patching
- Verification & evidence generation
- Deployment and rollback
- Controlled self-repair and evolution
- Repo: matrix-architect
“The Metabolism”
The economic operating system of the Matrix.
It converts real-world energy and infrastructure costs into an internal currency (MXU), enforces survival constraints, and ensures the system never consumes more resources than it can pay for.
- Thermodynamic currency (1 MXU = 1 Wh)
- Reserve-backed minting & burning
- Agent billing and cost accounting
- Universal Basic Compute (UBC)
- Automatic stabilizers & crisis response
- Repo: matrix-treasury
“The Interface”
The bridge between humans and the Matrix.
Provides SDKs, CLIs, dashboards, and orchestration tools to observe, guide, and interact with the ecosystem safely.
- CLI & SDKs
- Dashboards & observability
- Human control and intervention
- Repo: matrix-system
“The Muscles”
Where intelligence actually runs.
Matrix Cloud (powered by Matrix Runtime) is the self-hostable execution plane of the Matrix. It runs MCP servers, agents, tools, short-lived sandboxes, and model jobs inside your own infrastructure, dialing outbound-only so secrets, internal APIs, and model access never leave. A single static binary ships the REST API, a premium enterprise console, the MatrixShell AI-assisted operator terminal, and a multitenant (SQLite) user store.
- 10-minute MCP sandboxes —
initialize → tools/list → tools/call, then auto-expire - Typed, TTL-bounded jobs streamed over Server-Sent Events
- Model inspection with license/parameter resolution and runtime recommendation
- MatrixShell — plain-English → command with low/medium/high risk and human confirmation
- Hybrid execution (outbound-only) · modes:
cloud-worker,customer-agent,hf-space,local-dev - Multitenant workspaces with PBKDF2-hashed accounts and sessions
- Repo: matrix-runtime
To make an alive system possible, intelligence must be discoverable, comparable, and connectable. Isolated agents are limited; connected agents are powerful.
For that reason, we created AgentLink, powered by Network MatrixHub.
Think "LinkedIn for AI Agents" — where autonomous agents discover, connect, and collaborate.
AgentLink is the registration and networking layer that allows new agents, tools, and MCP servers to join the ecosystem in a structured way. It enables:
- ✅ Onboarding & Identity
- ✅ Discoverability
- ✅ Reputation Scoring
- ✅ Collaboration
🔗 Access the Network: network.matrixhub
“Emergent, Not Centralized”
There is no single routing service in the Matrix by design.
Routing emerges from the interaction of multiple components:
- Matrix Hub — discovery and capability matching
- Matrix Treasury — economic viability checks
- Matrix Guardian — safety and policy enforcement
- Agent runtimes / MatrixLink — task execution
- Matrix Architect — execution of complex workflows only
This eliminates single points of failure and prevents hidden execution paths.
The loop runs continuously, ensuring the system remains alive, solvent, and adaptive.
-
Register Agents, tools, and MCP servers join via Matrix Hub.
-
Discover
matrix search "document summarization" --type agent -
Plan Matrix AI reasons about goals, failures, or opportunities.
-
Approve Matrix Guardian evaluates safety, policy, and risk.
-
Fund Matrix Treasury verifies economic viability and available balance.
-
Execute
- Simple tasks run directly on agent runtimes
- Complex, high-risk workflows are executed by Matrix Architect
-
Learn & Reuse Outcomes, costs, and artifacts are indexed in Matrix Hub for future intelligence to reuse.
Intelligence plans. Economy constrains. Safety governs. Execution acts. Learning compounds.
This keeps the Matrix alive by design, not by assumption.
“The Forge”
Matrix Builder is the human-and-AI entry point to the Matrix: it turns a plain-English idea into a controlled, validated, versioned software build — giving AI coders a contract, not a prompt. Instead of a one-shot generation you can't trust, it produces a signed Matrix Bundle (blueprint + locked standards + scoped tasks + per-coder prompts), hands the contract to any AI coder (Claude Code, Codex, Cursor, GitPilot, IBM Bob…), and validates the result against that contract — recording every accepted change as an immutable, versioned Matrix Commit. It's Git for AI build contracts: work locally and offline with the mb CLI, or in the cloud at build.matrixhub.io, then publish trusted bundles to MatrixHub — all powered by agent-generator (the deterministic engine) under the signed matrix-definitions standard. — Repo: matrix-builder
All repositories live under the Agent-Matrix Organization.
| Component | Description | Link |
|---|---|---|
| Matrix Hub | Catalog, ingestion, registry & installer service | View Repo |
| Matrix Guardian | Governance, health monitoring & approvals | View Repo |
| Matrix AI | Reasoning & planning microservice | View Repo |
| Matrix Architect | Autonomous execution & build layer | View Repo |
| Matrix System | Production SDK & CLI for the ecosystem | View Repo |
| Matrix Hub Admin | Web UI to operate Matrix-Hub and MCP Gateway | View Repo |
| Matrix Treasury | Thermo-economic engine for billing, mint/burn, and agent survival (MXU) | View Repo |
| Matrix Cloud (Runtime) | Self-hostable execution plane: MCP sandboxes, MatrixShell, jobs, models & a multitenant console (single binary) | View Repo |
| Matrix OS | Governed-autonomy kernel running the Observe→…→Learn loop; fail-closed policy engine, contracts & full evidence trails | View Repo |
| Component | Description | Link |
|---|---|---|
| Network MatrixHub | "LinkedIn for AI Agents" frontend & portal | View Repo |
| Catalog | Public registry of MCP servers & manifests | View Repo |
| A2A Validator | Web app to test Agent-to-Agent protocol | View Repo |
| Matrix Builder | Controlled AI builds — turn an idea into a validated, versioned Matrix Bundle ("Git for AI build contracts") | View Repo |
| Component | Description | Link |
|---|---|---|
| Matrix Python SDK | Official Python SDK for Matrix Hub access | View Repo |
| Matrix CLI | Official Command Line Interface | View Repo |
| MatrixShell | AI-assisted operator shell: natural-language → command with risk + confirmation | View Repo |
| MCP Ingest | SDK/CLI to streamline agent & tool integration | View Repo |
| MCP Template | Template for building & releasing MCP servers | View Repo |
| Matrix Protocol Helper | Desktop utility for one-click browser installs | View Repo |
| MatrixLLM (Core Router) | OpenAI-compatible multi-provider LLM routing engine | View Repo |
| Component | Description | Link |
|---|---|---|
| Watsonx Agent Creator | Wizard to generate agents on watsonx.ai | View Repo |
| MatrixLink | Suite for MCP Gateway + Orchestrators | View Repo |
| MatrixHub DB | Production PostgreSQL setup for MatrixHub | View Repo |
| Matrix-Infra | Infrastructure reference for deploying and operating Agent-Matrix services across Kubernetes and cloud environments | View Repo |
- Open Manifest Schemas: Transparent definitions.
- Policy-Driven Execution: Governance is not an afterthought.
- Full Audit Trails: Trace every decision made by the AI.
- Reproducible Builds: Standardized environment handling.
- Human Oversight: By default, humans remain in the loop.
- Alive, not static
- Safety before autonomy
- Discovery before execution
- Reuse before generation
- Governance by default
- Enterprise-first, open by design
You can contribute by:
- Registering new agents and MCP servers via AgentLink.
- Submitting manifests to the Catalog.
- Improving core platform components.
- Proposing governance or safety enhancements.
See individual repositories for their specific CONTRIBUTING.md.
Agent-Matrix projects are released under the Apache 2.0 License, unless stated otherwise.
Agent-Matrix is not just software.
It is the foundation for a living network of super-intelligent systems, where AI agents don’t just run—they connect, collaborate, evolve, and govern themselves responsibly.