Sanjai Murugan
sanjai_murugan
AI Systems Engineer
Initializing neural pathways...
⌨
🏠 Home ⌘+1
👤 About Me ⌘+2
🚀 Engineering Projects ⌘+3
🔬 Research ⌘+4
🛤️ My Journey ⌘+6
⚙️ Engineering Toolkit ⌘+7
📜 Credentials ⌘+8
📡 Get in Touch ⌘+9
Sanjai Murugan
Sanjai Murugan
B.Tech CSE ’28, VIT Chennai · open to AI/ML internships

M. Sanjai — AI systems engineer. Engineering AI Systems

I’m Sanjai — I research how far you can compress a Mixture-of-Experts model before it stops behaving like itself, and I build the products that run on the other side of that question. Currently on an H100 at VIT Chennai, and shipping AI software that people use.

|
LoRA Fine-Tuning
RAG Systems
Local Inference
Agentic Workflows
Multi-Agent Arch.
sancodes@local-ai: ~
❯ cat about_me.md
— AI systems engineer from India
— Building production-grade local LLM systems
— Researching efficient inference & agent architectures
❯ ls projects/
— multi-agent-coding-system
— rag-portfolio-assistant
— vision-lowlight-detection
❯ echo "Ready to build"
█ deployment ready_
0
Years Building
0
AI Projects
0
Certifications
Scroll to explore

Building AI at the Systems Level

Sanjai Murugan
Name Sanjai Murugan
Role AI Systems Engineer
Education B.Tech CSE, VIT Chennai (2024–28)
Focus Local LLMs & Agentic Systems
Location India

I’m a second-year B.Tech CSE undergraduate at VIT Chennai who works on AI systems — currently selective int8 quantization for Mixture-of-Experts models, run on the university’s H100 research server. My interest runs from transformer internals and expert routing through to deployment pipelines and inference optimization.

I specialize in local-first AI architectures, multi-agent orchestration, Agentic AI, and RAG systems. I don't just use AI tools—I build the infrastructure that makes them work efficiently on consumer hardware.

Currently exploring sparse expert routing, KV cache optimization, and edge deployment strategies for large language models.

AI Systems Local LLMs Multi-Agent RAG Lora/QLora Apple Silicon Python TensorFlow PyTorch

Systems I've Built

Each project reflects deep systems-level thinking — spanning agent orchestration, inference optimization, retrieval systems, and computer vision.

🔍 Research Project

Bike Rental RAG Assistant

2025

"AI-powered retrieval assistant for intelligent bike rental support and real-time customer interaction."

A Retrieval-Augmented Generation (RAG) based AI assistant developed for a bike rental platform to handle real-time customer queries and provide accurate responses regarding pricing, rental policies, bike availability, booking procedures, and platform features. The system leverages semantic search and vector embeddings to retrieve relevant information from a knowledge base, enabling context-aware and reliable conversations.

  • Real-time query handling for bike rental platform users
  • Semantic document retrieval using vector databases and embeddings
  • Context-aware multi-turn conversational support
  • Efficient knowledge retrieval with optimized chunking techniques
  • Accurate response generation with retrieval-based context injection
LangChainChromaDBOpenAI EmbeddingsFastAPI
🧪 Experiment

TinyOllama LoRA Fine-Tuning Research

2025

"Parameter-efficient specialization experiments on lightweight local LLMs."

Explored LoRA-based fine-tuning workflows using MLX and lightweight language models to understand efficient specialization techniques and local deployment optimization. Documented rank exploration, quantization strategies, and quality trade-offs.

  • Low-parameter adaptation with LoRA rank exploration (r=4 to r=32)
  • Inference efficiency benchmarking before and after fine-tuning
  • Specialization behavior analysis across model sizes
  • Local deployment feasibility studies on consumer hardware
~0.1% of total parameters trained
4× reduced compute vs full FT
Optimized experimentation pipeline

Key Findings

  • LoRA rank r=8 achieved 85% of full fine-tuning quality with 97% fewer trainable parameters.
  • MLX on Apple Silicon proved competitive with CUDA for small-scale LoRA experiments.
  • Quantization-aware fine-tuning (QLoRA) enabled effective training on 6GB VRAM hardware.
