Hank Huang · solo builder · proof of work

I build systems with AI that run themselves — and I've been doing it since high school, before "AI makes it possible to do anything" was a slogan.

I engineer autonomous multi-agent infrastructure and use it to build real things: quantitative trading systems, large-scale node infrastructure, and a token airdrop earned on-chain through real usage — not a pitch deck.

signal Earned roughly 0.9% of Lighter's entire inaugural airdrop through real on-platform trading, and operate a self-healing AI agent fleet running 24/7 that I engineered end to end.

What I've built

ordered by weight · dry-run vs live tagged
01

Hermes — a self-healing AI agent fleet

A 24/7 autonomous multi-agent operating system running on 5 machines, engineered to detect its own failures and recover with no human in the loop.

roleSolo. I deployed the runtime and built the entire self-healing, memory, orchestration, and fault-tolerance layer on top of it. I did not train a model from scratch — I engineered the system that makes agents survive and keep working.

hardest partKeeping autonomous agents alive without a human watching. A process can be "alive" but brain-dead — event loop frozen, OAuth silently expired, or an orphan process stealing the message queue. I built a 7-layer watchdog that distinguishes "process running" from "actually reachable end-to-end," down to verifying outbound API reachability.

40+ production incidents diagnosed and hardened into automated recovery (documented as error patterns EP-39 through EP-82). One class of silent failure — an event loop frozen for 3.3 hours — was turned into ~100-second automatic self-recovery via an independent liveness watchdog that dumps a full-thread traceback and restarts.  LIVE · production, running now
02

Quant trading systems, built on the fleet

I use my self-built Hermes AI agent fleet to design and build quantitative trading systems, including a cross-exchange latency-arbitrage engine written in Go.

roleSolo. Designed the strategy, reverse-engineered the signal from publicly observable market fill data, and wrote the Go execution engine (WebSocket, cross-venue).

hardest partProving an edge is real without lying to myself. The latency engine runs as a dry-run to validate the edge before risking anything; the strategy came from reading publicly observable fill data, not from a textbook.

Latency-arb engine: 79% win rate, +1.83 bps per trade, 813 trades DRY-RUN. The edge comes from zero-fee pairs and rebate tiers, not raw spread. No capital figures, P&L, or returns published — qualitative by design.
03

Earned ~0.9% of Lighter's entire inaugural airdrop — on-chain, through real usage

Earned roughly 0.9% of Lighter's entire inaugural airdrop through measured on-platform trading — earned, not self-asserted, and not a résumé line.

roleSolo participant. No claim, no vesting — the initial airdrop was distributed directly to qualifying wallets based on real activity.

hardest partThis one is the opposite of the others — the hard part is that it can't be gamed or narrated. It's on-chain. Either the wallet earned the tokens or it didn't.

A ~0.9% share of the entire inaugural airdrop — no claim, no vesting, distributed on-chain to qualifying wallets. No USD figure or raw token count shown here by design; the allocation is on-chain verifiable.  earned · on-chain verifiable
04

AI-first since high school — solo-built large-scale node infrastructure

I've been using AI to build — and to teach myself — since high school. When Nillion launched, I taught myself Docker from scratch with AI (I'd never touched it before) and stood up a 5,000-node verifier fleet solo, running on a self-run fleet of ~200 Macs I operated myself.

roleSolo. Learned containerization from zero using AI, then wrote and operated the entire node fleet single-handed — the Nillion verifier fleet scaled past 5,000 nodes.

hardest partRunning thousands of containerized nodes reliably when I'd never used Docker in my life — AI was how I learned it and then kept the fleet alive at scale. In the same period I contributed compute from the same ~200-Mac fleet to decentralized compute networks (io.net).

Solo-operated a Nillion verifier fleet that scaled past 5,000 nodes — Docker self-taught with AI, from zero — running on a self-run ~200-Mac fleet that also contributed compute to decentralized compute networks (io.net).
05

Founded a company at 19 — a real legal entity, dual TW / HK

I incorporated a real company — dual Taiwan + Hong Kong entities — as the legal vehicle for this work.

roleSolo founder. Set up both entities and the operating stack: domain, corporate email, GitHub org, daily automation.

hardest partDoing the boring-but-real part properly — dual-jurisdiction incorporation, banking, accounting — instead of staying a hobbyist.

TW entity 墨克數位科技股份有限公司 (MKL Digital Technology Co., Ltd.), company reg. 62201452, approved 2026-04-23; HK entity Merkle Digital Limited.  verifiable · TW company registry
06

Web3 automation at scale — isolated infrastructure, large fleets

Large-scale, isolated node and orchestration infrastructure across multiple Web3 protocols — built for reliability and scale.

roleSolo. Designed the isolation architecture, the state machines, and the batch orchestration.

hardest partMaking hundreds of isolated environments behave deterministically — the failure modes multiply with scale, and one bad assumption cascades across the whole fleet.

Nillion verifier fleet 5,000+ nodes, plus an 8-module cross-protocol automation framework spanning multiple DeFi protocols (Eclipse) — all on isolated, independently-orchestrated infrastructure.  historical operations

Origin

How I got here

I went to 師大附中, one of Taiwan's top high schools. I taught myself most of the coursework using AI — not as a study aid on the side, but as the way I learned. I took a gap year, and I didn't finish with a diploma: I was two credits short and decided that re-taking classes to hang on to a piece of paper was a waste of time. So I have a certificate of studies, not a graduation certificate.

That gap year is when the real building started. I was already in crypto and trading, and I was building large-scale automation solo. AI was how I taught myself everything I didn't already know — when Nillion launched I picked up Docker from scratch with it and stood up a 5,000-node verifier fleet on a self-run fleet of ~200 Macs, which also contributed compute to decentralized compute networks (io.net).

Then I got into NTHU (National Tsing Hua University) through the 拾穗 program — an admissions track that doesn't look at standardized test scores; it looks at your work and interviews you.

The work outweighs the credential. I'm the living proof of it.

Everything since — the agent fleet, the quant systems, the company — is the same person doing the same thing I was doing in high school: using AI to build whatever I want, and going all-in on it.

The Academy

What I want to do at the Academy

My frame is AI-first, crypto-as-application. AI-native building is who I am; crypto is where I prove that AI lets one person build anything. That's the exact bet a16z is making, and it's the bet I've been living since high school.

The two people I most want to build alongside are Brian Armstrong at Coinbase and Jensen Huang at NVIDIA. Armstrong because crypto-as-application is the thesis I've been executing, not theorizing. Jensen and the $50k of NVIDIA compute because my whole edge is turning raw compute into autonomous systems that build and run themselves — give me more of it and I'll show you what one builder can do with it.

And I'm all-in. If I'm accepted, I leave NTHU and commit to this full-time. No hedging, no deferring in case it doesn't work out. I've already bet my path on work over credentials once — this is me doing it again, on purpose.