Secure, verifiable programs for governed AI-agent systems.

Website · Quickstart · Status · Roadmap · Apache-2.0

Argorix Lang

Argorix Lang is a compiled language and runtime for communication between AI agents under explicit policy, capability, evidence, and provider boundaries. Programs are parsed, checked, lowered to Argorix IR and bytecode, verified, and executed by a deterministic VM.

The current toolchain is implemented in Rust. The project is progressively bootstrapping a smaller systems subset, Argorix Core 0.1, so that the compiler and runtime can ultimately be implemented in Argorix itself.

Rust is the forge. Argorix Lang is the sword.

Project status

Area	Current state
Latest release	v1.0.1 — see supported versions
Workspace version	1.0.0
Compiler and VM	Rust implementation
Agent language	Parser, semantic checks, IR, bytecode, verification, and deterministic VM
Runtime profiles	dry_run, simulated, and governed sandboxed_external planning
Core bootstrap	Core 0.1 parses, type-checks, lowers to verified IR, and executes through the transitional C backend and the C1 runtime
Core standard library	ESP-009 in progress: Buffer<T> and Arena<T>/Handle<T> execute; the collections and serialization written in .argx are pending
Conformance	Runtime cases, a regression corpus, a known-gap corpus, and a differential generator checked against a spec-derived oracle, on GCC and clang
Self-hosting	In progress; not achieved yet
Rust independence	Planned and gated; not achieved yet

The current release is an early-stage secure multi-agent runtime MVP. It is not a production certification, a general-purpose sandbox, or proof that every declared trust or security property has been externally verified.

Quickstart

Requirements

• Rust stable with cargo.
• Node.js 18.18 or newer only for the optional web demo.

Build and test

cargo build --workspace --locked
cargo test --workspace --locked

The main binaries are written to target/debug/:

• argorixc — compiler and verifier;
• argorix-vm — deterministic VM and evidence tooling;
• argorix-conformance — conformance-suite runner.

Validate and compile an Argorix program

cargo run -p argorixc -- check examples/runtime_mvp_v100.argx
cargo run -p argorixc -- emit-bytecode examples/runtime_mvp_v100.argx
cargo run -p argorixc -- verify-bytecode examples/runtime_mvp_v100.argx

Run and verify evidence

cargo run -p argorix-vm -- run examples/runtime_mvp_v100.argbc.json \
  --dry-run \
  --reactive \
  --inject "User:ResearchAgent:tell:UserPrompt" \
  --security-report report.security.json \
  --trace-out report.trace.json \
  --evidence-bundle report.evidence.json

cargo run -p argorix-vm -- verify-evidence report.evidence.json
cargo run -p argorix-conformance -- run conformance/suite.v100.json

PowerShell users can place each command on one line or replace Bash line continuations with PowerShell backticks.

Argorix Core bootstrap

Core 0.1 is the systems subset used by the self-hosting program. Core files are explicitly versioned and begin with:

core 0.1;
module example.main;

The stage0 frontend can currently perform syntax and semantic validation:

cargo run -p argorixc -- core-check tests/selfhost/spec/valid/lexer.argx

This command does not yet lower Core to executable IR or run Core programs. Those capabilities belong to the next bootstrap gates. The historical agent compiler and the Core frontend remain deliberately isolated so that one syntax cannot be silently interpreted as the other.

Core 0.1 currently covers the constructs needed to express a lexer, recursive parser, AST, and symbol table, including fixed-width integers, arrays, slices, buffers, arenas, typed handles, structs, enums, exhaustive matching, functions, recursion, lexical scopes, loops, modules, and imports.

See spec/core/README.md and the executable corpus under tests/selfhost/spec.

Runtime boundaries

Argorix follows one governing rule:

Runtime may execute only what governance explicitly permits.

• dry_run validates and records trace/evidence without provider execution.
• simulated uses the deterministic in-process simulated provider.
• sandboxed_external remains blocked unless the program and invocation pass every adapter, operation, policy, hardening, evidence, governance, audit, and fail-closed check.

Core Argorix does not ship a mandatory provider SDK and does not make arbitrary HTTP, shell, tool, MCP, or A2A calls. Provider endpoints and secret references are represented as redacted references; secret values must never be embedded in source, bytecode, traces, reports, or evidence bundles.

Several language declarations describe governance or trust metadata. A declaration is not evidence that an external event occurred:

• a declared MCP or A2A bridge is not a connected bridge;
• a dry-run identity or handshake is not authenticated identity;
• a trust-ledger hash chain is not a blockchain or immutability guarantee;
• a mapped control is not regulatory approval or legal certification;
• post-quantum readiness metadata is not proof of post-quantum security.

For the maintained security policy and disclosure process, read SECURITY.md.

Architecture

.argx source or package
  -> lexer and parser
  -> semantic, capability, and policy checks
  -> Argorix IR
  -> versioned Argorix Bytecode
  -> bytecode verification
  -> deterministic VM and scheduler
  -> governed provider/tool boundary
  -> trace, SecurityReport, and EvidenceBundle

The bootstrap path is separate and deliberately incremental:

Rust stage0
  -> parse and check Core 0.1
  -> executable Core IR and verifier
  -> temporary C backend and minimal runtime
  -> compiler phases written in .argx
  -> stage1/stage2 equivalence
  -> native backend and removal of Rust from required product builds

Repository map

Path	Purpose
crates/argorixc	Compiler CLI
crates/argorix_parser	Historical agent parser and isolated Core frontend
crates/argorix_semantics	Semantic and security checks
crates/argorix_ir	Intermediate representation
crates/argorix_bytecode	Bytecode lowering and verification
crates/argorix_vm	VM library
crates/argorix-vm	VM CLI
crates/argorix_conformance	Conformance runners and executable models
spec	Normative contracts and bootstrap specifications
conformance	Versioned suites and policy/model fixtures
tests/selfhost	Core bootstrap corpus
examples	Valid programs, packages, and bytecode fixtures
demo/argorix-chatbot-runtime	Optional governed chatbot demo

Demo

The web demo exercises contracts, policy, evidence, and fail-closed input handling. Build the Rust workspace first, then:

cd demo/argorix-chatbot-runtime
npm install
cp .env.example .env.local
npm run dev

The default configuration is plan-only and does not contact an external provider. See the demo documentation for the explicit sandboxed-provider configuration and its boundaries.

Roadmap

The project separates three outcomes that must not be conflated:

1. Independent toolchain — compiler, verifier, VM, packages, signatures, and essential tools no longer require Rust in product builds.
2. Functionally complete agent platform — authenticated communication, governed execution, recovery, tooling, and complete reference applications.
3. Production readiness — sustained reliability, independent security validation, external beta evidence, governance, support, and release gates.

The current source of truth is:

• PLAN_MAESTRO_ARGORIXLANG.md — maturity and product plan;
• PLAN_ESPADA_INDEPENDIENTE.md — technical path from Rust stage0 to an independent Argorix toolchain;
• tasks/madurez/BACKLOG.json — machine-readable status and dependencies.

Passing a bootstrap gate does not by itself prove production maturity or a security guarantee. Each completed gate links to reproducible evidence and states what remains unproven.

Contributing

Contributions are welcome. Please read CONTRIBUTING.md and GOVERNANCE.md, use Conventional Commits, include a DCO sign-off, and keep behavioral claims tied to tests or reproducible evidence.

git commit --signoff -m "feat: describe the change"

License

Argorix Lang is licensed under the Apache License 2.0.