📷 Applied AI / Computer Vision

Low-Light Animal Detection Pipeline

2025

"Computer vision system for wildlife detection in difficult lighting environments."

Developed a computer vision pipeline capable of detecting wildlife in low-visibility scenarios using image enhancement and object detection techniques. Explored preprocessing optimization for real-time performance under challenging environmental conditions.

  • Low-light image enhancement as preprocessing stage
  • Detection reliability scoring under varying conditions
  • Preprocessing optimization for real-time performance
  • Evaluation against real-world environmental conditions
💼 Product · Founder

HireFaster — AI Resume Evaluation SaaS

Jan 2026 – present

"A production hiring platform, architected and shipped end to end."

A full-stack SaaS rather than a prototype: Next.js front end, FastAPI services, MongoDB Atlas, Docker on AWS and Vercel. The engineering interest is in the failure modes — three concurrent processing pipelines behind a fault-tolerant orchestration layer with automatic provider fallback, so a single model provider going down degrades the service instead of stopping it.

  • Real-time SSE streaming, JWT auth, rate limiting and input sanitization
  • Fault-tolerant orchestration across 3 pipelines with automatic provider failover
  • Containerized deploy on AWS (EC2, App Runner) and Vercel
  • Security hardening: validation, auth middleware, abuse prevention
Next.jsFastAPIMongoDBDockerAWS
⚙️ Open Source · EDA

GLI-Flow — RTL-to-GDS Automation

Jul 2026 – present

"Verilog to GDSII in one command, with an LLM that explains why a run failed."

A full-stack platform over the open-source ASIC flow: a React/Vite dashboard of 35+ views on a FastAPI REST backend, with a pluggable SQLite/PostgreSQL data layer, Docker containerization and an 82-file CI suite. The part I care about most is the investigation engine — automated root-cause analysis of failed runs, so a broken flow returns a diagnosis instead of a log dump.

  • Single-command Verilog → GDSII pipeline over OpenROAD
  • React/Vite dashboard, 35+ views, FastAPI REST backend
  • LLM-assisted root-cause analysis for failed runs
  • Primary author: 15 of 17 commits · Apache-2.0
ReactViteFastAPIPostgreSQLDocker
📸 Computer Vision

DriveCLIP — Multi-Task Driving Perception

Mar 2026 – present

"Five sequential vision tasks collapsed into one forward pass."

A consolidated multi-task architecture extending CLIP ViT-B/32 with a feature pyramid and cross-attention, so five tasks that previously ran in sequence share a single optimized pass. The gain is architectural rather than hardware: 2.3× throughput at 20.4 FPS.

  • CLIP ViT-B/32 backbone with FPN and cross-attention heads
  • 5 sequential tasks merged into one forward pass
  • 2.3× throughput improvement, 20.4 FPS
PyTorchVision TransformersCLIPFPN

Pushing Systems Beyond the Tutorial

Exploring experimental AI system architectures, inference optimization techniques, and efficient model specialization beyond standard application development.

Featured Study
Independent research · VIT Chennai · NVIDIA H100 80GB (DST-FIST research server)
🐙 Code & pipelines

Selective Int8 Quantization for Mixture-of-Experts LLMs

Mixture-of-Experts Post-Training Quantization Fidelity Evaluation Expert Routing

MoE models activate few parameters per token but must keep every expert in memory, and standard post-training quantization treats all layers as equally important. I built a pipeline that scores each layer’s quantization tolerance with five signals — KL divergence, top-1 disagreement, choice-flip rate, log-likelihood MAD and perplexity delta — then quantizes only the tolerant safe band. On Qwen3-30B-A3B that band is 21 of 48 layers; on Qwen3.5-35B-A3B it is 10 of 40.

Multiple-choice benchmarks could not tell the two apart. Selective and full int8 both score 91.5% on GSM8K, and perplexity differs in the fourth decimal. So I measured something else: fidelity to the unquantized model as ground truth — KL divergence over 19,200 teacher-forced token positions, expert-routing overlap, and tokens-until-divergence in free-running generation.

