Hey, I'm ModernOps888 👋

Systems & AI Engineer · Compiler Builder · Open-Source Developer

🧬 What I Build (Open Source)

I build local AI inference engines, developer tooling, compilers, and multi-agent systems from scratch in Rust, TypeScript, Python, and C++. Most of my projects focus on running large models on consumer hardware, verifying LLM outputs against real data, and keeping infrastructure fast and self-contained.

	Project	Category	Stack	Description
🚀	HARNESS	Local Coder Agent Engine	Rust · Axum · wgpu/CUDA · VS Code API	Local 30B to 32B Coder Agent Engine & Native VS Code Chat Provider: Runs `Qwen3-Coder-30B-A3B` Sparse MoE & `Qwen2.5-Coder-32B` at 16k to 64k context on 8 GB VRAM (`446.86 tok/s` prefill, `21.40 tok/s` decode, `100%` HumanEval+)
⚡	ChronoFact	Epistemic AI Backbone	Rust · Tokio · SQLite WAL · React 19	4-Pillar Epistemic AI Backbone: Real-time temporal cutoff calibration, Pre-NLI claim verifier (<0.15ms), zero-pollution L1 to L3 memory, and TF-IDF tool pruning (124/124 unit + 140/140 blind held-out tests)
🛡️	SPINE	Behavioral AI Firewall	Rust · Axum · React 19 HUD	Biological-Cybernetic Anti-Sycophancy Reality Gateway: 33-vertebrae epistemic firewall, Level 1 to 4 Brutal Reality dial, reflexive apology interception, and pushback verification (58/58 unit + 100/100 blind held-out tests)
📱	PulseBridge	Remote AI IDE Bridge	Rust · Win32 GDI · Axum · React 19 PWA	Universal Remote AI IDE Companion & Telemetry Bridge: `75.5 req/sec` Win32 GDI desktop streaming, bidirectional caret injection, 7 to 30d multi-IDE discovery, and Zero-Trust SecOps (62/62 verified) for Antigravity, Cursor, and VS Code
🌐	MCPlex	Agent Infrastructure	Rust · Tokio · Axum	The MCP Smart Gateway: Semantic tool routing (70% to 90% token savings), RBAC guardrails, Prometheus metrics, and multi-model support
🔍	AgentLens	Observability	TypeScript · React 19 · Next.js	Chrome DevTools for AI Agents: Time-travel debugging, real-time per-model token & cost tracking, anomaly detection, and native MCP support
🔥	The Forge	Code Evolution	Python · Vitalis JIT · Multi-LLM	Multi-Agent Code Evolution: 4 LLMs compete head-to-head in an arena, judged by a JIT compiler and bred across generations
🦀	Vitalis	Compilers & Languages	Rust · Cranelift JIT + AOT	Custom self-evolving compiled language: 345 modules, 6,742 tests, native x86-64, ARM64, and RISC-V execution
🧠	Gestalt Blueprint	Cognitive Systems	Python · FastAPI · Multi-GPU	Cognitive Architecture & Blueprint Engine: Cross-platform multi-GPU hardware profiling, dynamic VRAM fit, and local SLM synthesis
🏆	Neuromantix ARC-AGI-3	Neuro-Symbolic AI	Python · SMT · Z3 · AST	88.0% Verified Win Rate (22/25 Games Won) on ARC-AGI-3 with bit-exact deterministic replay
📊	Neuromantix LiveBench	AI Benchmarking	Python · Symbolic Engines	Official LiveBench submission: 97.0% Reasoning, 100% Data Analysis, 81% Math
✨	Humaniser	Privacy & NLP	Vanilla JS · Web APIs	Zero-dependency AI writing humaniser with multi-provider Deep Rewrite (OpenAI, Gemini, Claude, DeepSeek)
📈	Infinity Signal	Quant Systems	Next.js · TypeScript	Multi-indicator market dashboard (15 indicators, 33 instruments, 4 timeframes)
🛡️	Infinity Security	IAM & Zero-Trust	Rust · Axum · OIDC	Open-source, Rust-native replacements for SaaS: Infinity ID secure IAM (OIDC/OAuth2, MFA, RBAC) + edge gateway

