Public experimental tool

Install Axiom to generate guardrails before the agent ships code.

Axiom OS is the local, open-source-oriented path for AI-assisted builders. Its job is to turn `app.ax` into simulated policy paths, generated checks, route skeletons, approval contracts, audit contracts, and a next command to run before code can access data or take action. It is not tied to one model or vendor; it works with any coding agent that can read project files and run local commands.

See the first flow Set the rules Why Axiom

Who it is for

Axiom OS is being built for people using Codex, Claude, Cursor, Copilot, DeepSeek, Qwen, Mistral, internal models, or similar coding agents who want more than prompt instructions but do not want a heavy security platform before they have a working app.

Builders

Advanced vibe coders

Start with a template, generate policy checks from `app.ax`, and keep the first workflow simple.

Developers

Not a toy

The simple flow still produces actors, data classes, capabilities, policy, approvals, brokers, and audit.

Agents

Deterministic next steps

`axiom doctor` and `axiom next` give coding agents explicit repo-aware commands.

The first five minutes

This is the first flow: easy enough for a non-expert builder and concrete enough that a serious developer can see what gets checked. 

axiom try --out /tmp/axiom-starter

To set the app-specific rules, generate a plain-language outline: 

axiom define --guided --cwd /tmp/axiom-starter

The explicit loop stays available when the agent is already inside a project: 

axiom init --template local-private-app --agent codex
axiom doctor
axiom next
axiom simulate-examples
axiom next
axiom generate app.ax --target typescript --out generated
axiom next
axiom verify app.ax --target typescript --out generated --write
The shortest useful loop: initialize the contract, check it, simulate policy, then generate artifacts for ordinary code.

What the project gets

Axiom does not replace the coding agent or make the model obedient. It gives the project a contract, deterministic checks, simulation examples, generated artifacts, and verification evidence so implementation work does not quietly add new data access or actions outside the rules.

1
`app.ax`The readable source for what the app is for, what it can access, what needs approval, and what must be audited.
2
Generated artifactsPolicy evaluators, route skeletons, approval contracts, broker guards, audit contracts, and tests make the rules executable.
3
Policy simulationsStarter scenarios prove allow, deny, and approval paths before generated artifacts are used.

What it does not promise

Axiom OS is not a guarantee that non-developers can safely ship high-risk systems alone. It is a safer default path for AI-assisted building.

No magic

Not a zero-day shield

Axiom reduces cases where an agent quietly adds too much access. It does not eliminate ordinary security engineering.

No replacement

Frameworks still matter

Browsers, servers, databases, and deployment platforms still run normal software artifacts.

No model policy

LLMs do not decide access

Models can draft and explain, but final policy decisions must be made by deterministic app code.

Future editions

Axiom Enterprise and Axiom Government can build on the same core with stricter policy profiles, evidence reports, deployment verification, and audit workflows. Axiom OS keeps the local contract model visible before those heavier editions exist.

Read the editions note