I build production-grade systems infrastructure for autonomous AI agents — the runtimes, compiler substrates, and orchestration layers that turn loose model calls into reliable, deterministic enterprise systems. My work spans high-performance systems engineering (Rust, Tokio, Axum, SQLx) to scalable coordination protocols (Model Context Protocol, SSE, REST) and recursive knowledge graphs.

My engineering philosophy is rooted in physical architecture (B.Arch training). I do not view software as isolated code blocks; I view it as load-bearing structures.

• Load-Path Engineering: Just as a physical beam transfers structural load, a software runtime must route concurrency, buffer memory, and distribute work. I design for predictable load paths, zero-copy memory patterns, and deterministic state transitions.
• Modular Assembly: I favor lightweight, high-performance, single-purpose components (such as stripped ~7MB static Rust binaries) composed through clear protocol standards (MCP) rather than heavy, bloated, fragile runtimes.
• Systems Diagnostics: Designing complex physical spaces and studying human cognitive structures taught me how multi-agent networks behave. I translate this into enterprise systems modeling, organizational risk dynamics, and resilient agent execution.

What that means for a company: I can own entire systems end-to-end — from database schema to API design to custom concurrency engines — without handoffs between specialists. I ship load-bearing systems.

Graph-native automation substrate for AI agents. Rust. 39 MCP tools.

Traditional automation tools (shell scripts, CI pipelines, no-code) are designed for humans, not AI agents. Agents can't "see" dependency graphs, can't recover gracefully from partial failures, can't compose capabilities dynamically.

automaton replaces the script with a graph-based module — every automation unit is a self-contained node with typed inputs/outputs, a content-addressed build cache, and a property graph of capabilities. The engine materializes branching, loops, and parallelism into a DAG, executes with level-based parallel dispatch via Tokio, and exposes the entire lifecycle through MCP.

• 8 Rust crates (core, SDK with proc macro, CLI, engine, registry, graph, MCP, runtime)
• Dual-backend SQLite/PostgreSQL with unified query layer
• Static musl binary (~14MB), zero runtime dependencies
• Production scheduler with cron expressions

Intelligence Gathering System — Rust flagship. ~7MB static binary, ~5MB RSS.

223+ curated sources across 45 countries, 14 intelligence pools, local NLP enrichment — all in a ~7MB stripped binary with ~5MB idle RSS. TOON (Token-Oriented Object Notation) reduces token consumption by 40–60% for AI agent consumption.

Started as a TypeScript proof-of-concept published to npm — the Rust port is the real flagship: dramatically lower memory/runtime, deployable anywhere including resource-constrained infrastructure.

• 9 custom parsers (RSS, Atom, HTML, OFAC, WHO, Semantic Scholar, PDF, Google News proxy)
• Pool-based source organization (Global Breaking, Geopolitics, Tech/Cyber, India National, etc.)
• Hybrid pipeline: news feeds + academic archives (arXiv, Semantic Scholar) + Reddit
• TOON format for token-efficient AI agent output (~40-60% reduction)

Teleological Developmental Graph — a recursive, holonic knowledge architecture. 55 MCP tools. Python (10K+ LOC).

The most ambitious implementation of an agent's "mind" — using a holonic graph to model goals, constraints, and knowledge. 55 custom MCP tools for dynamic knowledge capture, synthesis, and temporal query, enabling agents to maintain a durable, evolving memory of a project's entire evolution.

Enterprise systems modeling & risk architecture substrate for Deliberately Developmental Organizations (DDO). Rust. Python.

A multi-stakeholder systems modeling and risk simulation engine that maps organizational dynamics, resource flows, and structural constraints. Designed as an "enterprise diagnostics" substrate, HoloOS uses holonic theory to model complex systems, simulate structural risk propagation, and optimize resource allocation across adaptive team topologies.

• Multi-dimensional holonic state engine to map structural and process variables
• Monte Carlo simulations to model risk propagation across complex corporate topologies
• Agentic feedback loops that suggest optimal structural and process reconfigurations

Multi-agent C-suite — 227 tests, LanceDB memory, systemd deployment.

Coordinates specialized agents (CEO, COO, CFO, CRO, CMO) that run periodic operational checks, communicate with escalation/priorities, track work in Kanban boards, and persist context across sessions. The operant-mcp component exposes 35 tools for orchestration, 25+ database tables with Drizzle + Postgres.

Dual-interface social media orchestration engine (REST + MCP). Rust. Axum. SQLx.

Most social media tools serve one audience: humans via GUI or developers via API. social-forge implements a Shared AppState Architecture that serves both — a SvelteKit frontend via Axum REST and AI agents via MCP — through the same business logic layer with zero code duplication.

• Trait-based provider registry — add new social networks without touching core engine
• In-process Tokio scheduler with exponential-backoff retry (solves "ghost post" problem)
• SSE event stream for real-time publish/fail notifications
• JWT + Argon2 auth with multi-account cookie profile management
• Static musl binary, ~15MB Docker image

Streaming-first, fault-tolerant agent orchestration loop. Rust. Ratatui TUI.

The hardest problem in agentic systems isn't making the LLM smart — it's keeping the loop running when the LLM produces malformed output. Standard parsers crash on unclosed XML tags or broken JSON, taking down the entire agent.

hermes-rs implements a custom state-machine parser that detects tool calls incrementally. It can recover intent from truncated output, execute tools before the response finishes streaming, and maintain loop integrity even with unstable network connections. The "validated autonomous" mode enforces a strict Plan → Implement → Validate → Push cycle — the agent cannot push unless cargo test passes.

AI-directed video editing pipeline — raw footage to polished reel. 43 MCP tools. Rust + Python + TS. (Active R&D)

Most "AI video" tools generate from text. This takes real raw footage and edits it professionally through a structured pipeline: transcription → creative brief → multi-track timeline → rendered 9:16 reel with captions, b-roll, music ducking, and SFX. The AI agent directs like a human editor — choosing b-roll concepts, music mood, SFX placement — and the engine executes.

• 6-track Edit Decision List (EDL v2) — dialogue, voiceover, captions, b-roll, music, SFX
• Apex transcription (Hinglish-optimized Whisper) with word-level timestamps
• TTS voiceover engine with voice profile registry and duration estimation
• 261 indexed SFX + 16 music tracks with mood/role-based search
• FFmpeg rendering with automatic audio ducking
• Post-render verification (audio levels, caption sync, render fidelity)

I've also built several infrastructure-level MCP servers for internal use — including reverse-engineered integrations for 8 AI providers (Kimi, Qwen, Gemini, GLM, Perplexity, ChatGPT, Claude, DeepSeek) with zero API keys, and multi-model Perplexity access. These are private/prototype work.

MCP-AND-CLIS       15 — Production AI agent infrastructure  
WEBSITES            5 — Full-stack production applications  
FRAMEWORKS          2 — TDG knowledge graph, HoloOS systems modeling  
HERMES              3 — Agent orchestration runtimes  
CONTENT-CREATION    2 — Video editing pipeline, cinematography  
DEVELOPER-TOOLS     2 — AI coding runtimes  
SOCIAL              1 — Multi-platform publishing automation  
N8N-WORKFLOWS       1 — Automation configurations