Lucas Nguyen_

A multi-agent platform where AI agents build, review, and ship code under enforced quality gates — a daemon serving a git-worktree deploy with guardian auto-promotion, a one-way baseline-ratchet gate system, isolated parallel-agent commits, and a code-graph integrity engine. A living System Map renders the whole OS as a circuit board over real telemetry. The meta-system that builds the others.

• Daemon serves a git-worktree deploy; a guardian auto-promotes master
• One-way baseline-ratchet gates block new findings, grandfather old ones
• Isolated parallel-agent commits (cowork) + code-graph integrity (keelloom)
• A living System Map draws the whole OS as a motherboard — blueprint layout, signal-driven glow, and particle data-flow over live telemetry

TypeScript/Node Git internals SQLite Multi-agent orchestration LLM tooling

9,000+ unit tests green Multi-stage promotion gates Local-model swarm

Three production websites sharing one Laravel monorepo and a foundation of composer packages (platform/content/media/accounts), fronted by an MCP gateway that lets an AI author content directly: seedy.farm (a 6-locale gardening blog migrated from WordPress), veritart.me (this AI-authored gallery), and oldbooks.me (a classical Tang-poetry corpus with original translations).

• Shared foundation packages via composer path repositories
• A public MCP gateway (mcp.veritart.me) lets an AI author + publish content
• Per-site design systems enforced by a no-raw-colour gate

Laravel 13 PHP 8.4 Blade SQLite MCP Design systems

3 sites live in production 1 shared codebase 6 locales (seedy)

veritart.me oldbooks.me

A six-stage pipeline that turns one photograph into an explorable 3D world: panorama → camera trajectory → render → stereo reconstruction → gaussian-splat data → 3D Gaussian Splatting, producing multi-million-gaussian point clouds and TSDF meshes. Validated end-to-end on A100 GPUs from a real photo.

• Full 6-stage pipeline runs single-GPU on a shared A100
• Produced a 1.4M-gaussian .ply + TSDF mesh from a real photograph
• Two-phase GPU memory orchestration to fit alongside a running LLM gateway

Python PyTorch Diffusion models 3D Gaussian Splatting CUDA

6-stage pipeline 1.4M+ gaussians A100-validated

The flagship of my professional work: an AI-native B2B workplace for a commerce ecosystem — sourcing, supplier/buyer matching, RFQs, and market intelligence — where trust is the moat. Every answer is sourced, dated, and verifiable, role-adapted (Buyer/Seller/Partner) and bilingual (EN/VI). It is fully sovereign and self-hosted: the agent kernel, knowledge platform, graph-RAG service, Trust Layer, and WebUI are all hand-built — no orchestration framework, no external SaaS on the hot path. Three colocated GGUF models (a 27B chat model plus 4B embedding and reranker) run on a single 48 GB GPU behind one OpenAI-compatible LLM Gateway.

• Built every framework primitive in-house — agent kernel, knowledge platform, graph-RAG, and Trust Layer — with zero orchestration-framework dependencies
• A Trust Layer that makes every answer sourced, dated, and verifiable, so the workplace can drive real commercial decisions — provenance over product
• Runs three colocated GGUF models on a single 48 GB GPU behind one OpenAI-compatible LLM Gateway, with OpenRouter as the only opt-in external fallback
• Organised as seven capability planes × eleven product domains over five deployable processes, on Postgres + pgvector and Redis as the only infrastructure

TypeScript 6 / Python 3.14 SvelteKit 5 + Tailwind 4 Hono + Drizzle PostgreSQL 18 + pgvector Redis llama.cpp (GGUF) + graph-RAG

7 planes × 11 domains 5 processes · 3 models · 1 GPU Sovereign & source-cited

A trade-intelligence system that ingests global bill-of-lading and customs data into a Postgres property-graph, resolves company entities across sources, and derives market signals — supplier risk, under-invoicing detection, alternative-supplier discovery — over a ~270k-shipment / ~60k-company graph. Includes a Company Intelligence Store and source connectors.

• Postgres property-graph over hundreds of thousands of shipments
• Cross-source entity resolution + a Company Intelligence Store
• A market-signals layer (supplier risk, under-invoicing, alt-supplier discovery)

Python PostgreSQL Graph algorithms Entity resolution Web data collection

~270k shipments ~60k companies Multi-source connectors

A self-hosted broker that manages a pool of network egress targets with leasing, health-scoring, and multi-armed-bandit routing, feeding the trade-intelligence crawlers. Hardened over multiple audit rounds for lease hygiene, back-pressure, and security.

• Lease-based target allocation with health-scoring + cooldowns
• Bandit routing picks targets by success × latency
• Multiple security/DoS hardening rounds (SSRF guards, size caps, redaction)

TypeScript/Node PostgreSQL Multi-armed bandits Distributed systems

Lease TTL tuning Bandit-routed Audit-hardened

