AI Agent Engineer · MCP Infrastructure · Multi-Agent Orchestration · Systems Architecture

📧 contact@ishanparihar.com · 🌐 ishanparihar.com · 🔗 LinkedIn 📍 Noida, India · ✈️ Remote: worldwide

I design and implement custom cognitive substrates, low-overhead tools, and high-throughput communication routing layers. The operational scope of this portfolio covers:

All metrics are machine-measured from the repositories — no self-reported numbers. Performance claims (context reduction, runtime footprint) are benchmark-verified on the linked flagships.

I build the graph engines, compilers, and protocol layers that make autonomous AI agents functional, resilient, and cost-effective under real production loads. Every flagship below points to the proof living in its own repository — playable demos, runnable test suites, and measured benchmarks. Open the repo and verify it yourself.

For fractional CTO, custom MCP development, or agent architecture consulting — 📧 contact@ishanparihar.com. Or audit the code first: start from the portfolio's highest-test-count runtime (Operant, 9,249 tests) or the compact fully-verified engine (TDG Rust, 626 tests).

I treat AI system design as spatial machinery rather than linear text prompting. Most agent frameworks today are fragile prompt wrappers. I build load-bearing substrates:

• Graph-Native Orchestration: I replace linear shell scripts and standard pipelines with property graphs. Every execution node has typed ports; the execution engine resolves dependencies, materializes parallel branches using a Tokio-backed level scheduler, and exposes the live execution DAG to LLM operators via MCP.
• Token-Efficient Serialization: I designed and compiled the TOON (Token-Oriented Object Notation) standard. By eliminating structural syntax redundancy, TOON reduces context-window footprint by 40% to 60% compared to standard JSON, preserving deterministic validation.
• Minimal Memory footprint: I specialize in compiling highly optimized, zero-dependency static musl Rust binaries. My intelligence gathering pipelines (IGS) curate 411 sources across 47 countries while running within a 7MB static file and under 5MB of idle RAM.
• Systems Diagnostics: Drawing on my background in architectural design, spatial diagnostics, and cognitive modeling, I translate systemic risk, organizational constraints, and multi-agent network topologies into deterministic software constraints.

Terminal-native ReAct agent runtime. Rust. 9,249 tests. MCP client + server, skills, messaging channels.

A production-grade agent runtime written in Rust that runs from your shell: a real think → act → observe loop with a JSON-schema tool registry, memory-context injection every turn, provider fallbacks, and self-healing retries.

• Memory: agentmemory hybrid semantic memory (BM25 + vector + graph), auto-spawned on first use; optional Postgres backend.
• Tools: 60+ JSON-schema tools — fs, git, web, CDP browser, shell, code, http, memory, skills, cron, kanban, notes, checkpoints.
• Channels: Telegram · Discord · Slack · WhatsApp via the gateway; WASM plugins; operant autonomous dev loop.
• Local-first: no telemetry, no account; any OpenAI-compatible endpoint or a local llama.cpp / Ollama model.

Agent-directed video editing pipeline. Rust + TypeScript. 109 MCP tools, 510 tests.

A full agent-native media pipeline: take a brief, generate a script, synthesize voices, cut a timeline, and render — driven end-to-end through MCP tools rather than a GUI.

• Pipeline: brief → script → TTS → vision → FFmpeg → Remotion render, orchestrated as MCP tool calls.
• Depth: 12/12 measured sophistication families (state machines, DSLs, protocols, storage, determinism, plugins…) across 5 languages.
• Surface: 109 MCP tools — the widest tool surface in the portfolio after operant.

Education-system replacement — holonic developmental matrix. TS + Python. 61K LOC, 1,090 tests.

A structured cognitive curriculum engine: a 64-cell developmental matrix with a holonic growth model, plus a 9-command agent-first CLI (setup, status, new-game, diagnostic, curriculum, session, glossary, profile, setup-profile) — an AXI-style surface agents drive directly from the shell.

• Matrix: 64-cell developmental grid; curriculum, session, and profile state machines over it.
• Surface: mysterium bin globally installable; deterministic, non-interactive commands.
• Skills: ships structured skill libraries (workspace-lint, ui-ux-pro-max, ui-styling) as reusable agent tooling.

Professional profile extraction + Voyager profile-edit surface. Python. 51K LOC, 1,166 tests, 94 releases.

A full LinkedIn integration with a 25-command agent-first CLI and the most complete AXI ergonomics in the portfolio (6/6 axi.md signals). Every interaction is machine-parseable: TOON structured output, a --full escape hatch from content truncation, definitive empty states, size-hinted truncation, pre-computed total_count aggregates, and structured exit codes.

• AXI 6/6: the only portfolio repo implementing every axi.md principle end-to-end.
• Surface: 25 CLI commands; profile fetch, search, and edit flows agents drive deterministically.
• Track record: 94 releases — the most shipped tool in the lyr family.

Intelligence Gathering System — High-performance Rust engine. ~7MB static binary, ~5MB RSS.

A lightweight news and data ingestion pipeline scraping 411 distinct sources across 47 countries. It filters, deduplicates, and enriches global national, tech, and financial news, generating optimized intelligence feeds for agent consumption.

