SYSTEM COMPILATION FOR AI

We stopped asking AI to write systems. We made it compile them.

Bring Claude, Codex, Cursor or your own model. Define the system. DevMatrix deterministically compiles it into production code, tests, migrations, infrastructure and evidence.

Free · BYOK · Python/FastAPI · You own the code

Bring your own model key for authoring. Compilation itself calls no model — that's the point.

ledger.dmxemitted
spec Ledger {
module Accounts {
entity Account {
tenant_id: TenantId
balance: Money @currency(ISO4217)
}
api REST { auth: JWT @multi_domain }
}
module Payments {
flow Transfer { saga: orchestration
steps: [debit, credit] }
}
compile {
targets: [python_fastapi, java_spring]
db: postgresql @rls, secrets: vault
}
}
Compiler Wall
FastAPI + Spring servicesSpring in testing
PostgreSQL schema + migrations
RLS + auth policies
Contract + security tests
CycloneDX 1.5 SBOM
Ed25519 replay certificate
Same spec in, same artifacts out — every run.
Evidence

Don't believe the demo. Inspect the build.

Nothing here asks for trust. What is published comes with the hashes to check it, and what is not published yet says so on the card.

Published today

Sealed builds in the public repository, each carrying the fingerprint and hashes that tie the artifacts to the specification they came from. The verifier is public as well, so checking a build does not mean running our tooling or taking our word for the result.

CRM SaaSLands at launch
Total LogisticsLands at launch
IdentityLands at launch
Bank LedgerLands at launch
Bring your agent

Keep your AI. Give it a compiler.

Ask an assistant for a system twice and you get two systems, neither of which you can reproduce. DevMatrix does not compete with that layer — it consumes it. Your model decides what the system is; the compiler turns that decision into the same code, tests, migrations and infrastructure on every run.

Your team + their LLM

  • Understands the business
  • Drafts the DMX specification
  • Reviews and iterates

Probabilistic · creative

DevMatrix

  • Compiles
  • Verifies
  • Emits code + signed evidence

Deterministic · auditable

Compiler Wall

AI reasons. DevMatrix compiles.

Your key authors the specification. Past the wall the compiler runs on its own and calls no model at all — which is the only reason the same specification can produce the same artifacts twice.

Everything after the spec is deterministic.

Four stages. You write the first one; past the boundary the compiler calls no model at all.

  1. 01

    Specify

    Your team declares the system in DMX — by hand, or with the LLM they already use.

  2. 02

    Compile

    Past the Compiler Wall there is no randomness. Same spec, same artifacts.

  3. 03

    Verify

    250+ quality gates across BLOCK, WARN and INFO, then 1,000+ generated tests per service. Nothing ships around them.

  4. 04

    Ship with evidence

    Production code, infrastructure, tests and a signed evidence pack — from one build.

Requirement changes? Edit the specification and recompile. The fix isn't a patch — it's a new baseline, identical for every service.

What a compilation produces

Click a line. See what it becomes.

This is the source map the compiler signs into every build: every artifact traces back to the node that caused it.

ledger.dmx
spec Ledger {
module Accounts {
}
module Payments {
}
}

Double-entry accounts, transfers and settlement. Four nodes, and everything they cause.

Illustrative DMX shapes, not customer builds. Published figures come from the verified build below.

Change one line

A requirement changes. You edit the specification, not forty files.

Compliance asks for the personal-data column to be encrypted at rest. Here is the entire change.

ledger.dmx
spec Ledger {
module Accounts {
entity Account {
tenant_id: TenantId
pii: Json
}
}
}

Schema and migration

The column is emitted encrypted, with a forward and rollback migration — in every service that touches the field.

Key material wiring

Envelope keys are wired to the secret store the spec already declares. No credential reaches the source tree.

Contracts and serializers

API contracts and serializers are regenerated so the field never leaves the perimeter in clear text.

Tests

