Seattle · Field notes, 2026
Software Engineer · AI Infrastructure
I build the infrastructure that lets models act in production—multi-tenant LLM serving, model guardrails, staged rollouts, and bounded agent systems.
I / The system registry
Agents should be inspectable, bounded, and worth interrupting a human for. This atlas is the public edge of the systems I build and the patterns I am testing.
A shared ambient digital pet for two humans, live with real users. paws is the private household product; woolroom is its MIT-licensed, self-hostable engine for room state, mood, memory, realtime sync, and bounded responses.
Watch paws ↗Open-source engine →A compact DSL and single-node runtime for bounded, traceable LLM workflows — grammar → frozen-dataclass AST → deterministic runtime with durable runs, contracts, and replay. Published on PyPI.
Install from PyPI ↗A personal investment platform: a ~70-name universe scored on 11 LLM-graded dimensions, with kill-trigger monitors and daily Telegram alerts.
Design notes →The product layer between my agent fleet and my attention — one ranked decision surface, deterministic rendering, and a constrained action gate. Private by design.
Product walkthrough →A persona-routed stdio MCP server — a semantic router maps the task or todos to persona → skills → tools, auto-loading team resource packages; team behavior lives in its own JSON config. Adopted across teams without forking shared infrastructure.
Pattern note →A personal fleet of AI agents on Telegram — runtime-agnostic by design: Claude Code, Hermes, Codex, and Kimi are interchangeable labor. Ming owns the ideas and final review; the fleet assists production and maintenance.
How it's run →htop for AI agents — liveness, CPU/RAM/GPU usage, and a kill switch for headless agents: OpenClaw, Hermes, Ollama, vLLM, Claude Code.
Install from PyPI ↗II / Selected work
At Amazon, I own multi-tenant LLM serving, model guardrails, and staged-rollout infrastructure for real-time GenAI translation across regions.
Tenant onboarding, request routing, per-tenant cost tracking, eval-gated rollout, safety controls, and a kill switch—the infrastructure around inference is the product.
III / Trajectory
Signal, structure, and uncertainty—the visual language of this atlas begins in seismic imaging.
Signal-processing and 3D seismic-imaging pipelines over large subsurface datasets.
Distributed backend systems, chat infrastructure, and production GenAI translation on AWS.
Open-source runtimes, personal agent infrastructure, and field notes on keeping AI bounded and observable.
Software engineer building production AI infrastructure for large-scale, customer-facing systems. I own multi-tenant LLM serving, model guardrails, and rollout infrastructure for real-time GenAI translation at Amazon, serving many languages across multiple regions. ~8 years building distributed backend systems across AWS, production operations, and large-scale data processing.
Customer Service · GenAI Translation · Chat Infrastructure
AI Platform & Multi-Tenant LLM Serving
Inference Reliability, Safety & Cost Optimization
Distributed Platform Engineering & Migrations
Technical Communication
U.S. Seismic Imaging Department · 3D subsurface imaging workflows for major Oil & Gas clients
AI / LLM Systems
Distributed Systems & Cloud
Languages
Rice University — M.S. in Geophysics
Jul 2016 — May 2018 · Houston, TX
Yangtze University — B.Eng.
Aug 2012 — Jun 2016 · Hubei, China
IV / Writing
What failed, which boundary held, and what transfers beyond one codebase. Production AI, reliable agents, and human control.
My eval gate scored a byte-identical file 0.167 better than itself and approved it. The number I trusted for months only recorded my own approvals.
Runtime-agnostic agents on Telegram — Claude Code, Hermes, Codex, Kimi as interchangeable labor — with a shared knowledge memory, cron-driven loops, and a rule that everything the fleet ships gets verified before it's claimed.
Coherence in an ambient pet comes from explicit state, bounded choices, and reliable fallbacks — not from generating every line at runtime. The pattern: a two-axis mood lattice, an authored phrasebook with a strict fallback order, event-indexed selection, a conservative intent classifier, and a validator-gated LLM lane that can only ever audition.
Local Git hooks catch honest mistakes, but an agent with shell access can bypass them; mandatory review requires isolation or a receiver-side gate.
A product walkthrough of the personal operations layer I use to turn agent output into one ranked, privacy-aware decision surface, with its frontend and backend boundaries.
Human approval is a capacity-constrained service, so I cap my remote AI decision docket at five and drain the backlog in focused review sessions.
Ten times in eighteen days I pasted one AI agent's output into another agent's window. There is no wire between them. The wire is me.
Generation instructions are not enforcement. I run independent persona and house-rules reviews over every fresh draft, then file findings as blocking comments before human review.
One Telegram thread logs meals, workouts, weight, guitar, trades, and practice reps through verb prefixes, deterministic state, and a strict separation between capture and dispatch.
A personal investment platform that scores a ~70-name universe on 11 LLM-graded dimensions, blends probability-weighted scenarios, and treats the kill trigger as a first-class object — the design notes.
A semantic router that reads the task or todo list, routes to persona → skills → tools, and auto-loads team resource packages — one stdio binary that works with any CLI or agentic tooling, with team behavior living in its own JSON config.
Three frameworks shipped the same control-plane idea in a month — external process control, capability negotiation, env-var hygiene. What converged, why my tmux fleet already has the failure modes it solves priced in, and the two concrete triggers that would make me adopt it.
As AI makes infinite engagement easier, the better product bet may be software that respects absence.
Most multi-step LLM code is prompt strings glued together in a Python function. ThreadLang makes the workflow the program — a grammar, an AST, and a structured trace you can run without a network call.