• Serialization: Outputs natively in TOON, saving 40% to 60% in downstream context window costs.
• Parsers: 9 custom-engineered stream parsers handling RSS, Atom, HTML tables, OFAC lists, and PDF archives.
• Efficiency: Developed to replace a slow, high-memory Node.js prototype, dropping idle RAM consumption to under 5MB.

Multi-platform intelligence gatherer and scheduler across 25 platforms. Rust. ~78K LOC.

A Rust backend with an axum REST API + rmcp MCP server, JWT auth, SSE realtime, and an in-process scheduler for cross-platform social content operations — Reddit, LinkedIn, Instagram, Telegram, Threads, Facebook, YouTube, Discord, and X/Twitter.

Teleological Developmental Graph — Pure Rust cognitive engine. 626 tests. 50 MCP tools.

A complex implementation of stateful agent memory using a holonic graph structure. Every memory unit is represented as a node: (Content, Embedding, Telos). The teleological decay algorithm ensures stale or irrelevant context decays over time while highly relevant goal nodes remain active.

• Interface: 50 custom MCP tools allowing agents to write, link, prune, and query memories using vector search combined with graph traversal.
• Validation: 626 tests total — zero warnings, zero regressions, verified against the current suite.
• Canonical: The Rust port supersedes the original Python reference (now private); tdg-rust is the single canonical TDG project.

Contract-first music compiler — from plain-language brief to mastered WAV. Rust. 12 crates, 944 tests.

A deterministic composition compiler that turns a human brief into a full-length WAV: event-sourced composition state, a validator gate with genre/register/layer checks, a production-grade layered synth, and a mastering chain. Same brief → byte-identical audio, every run.

• Pipeline: Brief → plan → compile → validate → render → master.
• Audio: Production-grade layered synth voices (SF2-sampled drums, doubled guitar, organics) with per-layer spectral auditing.
• Determinism: Byte-identical replay from contract + seed; 944 tests enforce no-regression rules.

The browserless slide factory. Rust. 46 slide types, 185 tests, ~35K LOC.

High-quality Instagram / LinkedIn / TikTok / X carousels as HTML → PNG via an embedded Blitz renderer — no Chromium, no browser, no screenshot hacks. 4.5× less memory than headless-Chrome pipelines, fully static musl binary, WCAG-AA contrast auditing, and an MCP server for AI-driven generation.

Deterministic emergent human-society simulation — every agent a complete mind. Rust. 82K LOC, 1,245 tests.

Not just a "society sim": a full cognitive-science stack — bodies, nervous systems, appraisal-based emotion, belief systems, social bonds, institutions, culture, and noospheric fields. Three architecture plans (AP1 → AP2 → AP3) deepen it from a medieval settlement into a multi-scale civilization simulation where history always emerges from locally bounded agents.

I consolidate all tools, servers, and platforms under clear protocol interfaces. This is the operational landscape of my systems:

One shared AXI-compliant architecture: every tool speaks TOON/YAML output, structured errors, and contextual help; obscura-core is the shared cookie-vault daemon underneath the browser-scraping family.

• Languages: Rust, TypeScript, Python, Kotlin, Go, SQL, Zig, Bash, MQL5
• Protocols: Model Context Protocol (MCP), Agent eXperience Interface (AXI), TOON Serialization
• Infrastructure: Docker, systemd services, PostgreSQL, SQLite, Supabase, LanceDB, n8n automation
• AI/ML Integration: local LLMs (llama.cpp, Qwen), OpenAI, Anthropic, Gemini, Whisper, Whisper Hinglish

🔒 = private repository — available on request. Contact me for access.

Tiers are scored objectively — see the ranking rubric for the machine-measured dataset, the published formulas, and the documented cap policy.

Delivery artifacts — a separate category, not tiered against the software rubric.

• 🔒 ishanparihar-svelte: SvelteKit 5 platform managing MDX blogs and Razorpay payments.
• 🔒 law-of-one-india-website: Publishing platform handling community user management.
• 🔒 design-aesthetics-website: Architectural visual landing page. GSAP animations, Three.js shaders.
• 🔒 lifeos-website: Technical marketing page and documentation outline for LifeOS.
• 🔒 webdev-portfolio: Freelance portfolio scaffold (agent prompt + design system); site source in the nested my-portfolio repo.
• 🔒 ishanparihar-cms: Web backend exposing 60+ CMS tools for content management.

Three disciplines shaped this body of work — and each is visible in how the systems are built.

• Architecture taught me to think in space and load-bearing structure. A program is a container with designed constraints, not a linear recipe — so every repo here is engineered like a building: for what it must carry under real load.
• Psychology taught me to study minds. That's why the portfolio runs deep into cognitive systems — teleological memory graphs (tdg-rust), deterministic society simulations (mindstrata), developmental matrices (mysterium). Building for agents means building for cognition.
• Engineering fuses both into infrastructure: compilers, runtimes, and protocol layers that let autonomous agents operate at production scale (operant, automaton, igs-rust, social-forge).

The throughline across all of it is the same: I build infrastructure for AI agents to operate at production scale — deterministic where it matters, verifiable everywhere, and proven by the artifacts committed beside the code.

Every sponsorship funds the open ecosystem behind this profile — new releases, test suites, CI, and infrastructure across all 42 projects:

Your support funds new features, releases, and infrastructure for the whole ecosystem.