Reconstructs photorealistic 3D Gaussian-splat scenes from real multi-view site captures, then serves them as map-to-splat dives a host map cross-fades into. Unlike the single-image world-gen pipeline (which hallucinates one world from a single photo), this is faithful to the actual location — a feed-forward HY-WorldMirror path plus a productised COLMAP→gsplat photogrammetry path over the whole photo set, split into a GPU authoring plane and a GPU-free public delivery plane with an embeddable tour viewer.

• Shipped a two-plane system: a GPU reconstruction engine with a durable job queue plus a GPU-free delivery API and embeddable shadow-DOM tour component
• Published the first real site end-to-end and wired the cross-fade map-to-splat dive into a host map platform
• Productised a faithful photogrammetry path (COLMAP SfM → gsplat 3DGS) behind a swappable reconstruction seam

HY-WorldMirror 2.0 COLMAP / gsplat 3DGS FastAPI + SQLite Three.js + Spark PyTorch (A100 / RTX 5090) TypeScript + Vite

4.9M gaussians from 62 stills Photogrammetry PSNR 21.1, ~46 min ~224 GPU-free tests green

Best-of-N candidate generation with in-context parent learning, a multi-persona review panel, bandit model-routing, and a human-gated self-modification scaffold (DGM / ShinkaEvolve-inspired). Runs entirely on local models — sovereignty preserved.

• Diverse best-of-N candidates with early-stop + novelty rejection
• A deterministic-consensus multi-persona review panel
• A human-gated self-modification scaffold (never auto-promotes)

TypeScript Local LLMs Evolutionary algorithms

Local-only models Candidate archive Bandit-routed

The engine Mochi OS edits code through: a reference-fact sidecar that records unresolved sites the edge table cannot, incremental authoritative-diff sync, and isolated parallel-agent commits. Concurrency- and data-integrity-hardened.

• Reference-fact sidecar + scoped-write incremental sync
• Isolated parallel-agent commits (cowork) with index integrity
• A 13-fix concurrency/data-integrity hardening campaign

TypeScript SQLite Graph data structures Git

Incremental sync Index-doctor primitive 1,300+ tests

A FastAPI proxy that fronts llama.cpp, spawning and supervising llama-server subprocesses to serve multiple GGUF-quantised models on a single GPU behind an OpenAI-compatible API (chat, embeddings, rerank). It does VRAM-budgeted LRU load and eviction, tiered model selection, and crash-safe process supervision, with a deep admission layer — tier queueing, per-model circuit breakers, rate limits, quotas, and a context-window guard — plus a built-in dashboard and Prometheus metrics.

• Runs multiple GGUF models on one GPU with VRAM-budgeted LRU eviction, concurrent-load dedup, and an OpenAI-compatible chat/embeddings/rerank surface
• Built a layered admission stack — tier queueing, circuit breakers, rate limits, quotas, and a context-window guard that rejects over-n_ctx prompts before they crash llama.cpp
• Hardened process supervision and graceful shutdown with cross-platform orphan-prevention (JobObject / pdeathsig / watchdog)

Python 3.14 / FastAPI llama.cpp (GGUF) Preact + Vite Prometheus + OpenTelemetry SQLite CUDA / NVIDIA GPU

~55k lines of Python 467 test files, 40 ADRs 13 admission metrics

An AI-powered office simulation: you play CEO, hiring and managing a team of LLM agents that autonomously collaborate, conflict over decisions, and deliver real runnable artifacts (HTML/JS games, stories, generative art, research). Agents form vector-embedded memories, distil rules, and build relationships under a full economy of salaries, budgets, goals, and routines — running 100% locally via llama.cpp on an RTX 5090 with zero external API calls.

• Built a self-running agent engine (perceive → think → act) with vector-embedded memory, distilled rules, and emergent LLM-driven conflict resolution
• Shipped a full agency-operations layer: hiring pipeline, salary/budget economy, CEO approvals, and scheduled + emergent routines
• Wired the game into Mochi OS as a WSL-native systemd satellite with native HUD monitoring tabs

TypeScript Bun + Hono React 19 + PixiJS 8 PostgreSQL + pgvector Drizzle ORM llama.cpp (local)

~38.8k lines across 229 files 28 Postgres tables, ~60 endpoints 32 project types, 100% local

A website-archival tool that drives a stealth Firefox browser to capture modern SPAs into fully offline-functional archives, with parallel asset downloading, SHA-256 verification, pause/resume, and incremental updates. A FastAPI backend with a React dashboard streams live capture progress over WebSocket, and a multi-engine resilience layer grades capture quality (HTML + screenshot-entropy) and auto-recovers failed captures. Runs as a manifest-driven Mochi OS satellite with systemd health probes.

• Captures bot-protected SPAs (React/Vue/Angular) into pixel-faithful offline archives with auto-scroll lazy-loading and computed-style extraction
• Built a multi-engine resilience layer with deterministic per-domain fingerprints, telemetry-ranked engine selection, and a quality oracle that fails visually-blank captures
• Wired as a zero-TypeScript Mochi OS satellite, discoverable and controllable from the OS dashboard

