Rust Toolchain · Argorix Lang

Rust Foundation

Built in Rust for security-critical AI infrastructure

The implementation language should reflect the security philosophy of the project.

Argorix Lang is built in Rust because infrastructure for AI safety should start from a secure systems foundation: memory safety, performance, strong typing and explicit control.

Hardware

Rust Core

Argorix Compiler

Bytecode VM

Execution Traces

Memory Safety

Reduced classes of low-level bugs without relying on a garbage collector.

Performance

Suitable for compiler, VM and bytecode execution paths.

Explicit Control

Clear ownership, predictable behavior and systems-level precision.

Strong Typing

Better foundation for semantic validation and structured runtime logic.

Systems-Level Trust

The implementation stack reflects the project's security-first design.

Language Preview

Designed for AI-agent systems

A language surface for tools, models, permissions, traces and controlled execution.

agent_flow.argx argx compiled · UTF-8

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

tool WebSearch {
  capability: "network.search"
  approval: required
}

model Reasoner {
  provider: simulated
  capability: "analysis"
}

agent Researcher {
  input task

  authorize WebSearch
  authorize Reasoner

  guard verify_sources
  trace enabled

  call WebSearch with task -> results
  ask Reasoner with results -> answer

  return answer
}

Language concepts

▸Tools as explicit capabilities
▸Models as declared providers
▸Authorization blocks
▸Runtime traces
▸Verifiable execution paths
▸Designed to evolve toward sandboxing

runtime output

●trace.requested
●trace.allowed
●tool.call.executed
●model.ask.simulated
●result.recorded

Syntax and semantics are still evolving. The goal is to make agent behavior easier to reason about, inspect and control.

Quickstart

Build, verify, run

A stable Rust toolchain is all you need. Compile a contract, verify its bytecode, and export evidence — entirely offline.

Build & verify the toolchain

Compiles argorixc, argorix-vm and the conformance runner.

Compile & run a contract

Validate semantics, emit + verify bytecode, dry-run the VM and export the evidence bundle.

Run the governed chat demo

A Next.js chatbot that shells out to the binaries — plan-only by default, never contacting a provider.

argorix — zsh

# build + test the workspace
$ cargo build --workspace
$ cargo test  --workspace

# validate + verify a contract
$ argorixc check examples/runtime_mvp_v100.argx
$ argorixc verify-bytecode examples/runtime_mvp_v100.argx

# dry-run the VM, export evidence
$ argorix-vm run runtime_mvp.argbc.json \
    --dry-run --security-report report.json \
    --evidence-bundle bundle.json

Argorix Lang compiler v1.0
Status: OK
Module: ArgorixChatbotRuntime
Capabilities: 1  Types: 3  Agents: 2  Protocols: 1
Semantic checks: passed

Argorix Bytecode verification v1.0
Status: OK
Bytecode version: 1.0  Instructions: 17
Agents: 2  Protocols: 1

Every command is offline and deterministic. No network access, secrets, environment variables, real tools or models are used to compile, verify or dry-run a contract.