MS Software Engineering @ San Jose State University

I build AI infrastructure and the systems underneath it. That means inference servers with continuous batching and paged KV caches, agents that know when their retrieved context is weak and go looking again, GPU cluster schedulers that isolate every job at the cgroup level — and, when the problem calls for it, a B-tree written down to the 4 KiB page or a CUDA kernel timed against a golden reference.

The through-line in my work is measurement over assertion: four serving backends behind one interface so the benchmark is honest, five checkpoint strategies compared across five model families, three attention kernels profiled in Nsight. I work across Python, C++, Rust, Go, and Java, and I ship full-stack products too — but the layer I care about is the one that decides whether the thing above it is fast, correct, and still standing at 3 a.m.

Languages

JVM Frameworks

Python Frameworks & Ecosystem

Web & Mobile

Agents, RAG & LLM Applications

AI Infrastructure & Serving

ML & Training

Systems & Low-Level

Cloud, Data & Platform

Six projects that cover the range I work across — inference infrastructure, agentic AI, and systems built from the page up.

A fine-tuned Mistral 7B (QLoRA) behind vLLM, NVIDIA Triton, Ray Serve, and TensorRT-LLM — one OpenAI-compatible API, four engines, one apples-to-apples benchmark.

• Continuous batching — the batch is rebuilt every decode step, so a finished sequence frees its slot immediately instead of waiting for the whole batch
• Paged KV cache with prefix reuse — fixed-size, reference-counted KV blocks shared across requests, so a repeated system prompt is prefilled once and reused
• Every backend sits behind one Backend protocol, so the API layer, load generator, and metrics are identical across runs and only the engine varies — tokens/s, req/s, TTFT, inter-token latency, GPU utilization, and $/1M tokens are actually comparable
• OpenAI-exact SSE chunk framing (existing clients work unchanged); fp8 / int4-AWQ TensorRT-LLM engine export; the scheduler and block manager are pure Python and CPU-testable

LangGraph agent over a documentation corpus that routes, retrieves, self-reflects, and re-queries when its context looks weak — then answers with inline citations.

• Agent graph: router → retrieve → reflect → (rewrite → retrieve …) → generate, routing each question as simple_lookup, multi_hop, or metadata_scoped
• MCP tools — search_docs, filter_by_metadata, get_page exposed as LangChain tools the agent calls directly
• Ingestion pipeline: BFS crawler → boilerplate/language/near-duplicate filters → recursive chunking with per-source chunk_index for citation lookup → Pinecone with filterable metadata
• MMR retrieval with a scored variant driving the confidence check; LangFuse traces and scores every run on retrieval recall, faithfulness, and answer relevance

Ingests kernel/driver diagnostics — NVIDIA Xid, EDAC/ECC, MCE, NVMe, NIC — from scale-out clusters and triages each incident with a Claude agent over MCP.

• Deterministic detection first, LLM last — cheap parsing and rule/rate detection runs on every line; the expensive agent runs once per incident, after a fleet-wide fault has been collapsed to a single cluster
• Normalized failure signatures: volatile tokens (hex addresses, counters, PCI IDs, UUIDs) are masked, so the same Xid across hundreds of hosts groups into one incident
• Elasticsearch index templates + ILM, idempotent bulk indexing, incident upsert-by-fingerprint, more-like-this similar-incident lookup; severity-gated deduplicated routing to Slack/PagerDuty

Massively parallel CI runner for HPC and ML workloads, dispatching onto an on-prem + AWS A100/H100 Kubernetes cluster provisioned with Terraform.

• Rust dispatcher (tonic gRPC): priority-aware scheduler, Pod factory, Kubernetes watch loop, Prometheus exporter — paired with a Python/FastAPI orchestrator for DAG validation and matrix expansion
• Per-job isolation inside the pod: the Rust ci-worker unshares Linux namespaces, applies cgroup v2 caps, drops capabilities, then execs the user command
• Terraform provisions the AWS half — EKS control plane, spot CPU node group, on-demand A100 GPU node group, and the NVIDIA GPU operator; on-prem joined via a second provider alias

A time-series database written from scratch in Go — storage engine, transaction layer, query engine, and cluster layer, no external database underneath.

• LSM-tree storage with a write-ahead log for durable, high-throughput ingest
• MVCC snapshot isolation so long-running reads never block writers
• Custom query engine — parser → planner → executor rather than an embedded SQL library
• Time-based sharding across the cluster layer for horizontal scale-out

C++17 storage engine down to the 4 KiB page: buffer pool, eviction policy, and page latches written by hand.

• Page-aligned buffer pool with LRU eviction over a fixed frame count, backed by a disk manager doing pread/pwrite of 4096-byte pages (page 0 is the header holding the root ID)
• Per-page POSIX pthread_rwlock for concurrent readers, with single-writer serialization at the tree level via std::shared_mutex
• O(log n) point lookups and ordered range scans over fixed-width keys

• 🧊 Arctic Code Vault Contributor — Code preserved in the GitHub Arctic Code Vault
• 📄 Published Researcher — Research on AI-based genetic disorder detection published in IJFGCN

🎯 Focusing on AI infrastructure, agentic systems, and the layers underneath