Skip to main content
Eshan Roy@eshanized
Projects Portfolio/M31A (M31 Autonomous)
v0.1.5 · Active Runtime·Autonomous Systems·Primary: Rust

M31A (M31 Autonomous)

High-assurance autonomous software engineering runtime in terminal.

A Rust-native autonomous software-engineering runtime that executes high-level engineering objectives in your terminal while enforcing non-bypassable policy gates and multi-tier empirical verification.

Official RepositoryOfficial WebsiteDocumentationReleases & Binaries

Interactive Runtime Telemetry

Live Ratatui Simulation
m31a · ratatui cockpit
MISSION: Refactor AST parse validation & enforce POSIX rlimits
STATUS: VERIFYINGSESSION #842
DAG Execution PlanWAVE 2/3
✓ T01: Scan .env secretsOK
✓ T02: Snapshot SQLite WALOK
▶ T03: Apply AST parser diffRUNNING
○ T04: Run cargo testWAIT
○ T05: SHA-256 seal manifestWAIT
STAGED DIFF: src/policy/gate.rs[VERIFIED BY TREE-SITTER]
+ pub fn check_path_traversal(target: &Path) -> Result<(), PolicyError> {
+ if target.starts_with("..") || target.is_absolute() {
+ return Err(PolicyError::PathTraversalDenied);
+ }
+ Ok(())
+ }
// Non-bypassable policy evaluation continues...
Policy: ALLOW (All 11 criteria satisfied)
Sandbox: Linux cgroups v2 (2.0 GiB cap)
Problem Statement

Conventional AI agents execute arbitrary shell commands with ambient credentials, trusting an untrusted LLM to self-police. They frequently cause destructive mutations, leak API secrets, and declare task completion without verifiable proof.

Intended Audience

Systems engineers, infrastructure developers, and software teams requiring provably safe, auditable autonomous coding workflows.

Core Architecture & Mental Model

Intelligence is not authority. The LLM acts strictly as an untrusted reasoning engine proposing structured actions; the Rust runtime strictly owns policy evaluation, OS sandboxing (cgroups v2, namespaces, macOS Seatbelt), atomic SQLite checkpoints, and empirical compiler verification passes.

Verified System Capabilities

Acyclic DAG Task Planning: Topological wave execution with critical path parallelization
11-Stage Non-Bypassable Policy Gate: Strict ALLOW / DENY / ASK decision matrix
Empirical Verification Engine: Automated compiler diagnostics, test suites, and lint cleanups
Two-Phase Crash Recovery: Atomic SQLite transactions resume safely without work loss
Conversation-First TUI Cockpit: Built on Ratatui with diff inspection and approval prompts
Zero-Leak Telemetry: Automated credential redactor scrubs tokens before persistence

Architectural Decisions & Rationales

Rust runtime with strict L0–L9 layered architecture

Rationale: Ensures that low-level security, sandboxing, and persistence layers never depend on or yield control to higher-level LLM agents or UI modules.

SQLite WAL with two-phase atomic manifest commits

Rationale: Guarantees deterministic recovery from sudden crashes or power loss without leaving dirty half-applied repository mutations.

OS-native sandboxing (cgroups v2, namespaces, macOS Seatbelt)

Rationale: Enforces true process-level isolation rather than relying on brittle shell string parsing or regex filters.

Technical Trade-offs & Honest Limitations

  • Strict policy gates require human approval for high-risk operations (e.g. out-of-tree file modifications, irreversible git push).
  • Sandboxing capabilities vary by host OS: full cgroups v2 resource limits are Linux-specific; macOS relies on Seatbelt profiles; Windows uses Job Objects.

Quickstart & Execution

# Clone and build M31A from source
git clone https://github.com/eshanized/M31A.git
cd M31A
cargo build --release
# Run the Ratatui interactive cockpit
./target/release/m31a tui
Empirical Verification Evidence

Over 820 deterministic unit and integration tests passing in CI across Linux, macOS, and Windows. Public release v0.1.5 tagged on GitHub.

Related Research & Architectural Writing

Research Paper

Empirical Verification in Terminal AI Runtimes: Non-Bypassable Policy Gates and Isolated Sandboxing

This technical report presents the design and empirical evaluation of the verification engine within M31A. We investigate the failure modes of ambient shell execution in language model agents, analyze process isolation mechanisms across Linux cgroups v2 and macOS Seatbelt, and benchmark a two-phase SQLite WAL crash-recovery architecture capable of restoring consistent workspace states following abnormal process termination.

Journal Essay

Inside M31A: Building a Rust-Native Autonomous Engineering Runtime

A comprehensive architectural breakdown of M31A, explaining why intelligence is not authority, how the 10-tier downward module hierarchy functions, and how two-phase SQLite recovery prevents workspace corruption.