Skip to main content
Eshan Roy@eshanized
SIGNAL // ESHAN ROY (@eshanized)·Tonmoy Infrastructure & Vision

I build the systems beneath the software.

Systems engineer, open-source architect, and researcher. I design autonomous software-engineering runtimes with non-bypassable policy gates, Arch-based operating systems, and distributed developer infrastructure.

Explore ResearchEngineering JournalProjects PortfolioAbout & Philosophy
github.com/eshanized/huggingface.co/eshanized/tonmoyinfrastructure.org
[CURATED WORK // FLAGSHIP SYSTEMS]

Flagship Engineering Projects

View All 10 Projects
v0.1.5 · Active RuntimeRust

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.

Verified 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
Case StudyRepository
Rolling Release · Active EcosystemRust & Shell

Snigdha OS

Performance × Elegance: Modern Arch-based Linux ecosystem.

An Arch-based Linux ecosystem engineered for lightweight performance, developer productivity, custom package management, and robust kernel tooling.

Verified Capabilities:
  • ✓Modular Core (`snigdhaos-core`): Minimal, highly optimized base operating system footprint
  • ✓Kernel Switcher (`snigdhaos-kernel-switcher`): Fast tool for toggling between Zen, LTS, and hardened kernels
  • ✓Blackbox Security Framework: Custom utility suite for penetration testing environments
Case StudyRepository
v0.1.0 · In DevelopmentRust & TypeScript

Kyro

Local-first autonomous desktop AI agent built with Tauri v2, Rust & React 19.

A high-performance, local-first autonomous desktop AI agent that bridges natural language reasoning with real computer interaction, zero-trust local privacy, and Model Context Protocol (MCP) integrations.

Verified Capabilities:
  • ✓Zero-Trust Local Privacy: All task histories and state stored in local SQLite WAL databases
  • ✓Operating System Keyring Vault: OS-level encryption for API keys and credentials
  • ✓Screen Understanding: Low-latency local frame capture and vision-language model integration
Case StudyRepository
[INTERACTIVE TELEMETRY // RATATUI RUNTIME]

M31A Cockpit & Autonomous Runtime

Simulated interactive terminal environment showing the 4-stage execution loop, 11-stage non-bypassable policy evaluation gate, and L0–L9 layered architecture.

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)
[TECHNICAL INVESTIGATION // RESEARCH & EXPERIMENTS]

Recent Research Publications

View All Research Papers
Technical Report·M31A-RES-2026-002·2026-09-28

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.

#systems security#terminal runtime#cgroups v2#crash recovery#empirical verification
Read Paper & AbstractCode
Research Framework·TIV-RES-2026-001·2026-09-12

Towards Autonomous Development Systems: A Research Framework

We propose a research framework for autonomous software development systems — computational runtimes capable of reasoning over, modifying, and verifying complex software repositories under strict safety guarantees. We define the problem space separating conversational assistants from sovereign execution runtimes, formalize an 11-stage non-bypassable policy gating model, and introduce empirical verification criteria where language model assertions are treated as untrusted until mathematically and observationally proven.

#autonomous systems#runtime governance#policy gating#systems engineering#software agents
Read Paper & AbstractCode
[ARCHITECTURAL MATRIX // DOWNWARD SYSTEM DEPENDENCY]

The Downward Systems Dependency Stack

Select any tier to inspect guarantees & components
M31A & Kyro Runtimes

04 // Autonomous Intelligence

Invariant: Downward Compilation Only

Untrusted LLM reasoning is strictly bounded by deterministic runtime authority. Natural language intent is transformed into topological DAGs with non-bypassable policy gates.

Concrete Implemented Subsystems
  • ▶Topological DAG Planner (Wave execution)
  • ▶11-Stage Policy Evaluation Gate
  • ▶Ratatui Terminal Cockpit (m31a tui)
  • ▶Model Context Protocol (MCP) integrations
Non-Bypassable Engineering Invariants
  • Intelligence is not authority
  • Model outputs require empirical verification
  • Zero-leak credential scrubbing on all telemetry
[TECHNICAL JOURNAL // ENGINEERING ARTICLES]

Engineering Journal

Read All Articles
[ECOSYSTEM_TOPOLOGY // CROSS-SYSTEM INTERCONNECTS]

The Sovereign Systems Matrix

Select any node to inspect architectural linkages
v0.1.5 · Active Runtime·Autonomous Systems

M31A (M31 Autonomous)

Read Case StudySource

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.

Verified 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
[STEWARDSHIP // COLLABORATION]

Let’s engineer software that endures.

Whether you are architecting autonomous agent runtimes, deploying sovereign Linux environments, or looking to collaborate on systems research with Tonmoy Infrastructure, my channels are open.

Initiate Direct InquiryRead Full Biography & Philosophy