London, UK · LinkedIn · GitHub · Portfolio Harness

[ Primary DRI & Coder: 5090 Blackwell / Spark ] <─── Tandem Loop ───> [ Independent Auditor & Reflex: 5090 Blackwell ]
  ├── 205-303 tok/s Whole-Module Synthesis (IQ2_XS 99.5% Cache Hit)     ├── < 2.5s Web-Grounded AST Triage & Zero-Leakage Double-Blind Audit
  └── 27-Skill Matt Pocock Agentic Loop (fit_max_tokens: true)           └── Fowler Smell Linter & Refactor Gate (Exit 0 + Sentinels)

"In the era of AI-accelerated software engineering, the biggest risk is unearned confidence. I don't believe in 'vibe coding' or taking model outputs on faith.

When models can generate thousands of lines in seconds, the role of the engineer shifts from typing syntax to enforcing ground truth. That is why every system I build is anchored in ruthless determinism: binary exit codes, deterministic test sentinels, isolated sandboxes, and hardware profiling.

I don't ask anyone to take my word for it—I let the compiler, the test harness, and the live telemetry speak for themselves."

"Most candidates can write prompts. Very few know what happens when the compiler throws an AST recursion error at 3 AM or how to prevent an autonomous agent from destroying a production codebase."

• Bare-Metal Compute Ownership: Dedicated heterogeneous multi-GPU infrastructure running on bare metal (NVIDIA RTX 5090 Blackwell sm_120 32GB GDDR7 + multi-node Spark cluster + completely isolated secondary RTX 5070 Ti 16GB display/gaming GPU).
• Sub-Second Reflex & High-Throughput DRI: Local OpenAI-compatible endpoint delivering sustained 205.6–303.7 tokens/second on Blackwell tensor cores under IQ2_XS quantization with 18,514 resident expert slots (75.3% in GDDR7 VRAM) and a verified 99.5% GPU cache hit rate.
• Hardware Isolation & Memory Tuning: Reduced host RAM arena from 46.8 GB to 33.0 GB, saving ~14 GB physical RAM so the host system can run simultaneous heavy AAA gaming loads on the secondary 5070 Ti at 95% utilization with zero micro-stutter while continuous autonomous AI engineering loops run in parallel.
• Double-Blind Clean-Room Audit Architecture: Enforced strict isolation between implementation and review passes: the independent auditor evaluates only ticket contract specifications and git diff with zero visibility into the author agent's internal prompt history or reasoning scratchpad, actively enforcing Fowler clean-code standards and deterministic test gates.
• Live Web-Grounded Failure Triage & Fast SSD Knowledge Cache: Just like a senior human engineer looking up authoritative documentation when encountering a compiler fault, the reflex triage loop extracts error signatures and automatically queries live technical documentation (Microsoft Learn, language specifications, Stack Overflow) via headless research tools, feeding verified ground-truth receipts directly into the 5090 Blackwell prompt to eliminate hallucinated fixes. Backed by a local NVMe/SSD cache with 7-day TTL auto-eviction and LRU limits, dropping repeated failure triage latency from ~3.5s down to <1ms.
• Low-Level Native Systems: Proven experience across physical PCIe DMA hardware capture, second-PC memory reconstruction, and C++20 game engine memory management (ezDynamicArray, move semantics, memory barriers).

I engineer closed-loop deterministic harnesses, not open-ended chat scripts. Every autonomous task is constrained by Four Iron Invariants:

1. Zero "Green When Untrue": A test is only marked passing if both the binary exit code is strictly zero ($LASTEXITCODE -eq 0) and all required stdout sentinel regexes match. Zero mock passes.
2. Git Worktree Sandboxing: Every agent turn runs in an ephemeral Git worktree. Failed attempts are destroyed with --force at the filesystem and Git ref level. The main integration branch is only touched via fast-forward merges on certified green builds.
3. ADR 0002 Static Architectural Linters: Automated diff analysis rejects any patch that attempts to dump subsystem algorithms directly into core engine God-classes before compilation is even scheduled.
4. Topological Ticket DAG: Tasks are resolved in strict dependency order, preventing out-of-order feature execution and cyclic deadlocks.

• Validated Against ezEngine: The active harness runs autonomously against ezEngine, a massive, production-grade C++20 multi-million-line codebase with CMake, Ninja, and MSVC toolchains.
• 135+ Verified Checkpoints: Autonomously writes, compiles, and verifies subsystems spanning organ anatomy & bionics, 24-hour schedules, multi-octave coherent worldgen, thermodynamic heat diffusion, pressurized fluid networks, and multi-personality storytellers.
• Autonomous Self-Healing: Real flight recorder incident: MSVC fatal circular header dependency (C2061) and ezDynamicArray buffer reset diagnosed and patched in 2,766ms without human intervention (Flight Recorder JSON).

