Anthony Perry Perry5216

Anthony Perry

London, UK · LinkedIn · GitHub · Portfolio Harness

[ Primary DRI: Spark Cluster (:8877) ] <─── Tandem Loop ───> [ Reflex Engine: RTX 5090 Blackwell (:8080 @ 198.8 tok/s) ]
  ├── C++20 Code Generation & Test Suites                       ├── < 2.5s MSVC AST Error Triage (2k Budget)
  └── Multi-Subsystem Composition                               ├── Whole-Module Synthesis (32k Resident KV)
                                                                └── Fowler Code Smell & ADR 0002 Linter

Engineering Philosophy: Empirical Rigor Over Hype

"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."

For Technical Hiring Managers & Headhunters: Preempting the Hard Questions

"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."

1. "Is this an API wrapper or actual systems engineering?"

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 + isolated display GPU).
Sub-Second Reflex Inference: Local OpenAI-compatible reflex endpoint delivering sustained 198.8 tokens/second on Blackwell tensor cores, executing compiler AST diagnostics in under 2,500 ms (empirically benchmarked: 4,096 tokens generated in 20.6s).
32,768-Token VRAM-Resident KV Cache: 131,072-token total context window with a dedicated 32k-token resident INT8 KV cache in GDDR7 VRAM, preventing host RAM thrashing during whole-module generation.
Empirical Rigor in Public (Zero Bluffing): Engineering means measuring real failure modes. When modern reasoning models starved their output token envelope inside <think> blocks, I diagnosed the Strata token exhaustion bug and implemented a Two-Tier Budget Model: strict 2,048-token / 512-reasoning-budget envelopes for sub-3s compiler triage, and up to 32,768 tokens for whole translation unit synthesis.
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).

2. "How do you guarantee agents don't hallucinate or pollute production repositories?"

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

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.
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.
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.
Topological Ticket DAG: Tasks are resolved in strict dependency order, preventing out-of-order feature execution and cyclic deadlocks.

3. "Can your systems handle massive native enterprise repositories?"

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).

4. "What roles am I primed to execute on day one?"

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.

5. "How do I verify your work in 10 seconds?"

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 Standards: Engineering Invariants

Conventional Agentic Setups	My Autonomous Production Harness Standard
Unconstrained Chat Prompts	Topological Ticket DAG: Strict dependency ordering prevents out-of-order execution
Mocks Assertions / Accepts Failures	Zero "Green When Untrue": Dual gate ($LASTEXITCODE == 0 + stdout sentinels)
Monolithic Model Overload	Asymmetric Tandem: Spark Cluster (DRI) + RTX 5090 Blackwell (Fast Reflex @ 182 tok/s)
Working Tree Pollution	Git Worktree Sandboxes: Ephemeral task workspaces with zero-residue rollback
LLM Architectural Drift	ADR 0002 Linter: Automated static guardrails intercept and reject God-class bloat

Flagship Systems & Active Projects

Autonomous AI Engineering Harness

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

Asymmetric Tandem Inference: Spark Cluster (DRI) generates complex multi-file C++20 subsystems, while a dedicated local NVIDIA RTX 5090 Blackwell (:8080 @ 198.8 tok/s) acts as the low-latency reflex triage engine.
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

P.E.R.R.Y. Autonomous Orchestration Ecosystem

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.

Low-Level Systems, Reverse Engineering & Hardware

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++).

Engine Architecture, Simulation & Graphics (C++20)

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).

Foundational Software & Academic Game Projects (Click to expand)

flurrE — Year-one Unity physics platformer (Rayman / Super Meat Boy mechanics).
Snails — Year-two team multiplayer game project (Unity / C#).
Ticketing-System — Year-two C++ OOP console architecture with file-backed persistence.
Axe-Game — Foundational C++ game loop and collision math.
Creep / The-Creeper — Procedural 2D simulation and entity management experiments.

Navigation Menu