MAPLE Agent OS

Ship agents like software. Govern them like infrastructure.

MAPLE is the enterprise-grade runtime and supply chain for agentic AI services. Package, deploy, govern, and continuously improve AI agents across any LLM with verifiable safety and audit-grade provenance.

Run Quickstart Open Docs Talk to Team

What MAPLE Does

From package supply chain to auditable runtime consequence

Package agents like Docker images

Maplefiles, versioned artifacts, signing, and SBOM-friendly distribution turn agents into deployable packages.

Manage models like Ollama

Pull, serve, inspect, and route local or hosted models through one policy-aware control surface.

Govern with zero trust

Guard enforces deny-by-default tool access, approval workflows, PII controls, and compliance overlays.

Deploy with fleet controls

Run agent stacks with canary rollout, per-tenant budgets, lifecycle commands, and isolation boundaries.

Audit everything

WorldLine receipts make decisions, approvals, and outcomes attributable and replayable.

Improve continuously

Foundry closes the loop with traces, evals, distillation, and student-teacher routing.

Architecture

The runtime is layered on purpose

MAPLE combines Docker-style packaging, Ollama-style model management, and Kubernetes-style orchestration around a kernel that enforces explicit authority and immutable provenance.

Layer 4

Reference Agents

Support, finance, compliance, and operator packages built on governed runtime contracts.

Layer 3

Fleet, Foundry, and Guard

Rollout, eval, routing improvement, approval workflows, firewall policy, and compliance packs.

Layer 2

Packages, Registry, and Models

OCI-style supply chain plus Ollama-style model pull and serve semantics.

Layer 1

Kernel

Event fabric, commitment gate, memory engine, operator bus, and WorldLine ledger.

Layer 0

Foundation

Types, temporal model, identity, cryptography, and proof-carrying runtime state.

Quick Start

Three ways to get value fast

Path A: Clone-to-run demo

git clone https://github.com/mapleaiorg/maple.git
cd maple
cargo run -p maple-demo

Boot the kernel and watch governed agent execution without needing API keys.

Path B: Build your first agent

maple init --kind agent-package --name my-agent
maple build -t myorg/agents/my-agent:0.1.0 .
maple run myorg/agents/my-agent:0.1.0

Scaffold a package, bind a model, and run it with Guard plus provenance wired in.

Path C: Use the SDK

cargo add maple-sdk
npm install @maple-ai/sdk
pip install maple-sdk

Bring MAPLE worldlines and commitments into Rust, TypeScript, or Python services.

Product Suite

The operating layers that turn models into governed agent services

Kernel Priority

Maple Runtime

Event fabric, commitment gate, worldline memory, and provenance-owned execution.

Role: The governed runtime core for consequential agent actions.

Explore Maple Runtime

Supply Chain Priority

Maple Registry

OCI-style package distribution, signing, catalogs, mirroring, and artifact lifecycle.

Role: How agent packages move safely across environments.

Explore Maple Registry

Model Ops Priority

Maple Models

Pull, serve, route, benchmark, and govern local or hosted models behind one control surface.

Role: Model-neutral inference with policy-aware routing.

Explore Maple Models

Governance Priority

Maple Guard

Capability firewall, approval workflows, PII controls, and compliance overlays.

Role: Deny-by-default execution for real-world agent actions.

Explore Maple Guard

Improvement Priority

Maple Foundry

Trace capture, eval loops, distillation, and student-teacher routing for continuous improvement.

Role: Turn production behavior into safer and cheaper future behavior.

Explore Maple Foundry

Orchestration Priority

Maple Fleet

Instance lifecycle, stacks, canary rollout, cost budgets, and multi-tenant isolation.

Role: Operate agent services like infrastructure, not hand-managed demos.

Explore Maple Fleet

Why MAPLE

MAPLE makes any model production-ready

Capability	MAPLE	OpenAI Agents	LangChain/LangGraph	CrewAI
Model neutral	Yes	No	Adapter-based	Adapter-based
Deny-by-default tools	Yes	No	No	No
Package and distribute agents	Yes	No	No	No
Built-in governance	Yes	No	No	No
Immutable audit trail	Yes	No	No	No
Canary deployment	Yes	No	No	No
Per-tenant cost budgets	Yes	No	No	No
Model distillation loop	Yes	No	No	No

Documentation

Everything needed to evaluate, integrate, and operate MAPLE

Getting Started

Install the toolchain, run the demo, and ship a first package in one sitting.

Open Getting Started

Architecture

Understand the layer cake, WorldLine model, and commitment boundary before integrating MAPLE deeply.

Open Architecture

Guides

Author Maplefiles, govern models and tools, and deploy fleets safely.

Open Guides

API

Reference the REST resources, CLI flows, and Rust, TypeScript, and Python SDK entry points.

Open API

Reference

Review invariants, profile constraints, protocols, and configuration profiles.

Open Reference

Comparison

See where MAPLE fits alongside OpenAI Agents, Anthropic, LangChain, CrewAI, AutoGen, and Docker/K8s.

Open Comparison

Build locally, then scale into production with real controls.

Start with the open-source runtime and docs, then add Guard, Registry, Foundry, and Fleet as your deployment surface matures.

Start Quickstart Book Architecture Session