Anmol Adwani

Demo

AI Agents · 2026

ForgeMind AI

An autonomous agent that turns a GitHub issue into a verified pull request.

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.

What I built

• 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.

6 / 7

tasks resolved on hidden tests

22

passing tests in CI

• Python
• Claude API
• BM25
• AST indexing
• Sandboxing
• GitHub API

Code

Demo

Distributed Systems · 2026

NebulaOS

A self-healing cloud orchestrator, a small Kubernetes written from scratch in Go.

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.

What I built

• 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.

0.57s

to elect a new leader

3.19s

full recovery after the leader is killed

730 ops/s

replicated writes, p99 38 ms

• Go
• Raft
• gRPC
• Docker
• containerd
• React
• Prometheus

Code LinkedIn post

Demo

Distributed Systems · 2026

NebulaChaos

A Jepsen-style correctness lab that made my Raft cluster lie, then proved the fixes.

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?

What I built

• 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.

3

real bugs found and fixed

284,732

operations, all linearizable after fixes

20,000

histories cross-checked against Porcupine

• Go
• Linearizability
• Fault injection
• Raft
• Porcupine

Code

Distributed Systems · 2026

AegisDB

A fault-tolerant, sharded, linearizable key-value database built from scratch in Go.

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.

What I built

• 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.

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

• Go
• Multi-Raft
• WAL
• Prometheus
• Porcupine

Code

Demo

Systems & Security · 2026

ChronoForge

A deterministic record/replay engine and time-travel debugger in Rust.

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.

What I built

• 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.

~800 B

log to replay a full run

300

schedules hunted in under a second

• Rust
• ptrace
• Vector clocks
• React
• TypeScript
• gRPC

Code

Demo

Systems & Security · 2026

GhostKernel

An x86-64 kernel in Rust whose processes come back from the dead.

Problem

On a normal OS a crash is final: one wild pointer at hour six and everything the process computed is gone.

What I built

• 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.

20

kernel and end-to-end tests

QEMU

booted and tested in CI

• Rust
• x86-64
• Bare metal
• QEMU

Code

Demo

Distributed Systems · 2026

ShadowTwin

A digital twin of a Kubernetes cluster that predicts which services fail when servers die.

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.

What I built

• 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.

96.2%

predictions correct (127/132)

59.1%

for the naive baseline

• Go
• Python
• PyTorch
• Kubernetes
• Prometheus
• React

Code

Demo

Systems & Security · 2026

ThreatPulse AI

Real-time cyber threat detection that folds alerts into MITRE ATT&CK kill-chain incidents.

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.

What I built

• 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.

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

• Python
• Online ML
• MITRE ATT&CK
• LLM briefings
• Live dashboard

Code

AI Agents · 2026

GoldenHour

A Hindi/English voice agent for the first 60 minutes after an online scam.

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.

What I built

• 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.

3

languages: Hindi, English, Hinglish

13

pytest guardrail tests

• Python
• FastAPI
• Groq Whisper
• ElevenLabs
• React
• three.js

Code

AI Agents · 2026

MemoryForge

A coding agent that remembers why it failed and proves which lessons actually help.

Problem

Coding agents repeat their mistakes. Saving their reflections sounds obvious, but bad lessons can make an agent worse.

What I built

• 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.

30.8% → 43.3%

first-try pass rate on held-out tasks

37 / 38

harmful lessons blocked

• Python
• PostgreSQL
• pgvector
• PyTorch
• Docker

Code

Demo

Full-stack & Data · 2026

Wind Watch

Day-ahead wind forecast intelligence for GB power trading.

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.

What I built

• 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.

−28%

forecast error after a rolling bias fix

86%

of hours inside the P10–P90 band

• React
• TypeScript
• FastAPI
• pandas
• Docker
• Vercel

Code Live app

Demo

Full-stack & Data · 2026

Ledgerly

A personal finance tracker with budgets, savings goals and monthly reports.

Problem

Most people don't know where their money goes each month.

What I built

• 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.

CSV + PDF

report exports

Light + dark

themes, mobile layout

• Next.js 16
• React 19
• PostgreSQL
• Drizzle
• Vitest

Code

More projects

1. May 2026 – PresentRemote

   Software Engineer Intern

   Dream Telecommunication Pvt. Ltd.

   • 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.
2. 2026 – PresentRemote

   Independent Researcher, Wind Power Forecasting

   Self-directed

   • 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.
3. May 2025 – Jul 2025Remote

   AI & IoT Solutions Intern

   Opsight AI

   • 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.