Gagan Jain

Governance-first, event-sourced AI operating environment in Rust — 12 workspace crates, 981 tests, provider-agnostic LLM streaming.

• Designed a governance-first, event-sourced AI OS in Rust: 12 workspace crates, 981 passing tests, 0 clippy warnings, full GitHub Actions CI/CD
• Built a policy-enforced agent kernel where LLMs propose actions and the kernel validates and records every state change in an append-only audit trail
• Implemented a provider-agnostic LLM layer with OpenAI-compatible and Anthropic streaming, LiteLLM routing, and local-first inference that runs fully offline
• Delivered native terminal emulation (PTY + VT100), SSH multiplexing, a secrets vault, and four interfaces: CLI, TUI, GUI, RPC

Companion repo to NexusAOS — the alpha-track sibling of the same 12-crate Rust workspace, focused on the microkernel layer (event-sourced governance, provider-swappable model interface).

• Companion to NexusAOS: shares the same 12-crate Rust workspace and its 981-test suite (tracked under NexusAOS)
• Implemented event-sourced append-only audit trail, policy engine with trust tiers, and provider-swappable model interface
• Integrated OpenAI-compatible and Anthropic streaming with real-time token streaming into TUI/GUI
• Delivered native terminal emulation (PTY + VT100 + Zig parser), SSH multiplexing, and multi-interface CLI/TUI/GUI/RPC

NexusAOS v2 — governance-first, local-first AI OS with specialist local models and LiteLLM-compatible routing.

• Architected specialist model stack: Gemma 4 12B (Planner), Qwen3-Coder 30B (Implementation), Qwen3.5 9B (Vision)
• Designed kernel-centric governance where models propose actions and the kernel validates/records every state change
• Built a LiteLLM-compatible proxy for NVIDIA NIM and other model providers
• Maintained event-sourced architecture with reversible, permissioned actions and offline-first execution

Sanskrit-oriented programming language with complete compiler pipeline and browser-based IDE. 123 tests.

• Complete compiler pipeline: lexer → parser → type checker → bytecode compiler — all built from scratch in Rust
• Browser-based IDE with React, Monaco Editor, syntax highlighting, autocomplete, and diagnostics
• Rust (axum) backend with compile, REPL, LSP, and file management endpoints via REST + WebSocket
• 123 tests covering the full pipeline, including a self-hosting corpus

Production RAG API service: hybrid retrieval (vector + keyword), embeddings, reranking-ready, and an LLM-as-judge eval harness.

• Built a FastAPI RAG service with hybrid retrieval (dense embeddings + BM25 keyword, merged via Reciprocal Rank Fusion) over ChromaDB
• Implemented chunking strategies (recursive, semantic), embedding pipelines, and an /ask endpoint that streams grounded answers with citations
• Shipped LLM-as-judge evaluation harness (faithfulness, answer relevance, correctness) with golden-set CI gate and RAGAS-style reports
• Containerized with Docker Compose; OpenAI-compatible LLM interface with local-first fallback

Reusable LLM evaluation harness: golden-set YAML, LLM-as-judge metrics, offline heuristic fallbacks, and CI-ready reports.

• Built a golden-set-driven evaluation harness with faithfulness, answer-relevance, and correctness metrics (LLM-as-judge + lexical fallbacks)
• Added offline heuristic scorers so evals run in CI without API keys; JSON + Markdown reports for regression tracking
• Designed golden-set YAML format (question, golden answer, context) and a CLI: python -m eval_harness --golden-set ...
• Containerized and CI-ready; used to gate the RAG service pipeline

Production-grade Flask + MySQL platform with Argon2id auth, Prometheus monitoring, and CI/CD.

• Production-grade Flask + MySQL platform with Argon2id auth, CSRF protection, brute-force lockout, breached-password scanning, JWT sessions, and strict CSP/HSTS headers
• Deployed Prometheus metrics, structured JSON logging, Chart.js analytics, FullCalendar scheduling, Docker Compose, and GitHub Actions CI/CD; 101 automated pytest tests

Optimizes surplus-food allocation to NGOs with a 3-stage lexicographic linear program (fairness → priority → cost) and expiry-aware routing.

• Built a 3-stage lexicographic LP solver (fairness → priority → cost) to allocate surplus food to NGOs while minimizing waste
• Added expiry-aware routing that penalizes allocations where travel time exceeds food shelf life
• Integrated Folium/Leaflet interactive maps with animated routes, heatmaps, and priority-colored markers
• Shipped a Flask web dashboard plus a desktop Tkinter GUI with charts and CSV export