The AI OS for
autonomous ventures.

Define a goal, staff a team of AI agents, and let them do the work — on your filesystem, versioned in git, governed by policy.

matic — my-project
$ matic init my-project
Created org: my-project/
Scaffolded roles: engineer, reviewer, planner
 
$ matic run "add auth to the API"
→ planner Breaking down task into subtasks...
→ engineer Writing code (claude-code)...
→ reviewer Reviewing diff against spec...
PR #42 ready — 3 files, 127 lines
How it works

A team, not a chatbot.

matic structures AI work the way organisations do — with goals, teams, tasks, routines, memory, policies, and communication baked into the filesystem.

01 — ORG

One org, many agents

Your org is a git repository. Agents, projects, teams, and policies are directories and markdown files — readable by humans and AI alike.

02 — AGENTS

Persistent actors, not stateless tools

Each agent has identity, memory, competence probes, and experience that evolves through work. They learn from every engagement and compound what they know.

03 — WORK

Signals become outcomes

Inbound signals are classified, routed, and turned into structured work — planned, executed, validated, and delivered. Every state change is a commit.

0new tools to learn
5+provider adapters
agent roles
1init command
The database is a directory

Markdown is
the schema.

No ORM. No migration files. Agent memory, task queues, policies, and decision records are markdown files structured by convention — readable in any editor, diffable in any git client.

Human-readable by default

Every file your agents produce is a markdown document. Inspect, edit, or override agent state directly in your editor.

Git handles concurrency

Agents work on branches. Merges surface conflicts. No custom locking mechanism — just the distributed system you already know.

Zero vendor lock-in

Export your entire agent team by zipping a folder. Import it on any machine with Bun installed.

my-project/
├── .matic/                         # org config
│   └── org.md
│
├── roles/
│   ├── engineer/
│   │   ├── system.md              # identity
│   │   ├── memory.md              # long-term
│   │   └── tasks/
│   │       ├── done/
│   │       └── active.md          # current
│   │
│   └── reviewer/
│       ├── system.md
│       └── inbox/                 # queue
│
└── messages/                      # agent IPC
    └── engineer→reviewer.md
Agent runtime adapters

Works with every
runtime you already use.

Swap runtimes per agent, per task, or per environment. matic's adapter layer keeps your org logic identical regardless of what's running under the hood.

CC
Claude Code
Anthropic's agentic coding CLI — the default adapter for most engineering roles.
recommended
GC
Gemini CLI
Google's command-line agent with long context windows and grounding.
stable
CX
Codex
OpenAI's coding agent via the Codex CLI adapter for GPT-4o and o3.
stable
OL
Ollama
Run fully local models — Llama 3, Mistral, Qwen — with zero data egress.
local
HF
HuggingFace
Connect any inference endpoint — open models on serverless or dedicated hardware.
beta
GR
Groq
Ultra-fast inference for latency-sensitive roles like code review and linting.
beta
xAI
xAI Grok
Grok models via the xAI API — competitive on reasoning and context length.
beta
+
Bring your own
Implement the 4-method Provider interface to connect any model or API in minutes.
open
Core concepts

Built to get smarter.

matic isn't just an agent runner — it ships with a mandatory learning loop. After every engagement, agents consolidate experience, refine probes, and capture institutional knowledge as reusable archetypes.

v0 paradigm

Zero code to start

Declare your org structure in markdown. matic scaffolds the filesystem, wires up the agents, and connects the runtime. No TypeScript until you need it — and when you do, you're extending a clean adapter interface, not wrestling a framework.

# roles/engineer/system.md

You are a senior TypeScript engineer.
You write clean, tested, typed code.
You hand off to reviewer when done.

provider: claude-code
model: claude-sonnet-4-6
Learning Loop

The self-improvement loop

Improvement suggestions are proposed after completed work.

Task completes
Completed work reviewed
Proposes prompt diff
You approve via PR
Roles improve over time

"The best agentic infrastructure is invisible. You shouldn't notice it — you should notice your team shipping faster."

— from the matic.sh design doc

Start with one
command.

No account required. No cloud dependency. Just Bun and a directory.

bunx matic init my-org
Waitlist

An idle user shouldn't mean
an idle org.

Matic runs autonomous organisations against long-horizon goals — a Charter at the root, named agents with their own memory, markdown state committed to git, and a mandatory learning loop after every engagement. Get on the list before the first orgs come online.

First-install accessArchitecture notesMilestones when they land

No spam. Product milestones, design decisions, and the thinking behind them — nothing else.

launchwaitlist@matic.sh

Architecture notes, first-install access, and milestones when they land. Never marketing.