Everything here is real software I built and operate — designed, run, and repaired end-to-end on my own multi-node GPU platform, the Forge. This is my life’s work in the open: no notebooks, no toy demos, but autonomous agents that survive for days, an MCP platform with human-in-the-loop governance, a security appliance that reasons about my own network, and production pipelines with real daily users. Every system here earned its place by doing a job I actually needed done.
Each one solves a problem I actually had, runs on infrastructure I administer, and was reviewed by my own multi-model QA gate before it shipped. They range from battle-tested production systems to active research I’m still pushing on — the badges tell you which is which. Expand any card for the architecture and the measured results.
Letting an AI act on live systems safely is a governance problem before it is a tooling problem — and it’s the one I most wanted to get right. BridgeForge is my answer: an MCP server exposing 44 tools — shell, files, vision, knowledge base, task delegation, messaging — behind dual-token auth, with node enrollment across a genuinely heterogeneous fleet, a live observability dashboard, and an append-only audit trail where every action is attributable. High-risk moves don’t just execute; they stop at a tiered human-in-the-loop gate that messages me on Telegram and waits for an explicit yes. It’s the backbone the rest of the Forge runs on — including this very page, which was written, reviewed, and deployed through it.
DesignForge is the most SaaS-shaped system in the fleet, and the one I lean on hardest day to day: an API-first review lane where every submission is grounded with its references inlined, routed by kind — design, code, spec, structural — to the model backends best suited to it, and returned as a structured verdict (APPROVE / REVISE with severity-ranked findings). Artifacts persist per run, and the orchestration layer calls it automatically for per-commit design-drift review, so nothing drifts quietly. The reason I trust it is simple: it has caught real defects in my own systems — floor overclaims, concurrency races, silent contract breaks — before they ever shipped. Having a tireless senior reviewer on call changes how you build.
Most things called “agents” are stateless request loops that forget everything the moment they answer. Ares is the opposite, and it’s the project closest to my curiosity about what a machine can become if you just let it keep running. A cloud model ensemble proposes, an adaptive weighting layer scores the votes, a judge model rules, and a stronger teacher model escalates the genuinely hard cases. What it learns is written into a persistent weighted memory graph — nodes, edges, trigger paths — that it maintains itself through its own auditing and consolidation loops, while an external watchdog enforces rate-limited revival whenever it falls over. It has run for days on end, grown its own knowledge, and picked itself back up without me — which is exactly the point.
Single-model answers fail silently — they’re confidently wrong and nothing warns you — so I built the failure mode out. The Council seats five models as equals, local and frontier alike, through opening statements, named rebuttal rounds where they argue with each other by name, and a verdict from a fresh judge that never sat the debate, with an optional adversarial auditor and a toggleable Devil’s Advocate seat for when I want the case stress-tested. Trinity is its lighter, faster sibling: a bidirectional peer-review panel where every reviewer is themselves reviewed. Together they gate every v1.0 promotion across the fleet — and more than once they’ve caught me, and each other, mid-mistake. Disagreement, made into an institution.
This is the system I’m proudest of as an end-to-end piece of engineering. GuardianForge bundles a network-model core, live radio and traffic sensors, and a knowledge store of every device and segment into a single deployable appliance. When something anomalous fires, it runs a real investigative cascade: a fast model drafts a verdict, a stronger tool-using investigator reads the draft, pulls more evidence from a curated tool registry — packet analysis, device history, evil-twin and radio-sibling checks — and a final pass writes an operator-grade incident report. An anti-hallucination gate refuses to emit any address that wasn’t in the evidence, and a three-tier enforcement ladder means dangerous actions are never automatic — they wait for my approval over Telegram.
SVA is my attempt to make machine vision economical the way biological vision is. Instead of running an expensive vision-language model over every frame, it captures screens over a live pipeline, builds a cheap peripheral change-map to see where something happened, and only then spends a deep read on the region that actually changed — a foveal attention pattern borrowed from how eyes work. It runs as a set of capture lanes with real-time change detection, feeding both interactive queries and batch deep-analysis. It’s wired into the platform as first-class vision tools, so any agent in the fleet can look at a screen and reason about it, on any enrolled machine.
Everything else on this page depends on the fleet being alive and observable, and ForgeNetwork is what makes it so. It runs as a daemon that polls every monitored node — routers, servers, links — on a tight cycle, collecting latency, reachability, WAN and VPN state, load, memory, connected clients, and periodic throughput tests, then stores it all as a time-series and surfaces it through REST endpoints and a live dashboard tab. It started as a single-router watchdog and grew, deliberately, into the monitoring backbone for the whole home-lab estate. When a node flaps at three in the morning, this is the system that already knows.
Literary translation is where ordinary machine translation goes to die: voice, idiom, and consistency across a whole book matter far more than getting the gist right. TranslateForge is a multi-pass LLM pipeline with a reviewer-in-the-loop UI, built for — and continuously shaped by — a working professional literary translator who uses it on real manuscripts every working day. Every one of its eleven-plus sprints of iteration came from an actual book meeting an actual deadline, not a synthetic benchmark. It’s the clearest proof I have that these systems earn their keep only when someone genuinely depends on them, and lives on its own public subdomain because it’s a real product, not a demo.
Every model earns its seat here the hard way: per-timeframe champions are selected by measured evaluation win rate, and the top timeframe runs a live consensus of the local champion, an API reasoning model, and a frontier judge before it will commit to a call. A real-time futures monitor feeds the whole thing, and a portfolio-level liquidation-surface controller manages cross-margin risk across positions. I want to be precise about what this is: all figures here are measured evaluation metrics from the harness, and this is research instrumentation — a study in whether disciplined model competition and consensus can be quantified — not a returns claim or financial advice. The discipline of measuring honestly is the actual product.
ChessForge is where a lot of the Forge’s honesty machinery was first forged in fire. Rather than train a network, it evolves the natural-language reasoning prompt itself — the plain-English description of how to think about a position — and tests each generation against a real Stockfish opponent for an honest signal instead of self-play echo chambers. Tactics it discovers are promoted into a knowledge store with confidence scores; ones that stop working are demoted. The hard lesson that shaped everything downstream: it once graded itself brilliantly while losing every game, so I built strict anti-hallucination checks and grade caps that refuse to reward a system with zero wins. Fully explainable, and honest to a fault by design.
The Brain is the next step in the whole program, and the one I’m building most carefully. It sits above the review and deliberation stack and asks a hard question: how do you let a weak, cheap local model — or a frontier one, or me by hand — drive powerful capabilities without anything unsafe slipping through? The answer is a single non-bypassable dispatch chokepoint that mints a signed ticket for every action; organs refuse to move without one. Its governing doctrine is that the digest informs and the grammar constrains — an unsafe action is simply absent from the menu a small model is offered, never a rule it has to remember to follow. It carries layered memory, a self-repair engine, and an ownership matrix ratified through my own Council. Early, unfinished, and the piece of architecture I’m most excited about.
Across the fleet a single pattern kept proving itself, so I made it a family. Each Architect owns one domain — vision, translation, prompts — and does the same disciplined job: resolve the best prompt for the task, route to the right model backend, judge the result on explicit quality axes (accuracy, completeness, structure, specificity, no-hallucination), and fold every human correction back into a learning store so the next answer is better. TranslateArchitect runs in production inside TranslateForge, learning from a professional’s edits; VisionArchitect governs every vision workload with a routing table and a five-axis judge; PromptArchitect underpins the agent pipelines. It’s the closest thing the Forge has to a house philosophy, written as running code: never trust one model blindly, always judge, always learn.
The flagships are not islands. They stand on three shared foundations — an engine, an optimizer, and a memory — that I built once and reuse everywhere.
Everything above runs on a self-hosted, multi-node GPU platform I designed and administer end-to-end: built primarily in Python (FastAPI), service management under systemd, public edges through Cloudflare tunnels, a strict credential-handling pattern, tiered verification gates (L1–L3) before anything is promoted, automated cross-node backups, and institutional memory so no decision is lost between sessions.
> I run AI systems the way production infrastructure is run — because that is where I come from.
Beyond the twelve flagships — the working systems that fill out the platform. Smaller in scope, but each one real, each one built to do a specific job well.
AI Systems Engineer — 25+ years across enterprise infrastructure and telecom, most recently as a Principal Technical Support Engineer. MSc Open Systems Architecture and BSc Electronics & Computer Science, Politehnica University of Bucharest. Oracle Cloud Infrastructure 2025 Generative AI Professional and AI Foundations Associate.
Open to senior AI/infrastructure engineering roles — full-time or B2B contract.
Email is the front door — or use the form on the main site. Prefer voice? Request a call by email and I'll confirm a slot.
./email me ./contact form ./linkedin