M31A Logo
M31Av0.1.15

Engineering beyond assistance.

An autonomous engineering system that plans, executes, coordinates and verifies real software work — from an interactive terminal to a native desktop workspace. Powered by NVIDIA NIM frontier intelligence and Linux Bubblewrap isolation.

NVIDIA NIM Low-Latency Frontier ModelsBubblewrap Linux Container IsolationRatatui Full-Screen TUI
$m31a "Refactor token bucket limiter to use SIMD atomic CAS and add test suite"_
nvidia/nemotron-3.5-lightning-30b-a3b| Bubblewrap: workspace-write
🧠 DeepSeek R1 / Nemotron Thought Chain(Click to expand)284 tokens

Examining crates/m31a-core/src/rate_limiter.rs... Replacing Mutex<u64> with AtomicU64 compare_exchange_weak to prevent thread contention during 100k req/s bursts. Checking blast radius against consumer crates...

⚡ Tool Dispatched:apply_patch
Guardian Approved (ExecPolicy: allow)
*** Update File: crates/m31a-core/src/rate_limiter.rs
@@ -14,6 +14,8 @@
- use std::sync::Mutex;
+ use std::sync::atomic::{AtomicU64, Ordering};
pub struct TokenBucket {
- tokens: Mutex<u64>,
+ tokens: AtomicU64,
Verification passed: cargo test -p m31a-core (14 passed, 0 failed in 0.42s). Zero regressions.
Runtime: Idle & Ready
Press Tab for modes•Ctrl+M to switch models
Architectural Foundation

Meet M31A.

An autonomous software engineering runtime built from first principles as a modular 39-crate Rust workspace. M31A bridges frontier intelligence with kernel-level container containment to plan, execute, and verify complete developer workflows.

crates/m31a-agent-engine

Autonomous Agent Runtime

Coordinates prompt turn decomposition, dynamic context windows, token budget auto-compaction, and multi-step tool loops. Powered by NVIDIA NIM frontier intelligence including DeepSeek R1 and Nemotron reasoning paths.

39-Crate MonorepoStrictly decoupled domain architecture
Dynamic DiscoveryLive NIM model catalog via /v1/models
crates/m31a-tui

Ratatui Terminal UI

A full-screen terminal experience featuring streaming markdown transcripts, collapsible DeepSeek R1 reasoning blocks, fuzzy palettes, and SQLite session resumption.

Tab: [⚡ BUILD] vs [📋 PLAN] modes
Ctrl+M: Model switcher dialog
Ctrl+P: Fuzzy command palette

18-Tool Orchestration

Filesystem search, atomic patching with 4-tier fuzzy seek, multi-agent spawning, and headless browser validation.

Inspect tool catalog →

Defense-in-Depth Security

Linux Bubblewrap namespace containment with read-only masks over .git and .env, plus Guardian circuit-breakers.

Review security model →

JSON-RPC 2.0 & SDKs

Unix Domain Socket, Stdio, and HTTP/SSE transports. First-party TypeScript (@m31a/sdk) and Python (m31a) libraries.

Explore client SDKs →
Interaction Surfaces

Multiple ways to work. One sovereign engine.

M31A spans an interactive terminal, scriptable CLI, native desktop workspace, and first-party SDKs — all connected to the same Rust runtime.

Native Desktop Workspace · Preview

M31A Desktop

A native desktop application built with Tauri 2 and the Rust runtime. It brings persistent sessions, streaming conversations, tool activity, settings, and explicit approval and question dialogs into a dedicated workspace.

  • Tauri 2 desktop host integrated with the authoritative Rust runtime
  • Session sidebar and persistent conversation timeline
  • Visible tool execution, approval cards, and interactive question dialogs
  • Workspace settings and native file dialog integration
desktop.preview
# Build the desktop workspace
cargo tauri dev --manifest-path apps/desktop/src-tauri/Cargo.toml

# Desktop host and runtime share the Rust workspace
cargo check --workspace
Terminal-First Interface

M31A CLI & TUI

A full-screen interactive Terminal User Interface built on Ratatui and Crossterm, alongside 54 headless CLI subcommands for scriptable automation.