• Applied AI Engineer (Autonomous Coding / Codex / Devin-Class Agentic Loops): Designing evaluation harnesses, multi-agent co-processors, self-healing compiler loops, and deterministic execution environments.
• AI Systems & Inference Infrastructure Engineer: Managing high-throughput local inference, heterogeneous cluster scheduling, GPU VRAM budgeting, and local LoRA fine-tuning pipelines.
• Systems & Engine Software Engineer: Low-level C++20 architecture, simulation graphs, hardware memory introspection, and high-performance native tooling.

Clone the harness and run the automated integrity verification suite:

git clone https://github.com/Perry5216/autonomous-ai-engineering-harness
powershell -ExecutionPolicy Bypass -File ./autonomous-ai-engineering-harness/scripts/verify-harness.ps1

Production-grade autonomous engineering harness featuring asymmetric dual-model architecture, zero "green when untrue" verification, double-blind clean-room code review, and self-healing C++20 compiler loops.

• Asymmetric Tandem Inference & Double-Blind Review: Spark Cluster / 5090 Blackwell generates code with the 27-skill DSH deck, while a dedicated local NVIDIA RTX 5090 Blackwell (:8080 @ 205.6–303.7 tok/s) acts as both the low-latency reflex triage engine and an independent, clean-room code auditor.
• Zero "Green When Untrue" Verification: Tests are only certified passing when both conditions hold: binary exit code is strictly zero ($LASTEXITCODE -eq 0) and all required stdout sentinels are verified. Zero hallucinated or mocked test passes.
• Git Worktree Sandboxing: Ephemeral task-per-worktree execution prevents dirty workspace poisoning, index lock collisions, and state leakage. Atomic promotion via fast-forward merge on green gate; zero-residue rollback on failure.
• Autonomous Compiler Self-Healing: Real flight recorder incident: MSVC fatal circular header dependency (C2061) and ezDynamicArray buffer reset diagnosed and patched in 2,766ms without human intervention.
• Deterministic Ticket DAG: Dependency-ordered state machine resolving tasks in strict topological order.
• Live Visual Dashboard: Interactive Telemetry Board - 135 / 135 Verified Checkpoints Passing
• Flight Recorder Incident Telemetry: Raw Incident JSON Dump

High-throughput sub-bucket sliding window rate limiter and three-state circuit breaker engineered with microsecond monotonic clock seams and double-blind clean-room audit verification.

• Sub-Bucket Sliding Window (ADR 0001): Memory-bounded discrete bucket counters with exact sliding window replenishment and microsecond-precision resetMs calculation preventing retry storms.
• Three-State Transient Fault Isolation: CLOSED/OPEN/HALF_OPEN state machine featuring bounded probe concurrency, fallback execution, and deterministic recovery.
• Double-Blind Clean-Room Audit Verified: Full code evaluated and audited by an independent local 5090 Blackwell auditor with zero prompt leakage, scoring an A (91/100) — APPROVED across Fowler clean-code standards and deterministic test gates.

Self-hosted multi-agent platform and local LoRA training pipeline running on dedicated multi-GPU infrastructure.

• Perry v2: Typed monorepo (18 packages) orchestrating autonomous task DAGs, fail-closed security gates, Cursor-style browser sidecars, and evidence-based knowledge harvesting across a heterogeneous GPU cluster (5090 Blackwell + Spark + 5070).
• Perry System (v1): Self-hosted multi-agent AI orchestration platform featuring an autonomous self-learning loop and LoRA fine-tuning infrastructure.
• Blackwell sm_120 Training Pipeline: Custom Vanilla HuggingFace LoRA fine-tuning stack (TRL + PEFT + bitsandbytes) engineered for the RTX 5090 Blackwell architecture, featuring GGUF export via llama.cpp and automated Ollama model registration.

• eft-dma-radar — PCIe DMA hardware memory acquisition toolchain; physical memory layout discovery, scatter-read optimization, and external game state reconstruction (C#).
• csgo-dma-overlay — Second-PC HDMI passthrough overlay fed strictly from hardware DMA-acquired memory without host software footprint.
• Nathans-Tarkov-Radar-Public — External physical memory reconstruction and real-time state synchronization pipeline.
• BasicGameTrainner — Process memory introspection and pointer-chain analysis (C++).

• ezEngine Colony Plugin — Complex colony simulation engine running inside ezEngine. Features 135+ automated C++20 test checkpoints across organ anatomy & bionics, 24-hour schedules, multi-octave coherent worldgen & clustered ore veins, sub-zero freezers & rot prevention, 5-factor room impressiveness, and multi-personality storytellers.
• Merlin-Game-Engine-CPP — Full custom C++ game engine architecture built from scratch; component systems, rendering pipeline, and memory management.
• Ol-baid — Final-year university dissertation and capstone project integrating engine systems, custom shaders, and graphics architectures.
• Spider — GPU compute and animation experiment: real-time procedural spider navigation on arbitrary 3D spherical manifolds (C++ / OpenGL).
• ProjectDoppelgangerV4 — Unreal Engine 5 multiplayer first-person gameplay systems (C++ / Gameplay Ability System).