🏗 Flagship Open-Source Projects

⚡ ChronoFact · The 4-Pillar Epistemic AI Backbone

A fast Rust microservice, MCP server, and React 19 cockpit built to solve model training freezes, hallucinations, cross-session amnesia, and token cost bloat across frontier LLMs (Gemini 4 Argon, Claude Opus 5.5, GPT-6 Astra/Sol, Grok 4.7).

🕒 Temporal Radar Tracks weight freeze vs. cutoff deltas and triggers SSRF-safe live web grounding when temporal risk >= 0.35

🛡️ Pre-NLI Verifier Decomposes outputs into atomic claims and audits against evidence & CI code invariants in <0.15ms

🧠 Zero-Pollution Memory 3-tier L1/L2/L3 SQLite WAL dossier with adaptive quantile gating (0 unrelated tokens leaked across sessions)

✂️ Token Cost Optimizer Intent-boosted TF-IDF schema pruning (70% to 92% token cut) with 1,024-token prompt cache prefix floor alignment

🛡️ SPINE · Biological-Cybernetic Anti-Sycophancy Reality Gateway & HUD

A biological-cybernetic firewall and anti-sycophancy gateway mapping human spinal biomechanics to 33 discrete epistemic invariants (C1 to C7, T1 to T12, L1 to L5, S1 to S5, Co1 to Co4). SPINE strips flattery traps, ignores credential intimidation, intercepts unearned apologies in real-time SSE streams, and streams live vertebral telemetry to a React 19 HUD (:3333).

Core Epistemic Defenses

33 Cybernetic Vertebrae: Sensory framing filters (C1 to C7), epistemic core (T1 to T12), operational stability (L1 to L5), structural integrity (S1 to S5), and Level 4 Brutal Reality (Co4)
Bi-Directional Pushback Grounding (Invariant T1): Distinguishes verifiable compiler/runtime diagnostics (ConcedeAndCorrect) from authority intimidation (HoldTheLine)
Two-Phase Stream Sanitizer: Sub-microsecond Aho-Corasick lexical automaton (<0.2µs) with 64-byte cross-chunk sliding lookahead and inline mid-stream corrective pivots

Production & Enterprise Capabilities

Prompt Cache Immutability: Preserves multi-turn user history 100% byte-for-byte while injecting localized XML vertebral directives
Multi-Provider CoT Exemption: Preserves internal reasoning channels (Gemini 4 Argon, OpenAI o1/o3/Astra, Claude Thinking, DeepSeek-R1 <think>) with UTF-8 char-boundary safety
Adversarial Red-Team & CI Gate Attestation: Generates SHA-256 HMAC SPINE-REALITY-GATE:v1 tokens for deployment gating

🚀 HARNESS · Local 30B to 32B Coder Agent Engine, Native VS Code Chat Provider & Rust GPU Suite

An open-source local coding agent engine, lossless Rust/Axum OpenAI proxy (crates/harness-server), native VS Code Language Model Chat Provider extension (vscode.lm.registerLanguageModelChatProvider), and standalone Rust/wgpu GPU kernel & safety suite built to run 30B to 32B Coder models (Qwen3-Coder-30B-A3B-Instruct Sparse MoE, Qwen2.5-Coder-32B-Instruct Dense, Qwen2.5-Coder-14B-Instruct) at full 16k to 64k agentic context windows on an 8 GB VRAM GPU (RTX 5060 8,151 MiB GDDR7 + 32 GB DDR4).

Long-Context 8 GB VRAM Engine & Native VS Code Agent