  • Interactive streaming transcript with foldable DeepSeek R1 reasoning paths
  • Fuzzy command palette (Ctrl+P) and NVIDIA NIM model switcher (Ctrl+M)
  • SQLite session resumption (Ctrl+R) with full turn history replay
  • 54 subcommands including vibe, speculate, swarm, doctor, and setup
cli.preview
m31a vibe --visual-url http://localhost:3000
m31a speculate "Optimize parser" "SIMD-JSON" "FlatBuffers" --promote
m31a exec --model deepseek-ai/deepseek-v4.1-flash "Analyze memory safety"
Autonomous Engine

M31A Agentic Runtime

The core execution engine written in Rust 2024. Coordinates models, tool dispatch, context window auto-compaction, and session state machines.

  • Dynamic NVIDIA NIM model discovery querying /v1/models in real-time
  • Turn execution loop with automated context budget compaction
  • Durable SQLite persistence for threads, turns, and checkpoints
  • Integrated headless Chromium CDP visual TDD validation
runtime.preview
// Rust 2024 Turn Execution Engine
let turn = TurnEngine::new(config, provider, storage);
let result = turn.execute_turn(prompt, sandbox_policy).await?;
assert!(result.verified, "Turn verification gate must pass");
JSON-RPC 2.0 Daemon

M31A App Server

An industrial-grade JSON-RPC 2.0 daemon allowing IDE extensions, custom frontends, and CI/CD pipelines to control the agent runtime.

