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.
45 repos · 1,180+ tests green in CI · 21 live demos · cores in 7 languages · 9 with reproducible benchmarks
Open to Senior / Staff Software Engineering roles — AI systems, backend & distributed systems, and the product surfaces (web, mobile, GPU) on top.
🆕 cleanroom-ai: clean it before you share it. Six privacy tools whose OCR, speech and PII models run entirely in your browser, so nothing gets uploaded: Screenshot Redactor · Log Scrubber · PDF Redactor · Audio Redactor · Photo Share-Safe · Video Redactor
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 | |
|---|---|---|---|
| cleanroom-ai | six privacy tools (screenshots, logs, PDFs, audio, photos, video) that strip secrets & PII with OCR, speech and NER models running 100% in the browser; nothing uploaded | ▶ demos |  |
| 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. Nine
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:
…and switchboard — an open-source,
self-hosted feature-management platform with one identical flag-evaluation engine in
six languages (.NET, JS, Python, Go, Java, Rust). A shared conformance corpus runs through
all six in CI and publishes a 150/150 pass/fail matrix — including exact
cross-language identity of the SHA1 rollout-bucketing, so a user lands in the same
percentage slice no matter which SDK a service uses. Ships SDKs + OpenFeature providers to
every registry, a control-plane server with an Admin UI, and a self-hosting story
(docker compose up). Live dashboard & playground →
Everyone pastes screenshots, logs, PDFs and recordings into tickets, chats and AI assistants, and they leak secrets and personal data. cleanroom-ai is six free tools that clean those files first. The OCR, speech and PII models all run in your browser tab, so the file you are protecting never leaves your device.
🕶️ Screenshot Redactor API keys, passwords, emails, cards, names, faces & QR codes in screenshots 
|
🧽 Log Scrubber tokens, cookies & PII in logs, .env, JSON and HAR files, structure-aware
|
📄 PDF Redactor true redaction: flattens pages, then verifies no hidden text survives
|
🔊 Audio Redactor bleeps names, phone & card numbers with Whisper running in the tab
|
📷 Photo Share-Safe strips GPS & hidden EXIF, blurs faces and license plates
|
🎬 Video Redactor tracks keys, names & faces through screen recordings, re-encodes WebM
|
The live badge is a weekly GitHub Actions job that opens the published Hugging Face Space in a real browser, runs the example end to end, and fails if a single request leaves the page.
How do you know nothing is uploaded?
- Strict Content-Security-Policy. Each page may only connect to its own origin (plus Hugging Face's CDN for the Space's own model files), so the browser itself blocks any other destination.
- Everything is bundled. Models, WASM runtimes and libraries ship inside the Space: no third-party CDNs, fonts, analytics or accounts.
- CI that fails on any leak. A real-browser test records every network request and fails the build on any upload, any non-GET request or any third-party host, first against localhost and then against the live Space.
- Redaction is verified, not assumed. PDFs are flattened and then re-scanned to confirm no text remains, and videos are re-OCR'd after encoding to prove that none of the redacted items can still be read.
- Shared, tested engine. All six tools run on
@cleanroom-ai/core: checksum-validated secret and card rules, entropy checks, a PII NER model, PP-OCRv6 and YuNet faces.
- 🧰 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