Computer
Science

I learned Kubernetes and the Nautilus cluster from scratch just to get access to CARLA and run the lab's experiments — GPU-scheduled jobs, PVC-backed storage, pod specs written by hand. Most of the early work was infrastructure rather than research. Currently I'm studying the RL methods themselves, mostly SAC and DDPG, and learning to develop my own! The part I find interesting isn't implementing them but rather understanding why one algorithm or policy gets chosen over another for a given problem.

I helped build and complete four goal-tracking components for Compass, the lab's goal-setting and reflection app — owning the data and event layer, which meant keeping state consistent from a user's action all the way through NgRx Signal Store to Firestore. The lab is also studying how to use AI agents properly in development rather than just faster: we work inside Google Antigravity with a shared set of in-house agent skills, where the Angular feature pipeline splits every stage into a plan skill and an implement skill, and the implement stage refuses to run until a plan is finalized. Watching a codebase enforce that separation changed how I think about my own workflow.

I wanted to know exactly what a framework does when it runs a forward pass instead of trusting it, so I wrote the matrix multiply, ReLU, and argmax myself and built a binary weight format to carry a trained PyTorch model into C++. The bar wasn't whether it ran — it was whether it was provably the same model. Along the way I found my own test suite was passing against a stale baseline, which was a more useful lesson than the engine itself.

I founded this and led a five-person team, which meant most of my time went to defining interface contracts — chunk format, search API, response schema — so five people could build in parallel instead of blocking on each other. I own the retrieval engine itself: exact cosine-similarity k-NN, written as a correctness baseline before any optimization. Partial-sort selection and SIMD are the obvious next steps and I deliberately didn't take them yet.

Built at the NVIDIA × ASUS hackathon and finished on my own after the team moved on. The interesting part isn't the tuning — it's the safety model. An LLM proposes changes, but my code validates every one against legal ranges and overwrites state fields from live telemetry, so the model can't misreport what it's changing. Every mutation is journaled with its inverse. If the LLM is offline, a deterministic rule engine takes over.

The constraint that made this worth doing was writing the concurrency myself — a bounded producer-consumer queue and per-URI reader-writer locks over raw syscalls, no library concurrency. Getting honest numbers took two passes: my first benchmark silently linked the reference library instead of my code, so I verified symbol provenance with nm and reran everything.