  • Three bidirectional transports: Stdio, Unix Domain Socket, and HTTP/SSE
  • Over 40 RPC protocol methods (thread/*, turn/*, command/*, model/*)
  • Streaming server-sent events for live tokens and reasoning chunks
  • Interactive approval and human-in-the-loop question handling
app-server.preview
m31a app-server --stdio
# Or Unix Domain Socket IPC:
~/.m31a/app-server-control/app-server-control.sock
# Or Networked HTTP / SSE daemon:
m31a serve --port 8080
First-Party Libraries

M31A Client SDKs

Official client libraries for TypeScript and Python. Built for developers integrating autonomous agent execution into custom workflows.

  • TypeScript / Node.js (@m31a/sdk) with async iterable streaming
  • Python (m31a) with asyncio and synchronous clients (zero external deps)
  • Full support for reasoning chunk events and approval callbacks
  • Mock transports for fast, deterministic unit test harnesses
sdk.preview
// TypeScript SDK Quickstart
import { M31AClient, StdioTransport } from '@m31a/sdk';
const client = new M31AClient(new StdioTransport());
const thread = await client.createThread({ title: 'Refactor' });
await thread.run({ prompt: 'Implement SIMD serialization' });
Lifecycle Pipeline

From idea to verified implementation.

Unlike conversational chatbots that dump disconnected snippets into a chat window, M31A executes an unbroken, verifiable multi-turn engineering loop.

Execution FlowLive Reactive Pipeline
Phase 01

User Intent

Crate: m31a-cli / m31a-tui

Developer enters instructions in TUI composer or via JSON-RPC client.

Prompts are captured into SQLite thread sessions at ~/.m31a/storage.db. Checkpoint snapshots ensure safe rollback.

Isolation GateVerified Sandboxed
Core Capabilities

Engineered for sovereign autonomous coding.

Every capability in M31A is backed by a dedicated Rust crate. Explore the eight core engines that set M31A apart from conversational chat assistants.

crates/m31a-agent-engine::vibe_loop

Continuous Verification & Vibe Loop

Eliminate babysitting. The Vibe Loop actively monitors your filesystem for changes, validates builds in the background, detects compiler or type diagnostics, and autonomously synthesizes corrective multi-file patches via ultra-low-latency NVIDIA NIM models.

Why it matters:

You write code in your preferred editor without interruptions. When an error occurs, M31A identifies the failure, patches the regression, and confirms the build is clean without breaking your focus.

m31a-watcher (debounce: 400ms)● LIVE
[Watcher] Workspace delta: 2 files modified
[Compiler] cargo check: 1 error in crates/m31a-storage/src/lib.rs:48
[NIM] Synthesizing targeted Codex patch via nemotron-3.5-bolt...
[Patch] Applied 4-tier fuzzy patch. Re-compiling... Passed (0.18s).
crates/m31a-agent-engine::speculative

Speculative Parallel Reality Arena

Instead of guessing whether Approach A or Approach B is superior, M31A forks parallel isolated worktrees in temporary Bubblewrap sandboxes, generates competing implementations simultaneously, scores them across a multi-criteria matrix, and promotes the winner.

Why it matters:

Eliminates subjective guesswork for complex architectural trade-offs such as zero-copy refactoring vs memory allocation schemes.

Speculative Scoring MatrixAuto-Promotion: Enabled
Candidate A: SIMD-JSON96 / 100 [WINNER]
Tests: 100% | Speed: +380% | Blast Radius: 12 (Safe)
Candidate B: FlatBuffers78 / 100
Tests: 100% | Speed: +410% | Blast Radius: 64 (High Risk)
crates/m31a-storage & m31a-agent-engine

Multi-Agent Swarm Orchestration

Decompose sprawling engineering initiatives across specialized agents. The Architect agent produces a milestone dependency DAG, Coder agents acquire path concurrency locks to write minimal patches, and Guardian agents audit changes before the Tester executes tests.

Why it matters:

Prevents race conditions and overwrites during concurrent agent workflows via SQLite file path mutexes.

Swarm Board (SQLite pub-sub)m31a swarm
Architect: Task DAG decomposed into 4 sub-milestones
Coder-1: Acquired path lock on crates/m31a-patch
Guardian: Blast radius score = 8 (Approved)
Tester: Executing headless Chromium visual assertions...
crates/m31a-verify::visual_tdd & m31a-browser

Autonomous Visual TDD Engine

Verify real web applications end-to-end. M31A connects to headless Chromium via the Chrome DevTools Protocol (CDP) to assert DOM node presence, computed CSS styles, zero browser console errors, and zero HTTP 4xx/5xx network failures.

Why it matters:

Captures visual regression screenshots and formulates precise self-healing repair prompts if frontend components break.

CDP Headless InspectorDOM: Verified
✓ Console errors: 0 detected
✓ Network status: 0 HTTP 4xx/5xx failures
✓ Computed style: button.background = #15171b
✓ Captured visual snapshot: .m31a/artifacts/snap_01.png

AST Blast-Radius Gate

Cross-references symbol call-graphs and data-flow taint invariants before applying code modifications.

crates/m31a-ast

4-Tier Fuzzy Patch Engine

Full OpenAI Codex patch specification support with whitespace and typographic unicode normalization.

crates/m31a-patch

Skills & MCP Host

Discovers YAML-frontmatter skills and connects to external Model Context Protocol tool servers.

crates/m31a-mcp

SQLite Durable Storage

Thread branching, turn checkpointing, token accounting, and session resumption with zero data loss.

crates/m31a-storage
Non-Bypassable Containment

Autonomy with boundaries.

Autonomous systems must not accidentally overwrite repository history, leak developer secrets, or corrupt parent host files. M31A enforces a defense-in-depth security model before, during, and after every tool invocation.

Defense-in-Depth Execution Pipeline

Active Policy Gate

1. Prefix & AST ExecPolicy

Source Crate: crates/m31a-execpolicy

allow / prompt / deny

Evaluates commands against prefix rules, alternative token sets, and network destination filters before execution starts.

Enforcement Mechanisms:
  • PatternToken::Alts tokenized evaluation
  • Outbound network LAN block (blocks 192.168.0.0/16, 127.0.0.1 by default)
  • Whitelist for standard registries (crates.io, npmjs.org)

Platform Isolation Transparency: Bubblewrap kernel namespace isolation requires a Linux host with unprivileged user namespaces enabled. On macOS and Windows, M31A enforces strict path filtering and Guardian supervision, while native seatbelt profiles (sandbox-exec) and Windows AppContainer isolation remain in development for Phase 3 on the roadmap.

Practical Workflows

Real engineering tasks. Zero synthetic benchmarks.

M31A is built for software engineers who need autonomous assistance on substantive problems—from full-stack features to speculative performance experiments.

Workflow Specification

Full-Stack Feature Implementation

Spans both backend API handler and frontend components in one unified autonomous session.

Terminal Execution Syntax
$ m31a "Implement JWT authentication endpoint and React login modal with form validation"
Autonomous Execution Steps:
  1. 1AST parser cross-references route declarations and user schema
  2. 2Generates multi-file patch spanning backend routes and frontend UI
  3. 3Runs backend compiler checks and frontend headless Chromium visual TDD
  4. 4Captures passing visual screenshot proof
Client Libraries

Build on the M31A runtime.

Control the M31A agent runtime programmatically. Our official TypeScript and Python SDKs provide clean, typed interfaces over JSON-RPC 2.0 with native streaming and approval hooks.

Package: @m31a/sdk
  • Async iterable token and reasoning stream parsing
  • Event callbacks: onReasoning, onContent, onToolStarted
  • Interactive approval request handler callbacks
  • Stdio, UDS, and HTTP/SSE transport implementations
Interchangeable IPC Transports
Stdio
Unix Socket
HTTP / SSE
example.ts
import { M31AClient, StdioTransport } from '@m31a/sdk';

// Launch M31A daemon as managed child process
const transport = new StdioTransport({
  command: 'm31a',
  args: ['app-server', '--stdio'],
});

const client = new M31AClient(transport);
await client.connect();

// Create thread session backed by SQLite
const thread = await client.createThread({
  title: 'Autonomous Refactoring',
  cwd: process.cwd(),
});

// Run autonomous turn with live streaming
const turn = await thread.run({
  prompt: 'Refactor rate limiter to use SIMD atomic CAS',
  onReasoning: (chunk) => process.stdout.write(`[Thinking]: ${chunk}`),
  onContent: (chunk) => process.stdout.write(chunk),
  onToolStarted: (event) => console.log(`Tool: ${event.tool}`),
  onApprovalRequested: async () => ({ decision: 'allow' }),
});

await turn.wait();
await client.disconnect();
Decoupled Rust Topology

Built on sovereign, proven technology.

Every component in M31A is selected for performance, security containment, and sovereign operability. No proprietary wrappers. No hidden cloud dependencies.

Core Language

Rust 2024 Edition

Zero-cost abstractions, memory safety without garbage collection, and blazing throughput across 39 workspace crates.

Frontier Intelligence

NVIDIA NIM

Dynamic model discovery querying /v1/models with real-time SSE streaming for Nemotron and DeepSeek R1 reasoning paths.

Async Engine

Tokio Async Runtime

Multi-threaded asynchronous task scheduling driving simultaneous tool invocations, background filesystem watchers, and IPC streams.

Terminal Interface

Ratatui & Crossterm

Immediate-mode TUI framework powering virtualized scrolling transcript viewports, syntax diffs, and modal dialogs.

Linux Sandbox

Bubblewrap (bwrap)

Unprivileged Linux container isolation enforcing Mount, PID, IPC, UTS, and Network namespace boundaries.

Durable Storage

SQLite 3 (rusqlite)

Transactional persistence for thread sessions, turn checkpoints, pub-sub boards, and file path concurrency locks.

App Server Protocol

JSON-RPC 2.0

Standardized specification implemented across Stdio, Unix Domain Sockets, and HTTP/SSE for external tooling.

Desktop Host

Tauri 2

Native desktop shell integrating the Rust runtime with sessions, streaming chat, approvals, settings, and native dialogs.

Rust Workspace & Desktop Host

M31A combines independently testable Rust domains with its runtime, a native Tauri desktop host, and worktree-first coordination for isolated concurrent tasks.

View Full Crate Architecture
Release Tracking

Continuous release cadence.

M31A releases regular updates with new crate features, performance enhancements, and security improvements.

v0.1.15Latest Production Release

v0.1.15

November 14, 2026
## Release Notes ### Added - **Demand-Driven Coordination & Worktree-First Execution**: - Independent Git worktrees as the default execution and isolation boundary for concurrent coding tasks (`WorkspaceIsolationStrategy::Worktree`). - Demand-driven coordination infrastructure activated conditionally only when shared mutable resources require concurrency control. - Conflict discovery and dynamic replanning: structured conflict reports, transactional DAG updates, cycle detection (`would_create_cycle`), and automatic unblocking of ready tasks. - Durable integration pipeline with content-addressed idempotent deduplication, stale base revision detection, preflight validation, and exact per-file rollbacks. - SQLite database migration 18 adding `managed_worktrees`, `workflow_integrations`, and `workflow_conflicts` tables with complete recovery of active worktrees across restarts. - Architectural performance evaluation benchmark suite validating ~2.7x speedup with worktree-first parallelism (40ms vs 109ms baseline). - 13 comprehensive end-to-end integration tests on genuine Git repositories and file-backed SQLite verifying concurrent worktrees, conflict replanning, and verification failure rollbacks. - **Documentation Refactoring**: - Published authoritative Demand-Driven Coordination architecture guide (`docs/architecture/DEMAND_DRIVEN_COORDINATION.md`). - Streamlined and modernized user-facing specifications for TUI Approval Interaction, Model Selector, and Transcript Rendering in `docs/tui/`. - Cleaned up internal audit reports across `docs/reports/` and refreshed the documentation hub index (`docs/README.md`). - **Version Bump**: - Bumped workspace package, client protocol, installer scripts, and official TypeScript/Python SDK versions to `0.1.15`. ## Install m31a-cli 0.1.15 ### Install prebuilt binaries via shell script ```sh curl --proto '=https' --tlsv1.2 -LsSf https://github.com/eshanized/M31A/releases/download/v0.1.15/m31a-cli-installer.sh | sh ``` ## Download m31a-cli 0.1.15 | File | Platform | Checksum | |--------|----------|----------| | [m31a-cli-x86_64-unknown-linux-gnu.tar.xz](https://github.com/eshanized/M31A/releases/download/v0.1.15/m31a-cli-x86_64-unknown-linux-gnu.tar.xz) | x64 Linux | [checksum](https://github.com/eshanized/M31A/releases/download/v0.1.15/m31a-cli-x86_64-unknown-linux-gnu.tar.xz.sha256) | | [m31a-cli-x86_64-unknown-linux-musl.tar.xz](https://github.com/eshanized/M31A/releases/download/v0.1.15/m31a-cli-x86_64-unknown-linux-musl.tar.xz) | x64 MUSL Linux | [checksum](https://github.com/eshanized/M31A/releases/download/v0.1.15/m31a-cli-x86_64-unknown-linux-musl.tar.xz.sha256) |
Published Release Assets (9)
dist-manifest.json0.0 MB
m31a-cli-installer.sh0.1 MB
m31a-cli-x86_64-unknown-linux-gnu.tar.xz7.0 MB
m31a-cli-x86_64-unknown-linux-gnu.tar.xz.sha2560.0 MB
Open Source & Sovereign

Built in public. Backed by community.

M31A is an independent, MIT-licensed open-source project created by Eshan Roy under Tonmoy Infrastructure & Vision. We welcome technical contributions, security audits, and real-world feedback.

GitHub Repository

Explore the 39-crate monorepo source code, submit pull requests, and audit implementations.

Issue Tracker

Report bugs, request new crate features, and track ongoing engineering tasks transparently.

Contributing Guide

Step-by-step instructions on setting up the local Rust workspace, running Bazel checks, and style guides.

Security Policy

Details on vulnerability reporting, coordinated disclosure, and sandbox boundary assessments.

Sovereign Autonomous Coding

Your next engineering session starts here.

Explore an autonomous coding system built for developers who want more control over how software gets built.