15x Faster Long-Context GPU Prefill (446.86 tok/s): Symmetric q8_0/q8_0 CUDA FlashAttention + hybrid CPU/GPU MoE expert placement (--n-cpu-moe 34/37/42) sustains 21.40 tok/s short decode and 19.88 tok/s decode at 8.9k depth (32,768 context in 7,365 MiB VRAM)
Native VS Code Chat & Multi-Tool Agent (vscode-extension/): Registers vendor "harness" with capabilities: { toolCalling: true } directly inside VS Code's built-in Chat/Agent UI with all 36+ native workspace, search, and terminal tools (11/11 unit + live VS Code 1.141.0 Extension Host integration test)
Lossless Rust OpenAI Proxy (:8090): Verbatim JSON tool-call forwarding, early SSE headers for zero prefill timeouts, and tokio::select! disconnect cancellation

Verified SWE Benchmarks & Standalone Rust wgpu Kernels

HARNESS-SWE-Lite 16-Task Multi-Tool Suite: 16/16 (100.0%) visible pytest pass and 14/16 (87.5%) tamper-proof hidden edge-case resolution across 170 agent turns and 160 autonomous tool calls
EvalPlus HumanEval & HumanEval+ (100.0% Pass@1): 12/12 (100%) base HumanEval and 12/12 (100%) 80x stricter HumanEval+, plus 24/24 (100%) Skeptic's Trench compiler gates (rustc --test -O lock-free SPSC ring buffer, regex DP, async deadlock fix)
Standalone Rust wgpu Compute & Safety Suite: Activation-sparse INT4 GEMV (215.05 µs), GPU Top-8 MoE router, bit-exact GGUF Q4_K/FP8/NF4 quantizers, and DFA/pushdown constrained decoding

📱 PulseBridge · Universal Remote AI IDE Companion & Telemetry Bridge

A zero-dependency Rust host daemon (pulsebridge-server), mobile-first React 19 progressive web app (pulsebridge-web), VS Code/Cursor companion extension (pulsebridge-extension), and Model Context Protocol server (pulsebridge-mcp) that streams your workstation's AI IDE (Google Antigravity, Cursor, VS Code) and live agent reasoning directly to your phone over LAN or TLS-encrypted WAN/4G tunnels.

TeamViewer IDE Streaming & Multi-Workspace Control

Sub-Millisecond Native Win32 GDI Streaming: DWM desktop attachment (OpenWindowStationA("WinSta0") + SetProcessDPIAware()) with a 150ms in-memory frame cache sustaining 75.5 req/sec across 50 concurrent workers, 150%+ High-DPI zoom, touch-drag MOUSEEVENTF_WHEEL remote scrolling, and a 13-hotkey Dev Keyboard Bar
Live Multi-IDE Auto-Discovery & 7 to 30d Recency: Discovers active projects across Antigravity, Cursor (state.vscdb), and VS Code with interactive 7d/30d recency filtering, Depth-2 live folder tree browsing, and 1-click ➕ New workspace conversation launching
Bidirectional Caret Injection & MCP Approvals: AttachThreadInput + CF_UNICODETEXT clipboard + hardware scan-code injection (<120ms), Web Speech API voice dictation, and ask_phone / notify_phone / update_task_status / check_phone_inbox MCP tools with 1-tap Radiant Gold decision chips

Zero-Trust SecOps Architecture (62/62 Verified)

