# Anmol Adwani

> Software engineer building AI agents and distributed systems. CS student at LNMIIT, Jaipur, India (B.Tech + M.Tech Dual Degree, Computer Science, Expected May 2028). Open to software engineering internships, remote.

I'm a Computer Science student at LNMIIT, Jaipur. I learn how things work by building them from the ground up: a Raft-based orchestrator, a sharded database, a Rust kernel, and AI agents that fix real bugs. I like problems where things can fail, because designing for failure forces clear thinking.

## Links
- [Portfolio](https://anmol-porfolio.vercel.app/)
- [Resume (PDF)](https://anmol-porfolio.vercel.app/Anmol_Adwani_Resume.pdf)
- [GitHub](https://github.com/coolstack-coder)
- [LinkedIn](https://www.linkedin.com/in/anmolaa100/)
- Email: anmoladwani100@gmail.com

## Projects
- [ForgeMind AI](https://github.com/coolstack-coder/ForgeMind-AI-Autonomous-Software-Engineering-Agent): An autonomous agent that turns a GitHub issue into a verified pull request. Results: 6 / 7 tasks resolved on hidden tests; 22 passing tests in CI. Stack: Python, Claude API, BM25, AST indexing, Sandboxing, GitHub API.
  - Problem: Most AI coding tools stop at suggesting code. Nothing reproduces the bug, nothing proves the fix, and nobody can see why the change was made.
  - Grounds every decision in the real repo with an AST symbol index and a BM25 search corpus.
  - Reproduces the bug as a failing test before touching source, then localizes the fault with spectrum-based fault localization (Ochiai).
  - Two repair engines: a Claude tool-using agent and an offline search-based repair engine.
  - Accepts a patch only if the reproduction passes and the full suite stays green in a sandbox, then opens a PR with the regression test and root-cause note.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/ForgeMind-AI-Autonomous-Software-Engineering-Agent@main/docs/media/forgemind-demo.mp4
- [NebulaOS](https://github.com/coolstack-coder/NebulaOS): A self-healing cloud orchestrator, a small Kubernetes written from scratch in Go. Results: 0.57s to elect a new leader; 3.19s full recovery after the leader is killed; 730 ops/s replicated writes, p99 38 ms. Stack: Go, Raft, gRPC, Docker, containerd, React, Prometheus.
  - Problem: Most engineers only see Kubernetes through YAML. I wanted every step from "run 3 replicas" to "a machine died at 3 a.m. and nobody woke up" to be code I could read.
  - Raft consensus from zero: pre-vote, check-quorum, CRC-checked durable log, snapshots and leader group commit.
  - A kube-scheduler style filter-and-score scheduler, plus HPA-style autoscaling and node draining.
  - A heartbeat failure detector that reschedules lost workloads on healthy nodes and measures recovery time.
  - gRPC between nodes, Docker and containerd runtimes, a live React dashboard, Prometheus and Grafana.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/NebulaOS@main/docs/media/nebulaos-demo.mp4
- [NebulaChaos](https://github.com/coolstack-coder/NebulaChaos): A Jepsen-style correctness lab that made my Raft cluster lie, then proved the fixes. Results: 3 real bugs found and fixed; 284,732 operations, all linearizable after fixes; 20,000 histories cross-checked against Porcupine. Stack: Go, Linearizability, Fault injection, Raft, Porcupine.
  - Problem: Chaos tests usually ask "did it come back up?". The harder question is safety: did the system ever tell a client something that wasn't true?
  - Runs five real NebulaOS processes with a fault proxy on all 20 network links: partitions, SIGSTOP pauses, crashes, power loss and bit rot.
  - Records every read, write and compare-and-set, then checks the history with my own linearizability checker (Wing–Gong–Lowe).
  - Shrinks every failure to a 2–4 operation counterexample. Found and fixed stale reads, bit-rot data loss and double-applied commands.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/NebulaChaos@main/docs/media/nebulachaos-demo.mp4
- [AegisDB](https://github.com/coolstack-coder/AegisDB): A fault-tolerant, sharded, linearizable key-value database built from scratch in Go. Results: 0 lost writes out of 200k+ acknowledged under chaos; 14,444 ops/s with fsync on every commit; ~1s to elect a leader after kill -9. Stack: Go, Multi-Raft, WAL, Prometheus, Porcupine.
  - Problem: Add replicas to a database and you face split brain, lost acknowledged writes, stale reads and torn logs. AegisDB is designed around each of these failures.
  - Multi-Raft sharding with a consistent-hash ring and rendezvous hashing, with no coordinator.
  - PreVote, CheckQuorum and ReadIndex reads with a leader-lease fast path.
  - A CRC32-C write-ahead log that truncates a torn tail but refuses to replay past bit rot.
  - Exactly-once retries through client sessions, plus a lab with kill/partition buttons and a chaos monkey.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/AegisDB@main/docs/aegisdb-demo.mp4
- [ChronoForge](https://github.com/coolstack-coder/ChronoForge): A deterministic record/replay engine and time-travel debugger in Rust. Results: ~800 B log to replay a full run; 300 schedules hunted in under a second. Stack: Rust, ptrace, Vector clocks, React, TypeScript, gRPC.
  - Problem: Some bugs only appear for one thread interleaving, one clock value or one random seed. Re-running changes all of those, so the bug disappears.
  - Records only the nondeterminism (schedules, clocks, random numbers, input) into a log of a few hundred bytes, then replays bit-for-bit.
  - Reverse stepping, reverse watchpoints and a chaos-hunting mode where every failure is already a replayable recording.
  - Race detection with vector clocks, lock-order and deadlock cycles, and backward slicing that ranks the root cause.
  - A native Linux ptrace recorder for real ELF binaries.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/ChronoForge@main/docs/media/chronoforge-demo.mp4
- [GhostKernel](https://github.com/coolstack-coder/GhostKernel): An x86-64 kernel in Rust whose processes come back from the dead. Results: 20 kernel and end-to-end tests; QEMU booted and tested in CI. Stack: Rust, x86-64, Bare metal, QEMU.
  - Problem: On a normal OS a crash is final: one wild pointer at hour six and everything the process computed is gone.
  - In-kernel checkpoint/restore of registers, memory and open files, with dirty-page incremental checkpoints.
  - On a fault the kernel rebuilds the process from its newest checkpoint and rolls back file writes with an undo log.
  - A crash-loop guard, and a full UI drawn by the kernel itself on a 1280×800 framebuffer.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/GhostKernel@main/docs/demo.mp4
- [ShadowTwin](https://github.com/coolstack-coder/ShadowTwin): A digital twin of a Kubernetes cluster that predicts which services fail when servers die. Results: 96.2% predictions correct (127/132); 59.1% for the naive baseline. Stack: Go, Python, PyTorch, Kubernetes, Prometheus, React.
  - Problem: Kubernetes tells you that a node died. It doesn't tell you which services will go down, which will limp along, and which will recover.
  - Mirrors the live cluster from the API server and Prometheus, and grades its own fidelity every 2 seconds.
  - Replays Kubernetes' failure machinery to predict every service's state at three points in time.
  - Pre-flight checks rate a change SAFE, RISKY or BLOCK against 41 failure scenarios.
  - Seals each prediction with SHA-256, kills real nodes, then scores the prediction against reality.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/ShadowTwin@main/docs/media/demo.mp4
- [ThreatPulse AI](https://github.com/coolstack-coder/ThreatPulse): Real-time cyber threat detection that folds alerts into MITRE ATT&CK kill-chain incidents. Results: 100% recall on 27 attack campaigns; 0 false-positive incidents in 1.5 h of benign traffic; 68k pkt/s with ML, on a laptop. Stack: Python, Online ML, MITRE ATT&CK, LLM briefings, Live dashboard.
  - Problem: Attackers are rarely invisible, just unnoticed. Each stage of an attack looks harmless on its own, and rule-based tools bury analysts in uncorrelated alerts.
  - Streams network traffic through rules, behavioural analytics and online ML (Half-Space Trees) that adapts to drift.
  - Correlates alerts into one incident through entity pivots across the ATT&CK kill chain.
  - Every alert carries its evidence, and every incident gets an analyst briefing.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/ThreatPulse@main/docs/media/demo.mp4
- [GoldenHour](https://github.com/coolstack-coder/GoldenHour_Voice_Agent): A Hindi/English voice agent for the first 60 minutes after an online scam. Results: 3 languages: Hindi, English, Hinglish; 13 pytest guardrail tests. Stack: Python, FastAPI, Groq Whisper, ElevenLabs, React, three.js.
  - Problem: Stolen money can only be frozen if it's reported fast, but a scam victim is panicking. People can't type, but they can still talk.
  - A voice agent (speech-to-text, LLM, text-to-speech) that turns a caller's story into a live case file, countdown and recovery plan.
  - "LLM extracts, code decides": the model has only 2 tools, while deadlines, helplines and legal text come from deterministic Python.
  - Ready-to-file cybercrime and bank complaint drafts, with OTP, card and Aadhaar numbers masked before storage.
- [MemoryForge](https://github.com/coolstack-coder/MemoryForge): A coding agent that remembers why it failed and proves which lessons actually help. Results: 30.8% → 43.3% first-try pass rate on held-out tasks; 37 / 38 harmful lessons blocked. Stack: Python, PostgreSQL, pgvector, PyTorch, Docker.
  - Problem: Coding agents repeat their mistakes. Saving their reflections sounds obvious, but bad lessons can make an agent worse.
  - A lesson is admitted only after counterfactual replay (with vs. without, paired seeds) and retired by a randomized hold-out arm.
  - Retrieval with pgvector plus a PyTorch reranker.
  - A 36-task benchmark with six conditions, including a shuffled-lesson placebo, paired statistics and a results dashboard.
- [Wind Watch](https://github.com/coolstack-coder/WW_AN): Day-ahead wind forecast intelligence for GB power trading. Results: −28% forecast error after a rolling bias fix; 86% of hours inside the P10–P90 band. Stack: React, TypeScript, FastAPI, pandas, Docker, Vercel.
  - Problem: Before the day-ahead auction closes, a trading desk must decide how much power to buy on top of what wind will provide, without knowing how far to trust the forecast.
  - A Decision Desk showing the forecast available at gate closure, a P10–P90 band and a bias-adjusted expectation.
  - A Forecast Explorer and Accuracy Lab for any window and horizon, with no look-ahead.
  - FastAPI backend and React frontend deployed together on Vercel.
  - Live: https://ww-an.vercel.app
  - Demo video: https://raw.githubusercontent.com/coolstack-coder/WW_AN/main/docs/media/wind_watch_demo.mp4
- [Ledgerly](https://github.com/coolstack-coder/Personal-Finance-Tracker): A personal finance tracker with budgets, savings goals and monthly reports. Results: CSV + PDF report exports; Light + dark themes, mobile layout. Stack: Next.js 16, React 19, PostgreSQL, Drizzle, Vitest.
  - Problem: Most people don't know where their money goes each month.
  - Google sign-in (OAuth with PKCE), per-user data isolation and validated server actions.
  - Budgets with pace projection, savings goals, monthly reports and CSV/PDF export.
  - Integration tests run against real Postgres migrations.
  - Demo video: https://cdn.jsdelivr.net/gh/coolstack-coder/Personal-Finance-Tracker@main/docs/media/demo.mp4

## Experience
- Software Engineer Intern, Dream Telecommunication Pvt. Ltd. (May 2026 – Present, Remote)
  - Build API-integrated product workflows with TypeScript, React, Node.js and REST, turning requirements into testable features.
  - Prototype GenAI-assisted workflows, documenting expected behaviour, edge cases and failure modes before iterating.
  - Debug frontend, API and data-flow issues in short implementation cycles.
- Independent Researcher, Wind Power Forecasting, Self-directed (2026 – Present, Remote)
  - Probabilistic post-processing of GB day-ahead wind forecasts: bias correction, quantile regression and conformal prediction for calibrated P10–P90 intervals.
  - Evaluated with pinball loss and CRPS under strict no-look-ahead back-testing. Manuscript in preparation.
- AI & IoT Solutions Intern, Opsight AI (May 2025 – Jul 2025, Remote)
  - Built API-connected data views and operational dashboards for an industrial AIoT SaaS product.
  - Turned shop-floor sensor signals into decision-ready interfaces for manufacturing teams.

## Skills
- Languages: Go, Python, Rust, TypeScript, JavaScript, SQL, C++
- AI & LLMs: AI agents, Tool calling, RAG, Evals & guardrails, Claude, OpenAI, Gemini, Groq, PyTorch
- Distributed systems: Raft, gRPC, Write-ahead logs, Linearizability testing, Kubernetes, Docker
- Web & data: React, Next.js, Node.js, FastAPI, Flask, PostgreSQL + pgvector, Prometheus

## Education
- The LNM Institute of Information Technology (LNMIIT), Jaipur: B.Tech + M.Tech Dual Degree, Computer Science, Expected May 2028