Divergence from the bf16 model, Qwen3-30B-A3B. Lower is better; the axis starts at zero. GSM8K is not plotted — both configs score 91.5%, so the bars would be zero.
Top-1 disagreement 2.29 2.89
Expert-slot mismatch 2.22 5.66
Top-k set mismatch 5.37 13.29
Mean KL (×10⁻³ nats) 1.75 3.56
Safe band — 21 of 48 layers All layers — 48 of 48

The benchmark sees nothing. Everything that looks at what the model actually does sees a factor of two to two and a half. Safe band wins all twelve fidelity metrics on both architectures.

To rule out the obvious objection — that quantizing fewer layers trivially drifts less — I ran a control where every arm quantizes exactly 21 of 48 layers and only the choice of layers changes: the selected band, three random draws, and the 21 most-sensitive layers. The selected band beat count-matched random on 12 of 12 metrics. Paired over the same 150 prompts with 4,000 bootstrap resamples, exact top-k set match improves by +6.52 points, 95% CI [+6.31, +6.73], winning on 150 of 150 prompts.

12 / 12 Fidelity metrics won, both models
+6.52 Top-k set match vs count-matched random
150 / 150 Prompts won in the control
19,200 Token positions scored per config
What this does not yet show

All-layer int8 is still the better memory trade. It saves 15.6 GB more than the safe band at equal perplexity and equal multiple-choice accuracy. The safe band’s measured advantages are fidelity and throughput, not footprint.

On the Qwen models the ranking may be restating depth. Spearman correlation between layer index and sensitivity is −0.852 (30B) and −0.947 (35B), and a plain “deepest N layers” band recovers most of the advantage over random. A last-N control arm would separate the two and has not been run. On the smaller Phase 1 models the safe tier sat mid-network, where a depth heuristic would have picked the wrong layers — so depth is not a universal answer, but the Qwen result is not yet clean.

Long-form output quality has never been measured. Every metric here is accuracy, perplexity, or distance from the bf16 model.

Phase 1 · 2025–26
Apple M4 Pro / M3 Max, PyTorch MPS · four small MoE models

Where a MoE Model Can Afford to Lose Precision

OLMoE-1B-7B JetMoE-8B Layer Ablation Routing Analysis

The work that led to the H100 study. Quantize one layer at a time, measure the perplexity delta, and treat everything under 0.3% as the safe band. On OLMoE that was 4 of 16 layers and on JetMoE 6 of 24 — and across six benchmarks the largest degradation anywhere in the phase was −0.66 pp, with WikiText-2 perplexity unchanged at 6.67.

The more interesting result came from a different intervention: replacing layers with identity instead of quantizing them. Damage compounds super-linearly, and which layers you touch matters more than how many.

OLMoE-1B-7B, layers replaced with identity. Baseline perplexity 6.67.
Layers removedPerplexityChangeMean logit KL
L7 — one layer13.82+7.42%0.040
L6–7 — two consecutive16.11+25.15%0.170
L4–7 — four consecutive33.06+156.90%0.632
L3, L7, L11 — three scattered42.58+230.91%0.646

Four consecutive layers cost roughly seven times the sum of their individual impacts, and three scattered layers cost more than four adjacent ones. That is the observation the whole safe-band idea rests on: position dominates count.

Routing turned out to be strongly structured too. Maximum expert coefficient of variation reached 0.9913, and Jensen–Shannon divergence between per-domain routing distributions spanned an order of magnitude — history against code at 0.0401 [0.0373, 0.0452], biology against chemistry at 0.0038 [0.0035, 0.0073].

Caveats on this phase

The quantization was simulated. Weights were quantized then dequantized back to fp16 and stored that way, so it measures the precision impact only — no memory was actually saved and the 1.73 GB figure is theoretical. Phase 2 on the H100 is where real int8 was run.

The router was quantized too, which contaminates any routing conclusion drawn from this phase.

The domain-classifier result is thin. Router logits classify domain at 95% using all 16 layers, but a keyword baseline reaches 90% on the same 20 items — a margin of one item. It needs a larger evaluation set before it means anything.

Run log