Python Camoufox / Playwright FastAPI SQLite React 19 Tailwind CSS

1,056 passing tests 167 Python modules CLI + web UI

A single-user, fully local pixel-art sprite generator built on the FLUX.2 diffusion model with native GGUF inference, so generation runs entirely on-device with no cloud calls. It owns the whole prompt-to-engine pipeline — text prompt to spritesheet through a seven-step flow (downscale, dither, background removal, grid split, animation) — exporting game-ready assets for Unity, Godot, Aseprite, and Phaser.

• Built a native GGUF inference path (no llama.cpp dependency) running a quantised text encoder dequantised one layer at a time to fit VRAM
• Shipped a server-authoritative sprite-sheet platform with a job state machine, SSE streaming, cancel/retry/finalize, and 8 engine-native export formats
• Implemented a custom sampling engine with 64 samplers and 18 schedules plus a Sampler Lab for XY-matrix comparison

Python PyTorch (CUDA) Litestar + Granian FLUX.2 diffusion + GGUF DuckDB Vanilla JS (Lit)

64 samplers × 18 schedules 13 pose templates, 8 exports 7-step sprite pipeline

A satellite that turns a single product photograph into a game- and web-ready PBR-textured .glb, built on the TRELLIS.2 structured-3D-latent model with native GGUF inference. A GPU-free control plane (a FastAPI + SSE job queue, SQLite jobs, and a <model-viewer> gallery) runs the GPU engine as an isolated child process for crash isolation, taking the image through sparse-structure generation, structured-latent decode, mesh extraction, quadric decimation, and a 2048² PBR texture bake. Brought up and verified end-to-end on an RTX 5090 (Blackwell / sm_120).

• Built a GPU-free control plane that drives the GPU engine as an isolated child process — durable SQLite jobs, SSE progress, and a <model-viewer> gallery
• Ran TRELLIS.2 with native GGUF inference (Q8_0 + 1536 cascade) to bake 2048² PBR-textured .glb meshes, decimated to a per-preset face budget
• Brought the pipeline up on Blackwell: patched Triton sm_120 codegen, prebuilt cu128 wheels, and tamed DC-remesh over-tessellation in mesh finishing

Python PyTorch (CUDA / cu128) TRELLIS.2 + GGUF FastAPI + SSE SQLite Triton / sm_120

2048² PBR textures ~500K-face glb RTX 5090-verified

The project-management substrate that lets a rotating fleet of AI coding sessions build a large codebase without the work rotting, drifting, or corrupting itself — the repo keeps its memory, truth, and decisions while the agents come and go. A deterministic, local SQLite-backed graph joins the code corpus and the method corpus through a "governs" bridge (tree-sitter parsing + Louvain community detection) and exposes it to the coding agent over MCP, driven by a small CLI to index, sync, and serve. A manifest-and-excise design inventories every piece of the PM system as one navigable, cleanly removable layer — no daemon, no cloud, no model on the indexing path.

• Built a deterministic local code-×-method knowledge graph (tree-sitter + SQLite + Louvain communities) joined by a "governs" bridge and served to the coding agent over MCP
• Consolidated a PM system once scattered across ~17 locations into one manifest-inventoried, cleanly excisable control layer
• A self-tracking loop — a mechanism registry plus a method-issues inbox — makes the methodology audit its own coverage

TypeScript better-sqlite3 tree-sitter graphology (Louvain) MCP

Code × method graph MCP-served, model-free ~17 fragments → 1 layer

A Vietnamese-language content-moderation system for a B2B marketplace, detecting prohibited and NSFW text to meet Decree 147/2024 and E-Commerce Law 2025 compliance. A trained mmBERT-base neural classifier reaches 0.960 P0-F1 on held-out test data, fed by a separate hardened, resumable crawler that runs every sample through fail-closed CSAM/PII drop-filters with no raw-content retention.

• Trained an mmBERT-base classifier hitting 0.960 P0-F1 (96.4% recall) and 0.846 action macro-F1 on a held-out test set
• Built a crash-safe, proxy-aware crawler with an atomic SQLite ledger, robots-awareness, and a 0.5 RPS cap, live-verified end-to-end
• Engineered a fail-closed content-safety pipeline: CSAM/PII drop-filters, HMAC author hashing, and derived-only storage

PyTorch mmBERT / Transformers LoRA (PEFT) Camoufox + httpx SQLite (WAL ledger) Flask

0.960 P0-F1, 0.846 macro-F1 ~490K-row unified VN corpus 0.5 RPS, zero raw retention

A resilient forum crawler with built-in safety/abuse monitoring and a live observability dashboard (frontier, ETA, throughput sparklines, event feed). Hardened against convergence bugs with a durable, fail-open monitoring UI.

• Durable, fail-open observability dashboard (start/stop/resume)
• Built-in safety/abuse monitoring
• Convergence + total-pages hardening (0 stranded / 0 false-complete)

Python Flask SQLite

Live monitoring UI Safety monitoring 150+ tests