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.
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...
cargo test -p m31a-core (14 passed, 0 failed in 0.42s). Zero regressions.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.
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.
Ratatui Terminal UI
A full-screen terminal experience featuring streaming markdown transcripts, collapsible DeepSeek R1 reasoning blocks, fuzzy palettes, and SQLite session resumption.
18-Tool Orchestration
Filesystem search, atomic patching with 4-tier fuzzy seek, multi-agent spawning, and headless browser validation.
Defense-in-Depth Security
Linux Bubblewrap namespace containment with read-only masks over .git and .env, plus Guardian circuit-breakers.
JSON-RPC 2.0 & SDKs
Unix Domain Socket, Stdio, and HTTP/SSE transports. First-party TypeScript (@m31a/sdk) and Python (m31a) libraries.
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.
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
# 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 --workspaceM31A 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
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"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
// 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");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
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 8080M31A 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
// 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' });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.
User Intent
Crate: m31a-cli / m31a-tuiDeveloper 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.
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.
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.
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.
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.
Eliminates subjective guesswork for complex architectural trade-offs such as zero-copy refactoring vs memory allocation schemes.
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.
Prevents race conditions and overwrites during concurrent agent workflows via SQLite file path mutexes.
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.
Captures visual regression screenshots and formulates precise self-healing repair prompts if frontend components break.
AST Blast-Radius Gate
Cross-references symbol call-graphs and data-flow taint invariants before applying code modifications.
crates/m31a-ast4-Tier Fuzzy Patch Engine
Full OpenAI Codex patch specification support with whitespace and typographic unicode normalization.
crates/m31a-patchSkills & MCP Host
Discovers YAML-frontmatter skills and connects to external Model Context Protocol tool servers.
crates/m31a-mcpSQLite Durable Storage
Thread branching, turn checkpointing, token accounting, and session resumption with zero data loss.
crates/m31a-storageAutonomy 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
1. Prefix & AST ExecPolicy
Source Crate: crates/m31a-execpolicy
Evaluates commands against prefix rules, alternative token sets, and network destination filters before execution starts.
- 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.
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.
Full-Stack Feature Implementation
Spans both backend API handler and frontend components in one unified autonomous session.
- 1AST parser cross-references route declarations and user schema
- 2Generates multi-file patch spanning backend routes and frontend UI
- 3Runs backend compiler checks and frontend headless Chromium visual TDD
- 4Captures passing visual screenshot proof
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.
- Async iterable token and reasoning stream parsing
- Event callbacks: onReasoning, onContent, onToolStarted
- Interactive approval request handler callbacks
- Stdio, UDS, and HTTP/SSE transport implementations
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();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.
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.
Continuous release cadence.
M31A releases regular updates with new crate features, performance enhancements, and security improvements.
v0.1.15
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.
Your next engineering session starts here.
Explore an autonomous coding system built for developers who want more control over how software gets built.