2026-10-31
Fixed-layer-count control, 5 arms, 1 h 20 m — safe band beats count-matched random on 12 of 12 metrics
2026-10-30
Fidelity sweep finishes on both large models — safe band wins all 12 rows on Qwen3-30B and Qwen3.5-35B
2026-10-16
Qwen3-30B practical table: 44.73 GB at ppl 6.6011 against bf16’s 56.87 GB at 6.5998
2026-06
Phase 1 on Apple silicon — simulated int8 across four small MoE models; largest benchmark degradation anywhere was −0.66 pp
Full run ledger — every run, including the ones that failed or were never finished — available on request.

From Curiosity to Systems Engineering

The evolution from exploring Python to engineering production-grade AI infrastructure — told as it unfolded.

2023
The Spark

Everything started with curiosity. I picked up Python not because I had a plan, but because everyone said it was the language to learn. I started with basics — variables, loops, functions — then quickly fell into the rabbit hole of backend systems and APIs.

The first "hello world" API I built with Flask felt like magic. I had no idea what I was doing, but it worked.

PythonFlaskAPIsBasic ML
2024
Building Production Systems

This is when things shifted from hobby to serious engineering. I built my first production-ready RAG pipeline, deployed workflow automation with n8n, and integrated various AI APIs into real applications.

Key realization: The gap between "AI demos" and "AI systems" is enormous. Most tutorials stop at the demo. I wanted to build what comes after.

LangChainChromaDBOllaman8nFastAPI
2025
Deep Dive into AI Systems

I went deep. LoRA fine-tuning — understanding rank selection, placement strategies, and when parameter-efficient methods break down. Multi-agent orchestration — building systems where multiple LLM agents coordinate on complex tasks.

Built a multi-agent coding system from scratch. It was buggy, slow, and frustrating. I learned more from that project than from any tutorial.

LoRA/QLoRAMLXAgent SystemsInference Opt.RAG
2024-25
The Pivot That Didn't Happen

I once tried to build a startup around an AI-powered hiring intelligence platform. The vision was compelling — semantic skill matching, contextual relationship scoring, and an ATS that actually understood candidates beyond keywords.

Sometimes the best engineering decisions are the ones you don't ship. I learned more about product-market fit, team dynamics, and when to walk away from this project than from any that succeeded.

It’s shelved rather than abandoned, and what I learned went straight into HireFlash — the same problem, approached as a product with real unit economics instead of a pitch.

Vector DBsEmbeddingsGraph MLATS Systemsn8n
2026
Research & Infrastructure at the Edge

Current focus: selective int8 quantization for Mixture-of-Experts models, running on an H100 at VIT’s DST-FIST server. Seven MoE architectures profiled layer by layer, two taken all the way through real int8 and a fidelity evaluation against the unquantized model.

I'm building infrastructure that bridges the gap between research papers and production systems — taking experimental architectures and making them actually work at scale.

The goal isn't just to use AI. It's to understand it deeply enough to build what doesn't exist yet.

MoESparse RoutingKV CacheEdge AIInfra
Beyond
What's Next

I'm exploring the convergence of efficient inference, agent memory architectures, and AI-driven developer tools. The future isn't just bigger models — it's smarter systems that use intelligence efficiently.

Always open to research collaborations, ambitious projects, and conversations about where AI infrastructure is heading.

If you're working on something interesting in AI systems, I'd love to hear about it.

Open to Ideas

Tools of the Trade

A curated stack focused on building, optimizing, and deploying AI systems from the ground up.

🧠
AI / Machine Learning
12 tools
PyTorch Transformers LangChain LangGraph Ollama MLX ChromaDB LoRA QLoRA RAG Semantic Search Vector DBs
⚙️
Backend & Infrastructure
9 tools
Python FastAPI REST APIs gRPC Docker PostgreSQL Redis Nginx Linux CI/CD
💻
Frontend & UI
7 tools
Next.js TypeScript React TailwindCSS Framer Motion Three.js HTML5 / CSS3
⚡
Automation & Tools
5 tools
n8n GitHub Actions Cloudflare Vercel Workflow Systems AI Pipelines

Certifications

Verified certifications across AI, ML, and cloud platforms.

Let's Build Something Ambitious

I'm always interested in connecting with people who share my passion for building intelligent systems — whether it's AI engineering internships, ambitious AI projects, research collaborations, or experimental infrastructure work.