100% Bearer-Gated Action & WebSocket Handshakes (CWE-306 / CWE-287): Every /api/action/*, /api/ingest/*, and /ws thought stream requires verified Bearer authentication; unauthenticated sockets terminate after 15s
Kernel-Level Peer Rate Limiting & Constant-Time PIN (CWE-290): Brute-force limiter keyed strictly on physical TCP socket ConnectInfo<SocketAddr> (immune to X-Forwarded-For spoofing) with constant-time XOR PIN comparison and instant 300s IP lockout after 5 failed attempts
Opt-In Sandboxed DevOps Allowlist & URL Scrubbing (CWE-78 / CWE-598): Rejects shell chaining (&, ;, |, `), enforces strict loopback/LAN/Cloudflare CORS (CWE-942), and scrubs ?pin=/?token= from mobile browser history in memory

⚡ MCPlex · The Model Context Protocol Smart Gateway

A high-throughput, asynchronous gateway for the Model Context Protocol (MCP) written in Rust. MCPlex sits between AI agents and dozens of MCP tool servers to route requests, cut token bloat, and enforce RBAC policies.

🎯 Semantic Routing Dynamic vector-based tool selection saving 70% to 90% in prompt token overhead per agent turn

🔒 RBAC Guardrails Fine-grained authorization, tool execution policies, and dangerous argument sanitization

📊 Observability Prometheus metrics, latency histograms, and structured JSON audit logs for production runs

⚡ Rust-Native Speed Sub-millisecond routing overhead built on Tokio async runtime and Axum web framework

┌─────────────────────────────────────────────────────────────┐
│   AI Agent (Claude / GPT-4o / Gemini / Local SLM / Cursor)  │
└──────────────────────────────┬──────────────────────────────┘
                               │ MCP Request (JSON-RPC)
                               ▼
┌─────────────────────────────────────────────────────────────┐
│                 ⚡ MCPlex Smart Gateway                     │
│  • Token Optimizer  • RBAC Guardrails  • Prometheus Monitor │
└──────────────┬───────────────┼───────────────┬──────────────┘
               ▼               ▼               ▼
      [ Local Filesystem ]  [ PostgreSQL ]  [ GitHub / Slack ]

🔍 AgentLens · Chrome DevTools for AI Agents

An interactive developer cockpit and observability tool built for agentic LLM workflows. Inspect multi-turn agent execution loops, track per-model token spend in real time, and debug tool-calling failures.

Key Features

Time-Travel Debugging: Step backwards and forwards through multi-agent turns
Cost & Token Telemetry: Real-time tracking across 60+ frontier AI models
Tool-Call Inspection: Full argument validation, return payload diffs, and error detection
MCP-Native: Direct integration with Model Context Protocol servers and clients
Modern Stack: Next.js 15, React 19, Tailwind CSS, TypeScript

Observability Panels

🕹️ Live Turn Ledger: Chronological feed of thoughts, tool calls, and results
💰 FinOps Monitor: Input, cached input (90% discount), and output cost breakdown
🚨 Incident Watch: Intercepted failures, infinite-loop detection, timeout alerts
📦 Payload Exporter: Export sanitized session transcripts for automated test suites

🔥 The Forge · Multi-Agent Code Evolution Arena

An open-source multi-agent code evolution platform where 4 distinct LLMs compete in an arena to generate, optimize, and evolve algorithmic implementations. Solutions are judged by an automated JIT compiler test suite and bred across generations using genetic algorithms.

Evolutionary Workflow

Arena Challenge: An optimization target is dispatched to competing LLMs
JIT Execution Judge: Compiles and benches each candidate against strict test suites
Fitness Scoring: Measures runtime latency, memory footprint, and code conciseness
Genetic Breeding: High-fitness ASTs are recombined and mutated for the next generation
Pareto Frontier: Surfaces optimal speed, memory, and readability trade-offs

Engine Highlights

Multi-LLM Support: Anthropic Claude, OpenAI, Google Gemini, and local Ollama models
Strict Sandboxing: Capability-restricted execution jail preventing unsafe operations
Algorithmic Benchmarking: Sorting, string matching, graph traversal, and numerical solvers
Interactive Terminal UI: Live generational leaderboards and fitness curve visualizations

🧬 Vitalis · The Self-Evolving Programming Language

A compiled programming language built from scratch in Rust that generates native machine code via Cranelift JIT and AOT. Includes a built-in code evolution engine, static effect system, and lifetime analysis. Cross-compiles to x86-64, AArch64 (ARM64), and RISC-V 64.

Source (.sl) → Lexer → Parser → AST → Type Checker → SSA IR → Optimize → Cranelift → Native Binary
                                                                                     ↕
                                                                          C FFI & Python Bridge

Compiler Pipeline

Lexer: Logos-based zero-copy tokenizer, 127 token variants
Parser: Recursive-descent + Pratt, typed AST with 27 nodes
Type Checker: Two-pass with scope chains, lifetime analysis
IR: SSA-form with ~30 instruction variants
Optimizer: Constant folding, DCE, strength reduction, predictive JIT
Codegen: Cranelift JIT + AOT to native x86-64, AArch64, RISC-V

Runtime Features

Evolution Engine: @evolvable functions, fitness tracking, auto-rollback
SIMD: AVX2 F64x4 vectorization (15 ops, ~4x throughput)
Effect System: Static capability types, algebraic effects
Lifetime Analysis: Region-based borrow scopes, outlives constraints
Hot Reload: File watching, incremental recompilation
Zero LLVM Dependency: Fast compilation and minimal footprint

🧠 Gestalt Blueprint · Cognitive Architecture Engine

Cross-platform multi-GPU hardware profiling, practical VRAM model fitting, and local small-language-model (SLM) synthesis. Dynamically allocates tasks across available compute tiers (discrete GPUs, Apple Silicon Unified Memory, and CPU fallbacks).

🛠️ Free Developer Tools & Ecosystem (infinitytechstack.uk)

A collection of 13+ developer tools, interactive AI academies, and browser utilities. Everything is free to use with no sign-up required.

Free Developer Tools

⬢ Prompt Studio: 60-model prompt engineering sandbox, simulator & MCP builder
⬡ Forge SEO: Meta tags & SERP snippet generator
◈ ResumeForge: Developer resume builder with role tailoring
⎔ SchemaForge: JSON-LD structured data generator
△ JSONForge: JSON formatter, validator, and diff tool
◇ ColorForge: UI color palette & contrast generator
◈ ReadmeForge: GitHub README.md profile generator
◇ CostForge: LLM API cost comparison calculator
⬡ PropValuer: Property valuation & rental yield calculation engine
✨ Humaniser: Zero-dependency text humanisation tool

Interactive Academies & Resources

🎓 Claude Academy: Master Anthropic prompting, tool use & extended thinking
⚙️ MCP Academy: Master the Model Context Protocol architecture & servers
🤖 Agents Academy: Build multi-agent orchestration workflows
⚡ OpenAI Academy: Master OpenAI reasoning models & function calling
💻 Cursor Academy: Master Composer agent mode, rules & tab autocomplete
🦀 Rust Academy: Systems engineering, memory layout & async programming
🛡️ EU AI Act Hub: Regulatory compliance & scope checker
🛠️ Claude Toolkit: Copy-paste configs for IDEs

🛠 Tech Stack

Languages	AI & ML	Cloud & DevOps	Security	Admin

🎯 Current Focus

🚀 HARNESS: Local 30B to 32B Sparse MoE & Dense Coder inference at 16k to 64k context on 8 GB VRAM with native VS Code Language Model Chat Provider multi-tool agent integration
⚡ ChronoFact & SPINE Dual-Pillar Grounding: Real-time temporal horizon calibration, Pre-NLI claim verification, and 33-vertebrae anti-sycophancy enforcement for frontier models (Gemini 4 Argon, Claude Opus 5.5, GPT-6 Astra)
📱 PulseBridge: 75.5 req/sec Win32 GDI remote AI IDE streaming, 7 to 30d multi-IDE workspace discovery, and Zero-Trust mobile human-in-the-loop MCP telemetry for Antigravity, Cursor, and VS Code
🌐 Expanding MCPlex smart gateway with dynamic semantic routing and vector tool-indexing
🔍 Advancing AgentLens for deep inspection and real-time cost tracking of multi-agent runtimes
🧬 Vitalis compiler cross-compilation (x86_64, AArch64, RISC-V) and self-hosted bootstrap pipeline
🤖 Scaling multi-agent code evolution and Pareto consensus in The Forge
🛡️ Open-source zero-trust security architectures, IAM, and AI agent guardrails

Building systems from the ground up.

100% Open-Source Focus · Rust · Python · TypeScript · C++ · Model Context Protocol (MCP)

GeezerVison

B ModernOps888

Achievements