Runtime agent infrastructure for the Tachyon SQA process. The control plane drafts a test plan, pauses for QA, runs jobs asynchronously, and writes results back — then evolves the harness itself under human audit, instead of silently accumulating prompt residue.

• Designed the runtime agent infra for Tachyon SQA: a workspace harness plus an execution layer that owns test-plan state across draft, approval, job run, and result writeback.
• Built a daily regression tracking harness that materializes review sections from regression inputs, reads QA gates from Confluence, and drives follow-up work through durable runtime state.
• Encoded the test-plan lifecycle as a durable workflow: draft test plan → capture job execution details → wait for QA approval → agent executes jobs asynchronously → update job results and inspection results when each job finishes.
• Built a human-governed self-evolution loop: while a human uses the harness, the agent extracts reusable memory from the session into a temporary shared-memory layer; humans periodically audit and edit that layer; after approval, the agent persists the changes into the harness internals.
• Used Temporal-style durable-execution primitives: deterministic workflow orchestration, activities for side-effecting adapters, signals for QA approval, task-queue job claiming, retries/idempotent writes, event-history replay, and local sandbox recovery.

A Kubernetes-native control plane for isolated, stateful agent workspaces: provision from runtime templates, suspend and resume, then garbage-collect on TTL.

• Designed the sandbox control plane with CRDs and controllers, warm-pool provisioning, and lifecycle reconciliation.
• Hardened untrusted-code execution with gVisor/Kata RuntimeClasses, namespace-scoped RBAC, default-deny NetworkPolicies, and resource quotas.
• Standardized reproducible agent environments with immutable OCI images, short-lived secret projection, PVC-backed workspaces, and OpenTelemetry traces.

A compact implementation of the control-plane ideas behind high-throughput LLM inference. It keeps compute simulated on purpose so memory management and scheduling behavior are easy to inspect, test, and benchmark on a laptop.

• Implemented paged KV-cache allocation, block reuse, preemption, prefix caching, and continuous batching.
• Added deterministic workload benchmarks and unit tests for scheduler, cache, engine, and prefix behavior.
• Used the project as a concrete way to study vLLM-style serving internals instead of only reading papers.

A pipeline for turning long, unstructured clinical records into standardized structured outputs under privacy and schema constraints.

• Decomposed monolithic extraction into smaller schema-specific subtasks to reduce context waste and improve debuggability.
• Built domain datasets and fine-tuning experiments with Qwen, QLoRA, self-consistency checks, and schema validation.
• Optimized long-context inference with vLLM/PagedAttention and quantization to improve throughput and memory use.

A distributed course-management system for normalizing student score data across Gradescope, PrairieLearn, iClicker, and internal course workflows.

• Migrated fragmented course data into a normalized PostgreSQL-backed service with role-aware access control.
• Added Redis-backed caching and pre-rendering paths to reduce repeated query load.
• Maintained production-facing course tooling used by students and staff.

A six-month path for learning LLM serving systems through vLLM: request lifecycle, PagedAttention, scheduler design, kernels, mini-vLLM, and frontier serving systems.

• Connects operating systems concepts to real LLM serving internals instead of teaching them as isolated theory.
• Includes diagrams, source-reading anchors, self-checks, paper reading order, and a mini-vLLM project arc.
• Adds a frontier serving chapter on prefill/decode disaggregation, KV transfer, prefix-aware routing, speculative decoding, and FP8/KV quantization.

A learning site that follows one cloud request down through CPU scheduling, virtual memory, I/O, virtualization, containers, networking, Kubernetes, serverless, and GPU inference.

• Organizes 14 chapters around the path from a single machine to cloud-scale infrastructure.
• Connects CS162-style operating systems concepts to virtual machines, containers, orchestration, and AI serving.
• Published as a static learning artifact under the site’s Learning section.

A local-first illustrated textbook that walks from SQL and relational algebra down to buffer pools, B+ trees, query execution, locking, recovery, distributed commit, and modern data systems.

• Organizes 12 database systems chapters around diagrams, invariants, and I/O cost intuition.
• Includes a B+ tree sandbox plus static visual chapters for sorting, joins, optimization, recovery, and distributed transactions.
• Built as a personal learning artifact rather than a copy of course notes.