Senior software engineer — I build across the whole stack, centered on AI. From speculative decoding and verifiable RAG to ten on-device mobile apps and a WebGPU renderer: the deterministic AI core and the mobile, web, and GPU surfaces on top of it.

My one design rule, in every agent I ship: the model proposes; deterministic, tested code validates and executes. The interesting engineering isn't the prompt — it's the guardrail the prompt can't talk its way past.

44 repos · 1,140+ tests green in CI · 14 live demos · cores in 7 languages · 8 with reproducible benchmarks

Open to Senior / Staff Software Engineering roles — AI systems, backend & distributed systems, and the product surfaces (web, mobile, GPU) on top.

_{Every image links to a live demo. Top: AI dashboards (AgentForge, agent-trace). Bottom: three of ten on-device Flutter apps — plus a WebGPU boids renderer.}

I'm a Senior Software Engineer at Microsoft, and on nights and weekends I build small, tested tools for the unglamorous parts of putting AI in production. Everything below is real code with a README that explains the why, tests that assert the hard part, and — where it earns one — a design doc with trade-offs and reproducible benchmarks.

Production AI and platform work at scale — the day job behind the side projects:

• Copilot Studio — shipped an in-house AI agent (Workflows Agents) into Microsoft 365 Copilot, leading the First Run Experience squad; re-architected a large enterprise service into distributed microservices and built the reverse-proxy layer routing between customer-managed and data planes — systems used globally at enterprise scale.
• Zero-Trust platform — built three production AI agents on the team: an E2E failure- triage agent that auto-diagnoses failed pipeline runs and files bugs (turning hours of manual triage into minutes), a PR review & security agent, and a RAG architecture knowledge agent with citation-backed answers across repos and specs.
• Copilot for Finance — greenfield microservices (telemetry, metadata store, auth), RESTful APIs, App Store publication, and CI/CD automation for faster, more frequent releases.

llm-in-production — field notes on the seven things that will bite an LLM feature in production (cost, evals, prompt injection, drift, grounding, rate limits, agent guardrails), each with the pattern that fixes it and the small tool that implements it. If you read one thing, read its pre-launch checklist.

The whole model of how these fit on the request path:

flowchart LR
  U["Request"] --> IN["Guard input<br/>(prompt-shield)"]:::g
  IN --> Q["Budget check<br/>(quota-gate · token-lens)"]:::g
  Q --> M["Model"]:::m
  M --> OUT["Redact output<br/>(prompt-shield)"]:::g
  OUT --> R["Response"]:::ok
  M -.->|trace + cost| LOGS["Attribution<br/>(agent-trace)"]:::ok
  M -.->|grounded by| RAG["Cited retrieval<br/>(ledger-rag)"]:::ok
  classDef g fill:#faf5ff,stroke:#a855f7,color:#4c1d95;
  classDef m fill:#eff6ff,stroke:#3b82f6,color:#1e3a8a;
  classDef ok fill:#f0fdf4,stroke:#22c55e,color:#14532d;

• Agents that do real work, safely — planner/executor splits with a policy gate and human-in-the-loop approval: operations-agent, incident-commander (Go), agent-guard (zero-trust tool sandbox), guardianforge (fleet governance, Go + C#).
• Grounded retrieval — RAG you can prove: ledger-rag ships a tamper-evident proof with every answer; knowledge-workspace cites every claim; repo-index turns any repo into a citable knowledge base and answers only from retrieved source.
• Ship-it discipline — eval-forge (CI eval gate), prompt-shield (injection in / PII out), token-lens (cost attribution), quota-gate (per-tenant budgets), drift-watch (PSI/KL drift).
• Systems underneath — consensus and correctness: coracle (Raft) + flotilla (thousands of groups on one node), deterministic-sim-testing, durable-execution.
• Model internals & LLM correctness — spec-decode implements speculative decoding from scratch and proves it's exact (the emitted distribution provably equals sampling the target), with honest speedup benchmarks; metamorph is metamorphic testing for LLMs — invariance under paraphrase, reorder, and negation, shrinking each failure to a minimal prompt; honest-transformer is a transformer forward pass with bit-identical logits across Python, C#, and Java; and batch-invariant shows — and fixes — the reduction-order bug that makes a decoded token depend on its batch-mates.
• Interfaces, mobile & graphics — ten on-device Flutter apps, each a tested, deterministic core with a live demo (intent-canvas, morph-ui, aura-surface, thumb-sphere, and more); web dashboards in React / Next / React Flow (the agent tooling above); and gpu-flock, thousands of boids computed and drawn entirely on the GPU with WebGPU compute shaders.

Project	What it is		CI
agent-trace	visual timeline + replay for agent runs — where a run spent time, tokens, and money, then diff two runs	▶ demo
agentforge-dashboard	register, monitor, and deeply compare agents — radar + trade-off insights, spatial agent map	▶ demo
ledger-rag	verifiable RAG — every answer ships a tamper-evident cryptographic proof (Python/C#/Java)
agent-guard	zero-trust runtime sandbox for tool-calling agents: least-privilege policy + signed audit log
infra-optimizer	AI infra optimizer in Rust — the model only picks among candidates Rust has already proven safe
gpu-flock	a few thousand boids flocking entirely on the GPU with WebGPU compute shaders	▶ demo
intent-canvas	intent-first mobile home — express a goal in plain language, get a living workspace of modules; on-device deterministic intent engine (Flutter)	▶ demo

More — 44 focused projects, 14 live demos — under parag-labs.

Most RAG systems ask you to trust that an answer came from your corpus. ledger-rag makes it checkable: every retrieved chunk is a leaf in a Merkle tree, and each answer ships an inclusion proof binding it to a signed root — so a third party can verify the evidence set wasn't altered after the fact, without re-reading the corpus. The design doc owns the boundary honestly ("tamper-evident ≠ tamper-proof", the way certificate transparency does), and the same core is written three times — Python, C#, Java — so the property is the property, not a trick of one language's crypto library.

Where performance is a claim, there's a committed script and a graph. Example — why consistent hashing instead of hash % N, from consistent-hash:

Adding a node to a 64-node cluster remaps ~1% of keys with a consistent-hash ring; plain hash % N remaps ~98.5% — nearly the entire keyspace, every time. Eight repos ship a BENCHMARKS.md like this, measured on a plain machine from a script you can re-run.

A lot of the cores are written in Python, and C#, and Java. That's not for show: they're plain algorithms (a Merkle proof, a point-in-time join, a drift statistic), and porting them keeps me honest that the logic is the logic — not a trick of one language's libraries.

Outside the org I also maintain flatwire — streaming serialization with one identical API across six languages, published to every major registry:

• 🧰 Backend · distributed systems · applied cryptography · LLM & agent tooling
• ☁️ Azure (AKS, Container Apps, Cosmos DB), Docker/Kubernetes, CI/CD
• 🌐 Portfolio: parags.dev
• 💬 linkedin.com/in/paragsawant