New validation and security tests for the field are generated alongside the code, not filed in a backlog.

Evidence, re-signed

Threat model, SBOM and replay certificate are regenerated and signed against the new specification.

Nobody has to remember to do any of it, and nobody can do half of it.

Own the output

It's source code. Open it. Change it. Run it. Own it.

A compiler that produced code you could not leave with would be a hosting bill with extra steps.

Take it with you

Every compiled build downloads whole — sources, tests, migrations and infrastructure — as files you put in your own repository.

Run it without us

The emitted system has no runtime dependency on DevMatrix. The specification and the code are yours, and so is the right to run both.

Audit it with another model

Nothing is minified, generated into a bundle or hidden behind a runtime. Point your own reviewer — human or model — at the diff and have it check our work.

The tests come with it

Contract, behaviour, security and validation tiers, generated against the same specification on every build. They are yours to run in your own pipeline.

No day-one debt

Multitenancy, row-level security, sagas, outbox and hardening are compiled primitives, not patches accumulated by sprint fourteen.

Your stack, not ours

Python and FastAPI on PostgreSQL, on your cloud, with the tooling your team already chose. Java is in testing and is labelled that way everywhere it appears.

What Free compiles

Free compiles complete Python systems — monoliths, with the same engineering quality as everything else we compile. Microservices, additional targets and advanced capabilities are paid.

Free limits the architecture, not the quality.

Developer workflows

Write the specification where you already work.

The specification is the input to the compiler, not a form on our site. Author it in the browser, in your editor, or from the agent you already have open.

In the browser

Workshop

A full DMX editor with grammar-aware completion and validation as you type, version history, and the compile run in front of you. Nothing to install.

In your editor

VS Code Extension

Highlighting, completion and live validation on .dmx files, with your platforms and their status in the sidebar. Sign-in keys live in the OS keychain.

In your agent

DevMatrix MCP

A standard MCP server, so Claude Code, Copilot or Codex reads, writes and validates your specifications directly. The key is scoped to specs — an agent can never trigger a compile.

In Claude Codeclaude-code
/plugin marketplace add devmatrix-ai/devmatrix-mcp
/plugin install devmatrix@devmatrix

Install the DevMatrix plugin and your key is stored in the OS keychain — no plaintext config.

Evidence-ready by construction

The auditor arrives and asks where this line of code came from.

In most organizations that opens weeks of archaeology. Here the answer is a file: every emitted line traces to its specification node, and any third party can rebuild the artifact from the specification plus the compiler version.

SBOM · CycloneDX 1.5

Component inventory of every emitted dependency, signed and timestamped per build.

Source Map · IR ↔ Code

Every emitted line traced to its DMX spec node. Auditor-grade traceability.

Replay Certificate · Ed25519

Cryptographic proof the build is reproducible from the spec + compiler version.

Build Fingerprint + Merkle Root

Byte-deterministic hash tree over the full artifact tree.

Threat Model

Auto-derived from the IR. Lists assets, trust boundaries, and mitigations.

Capability Manifest

Declared capabilities (auth, RLS, encryption, rate limiting…) wired into the build.

Compliance Report

Per-spec dossier of controls covered, gates passed, and unresolved waivers.

Audit Trail

Append-only event log of every compilation, signed and tamper-evident.

Deployment Models

Cloud SaaS is the default. The other three follow your perimeter.

Cloud SaaS · Self-hosted · Air-gapped · Hybrid. The hosted console is where DevMatrix runs unless your security boundary says otherwise.

How each one works

Frequently Asked Questions

Your model can reason about the system. Now give it a compiler.

Request beta access and tell us about the system you want to build. We’ll review your use case and get in touch.

Read the language

The full DMX reference — every block, annotation and type the compiler accepts.

Follow the pipeline

What happens between the specification you write and the artifacts that come out.

Verify a build yourself

The published builds, their fingerprints and the public verifier that checks them.