I build
Engineer with 2.5 years across cloud infrastructure, backend systems, developer tooling and applied AI. MS Computer Science, Rutgers. Six projects follow, in detail.
production
platform I run
speedup
Tech Over
The per-request waterfall my LLMOps gateway emits — injection screen, complexity routing, provider call, automatic failover. The real dashboard is live here.
LLMOps
Control Plane
One API · six providers · nothing goes dark
Every team wiring an app to an LLM rebuilds the same four things badly: retries, cost tracking, a kill-switch for bad prompts, and a way to find out what actually happened at 3am. This is that layer, built once and self-hostable.
It sits between your applications and OpenAI, Anthropic, Gemini, Bedrock, Fireworks and xAI, speaking an OpenAI-compatible API — so adopting it is a base-URL change, not a rewrite.
Routing & failover
A complexity classifier reads each prompt and picks a tier: trivial work goes to a cheap model, hard reasoning goes to a strong one. The caller never chooses a model — they describe a job.
When a provider errors, times out or rate-limits, an automatic failover chain walks down the tiers and retries against the next one. The client sees one slightly slower success instead of a 500.
Guardrails on both sides
Inbound, every prompt passes a prompt-injection shield before a single token reaches a provider — blocked requests are logged with the rule that caught them.
Outbound, responses run through PII redaction, so a model that echoes an email address or a card number never hands it back to the client.
Observability & operations
Every request emits latency, prompt/completion tokens and a computed dollar cost, streamed to a live SSE dashboard with no polling. An alerting engine watches for cost, latency and error anomalies.
The service is stateless and horizontally scalable on shared Postgres and Redis, and ships as Docker, a Helm chart and Terraform — deployable to any cluster, local or EKS/GKE, with OpenTelemetry traces exportable to Grafana Cloud.
VACS
See what’s eating your Mac
A developer’s Mac quietly accumulates tens of gigabytes that no general-purpose cleaner understands. Xcode DerivedData, the Docker VM disk, Ollama weights, Playwright browsers, pip and Homebrew caches — every one of them looks like the same anonymous folder.
Most cleaners call all of it “junk” and offer one button. That is the wrong abstraction, and occasionally a destructive one.
96 audited paths · 8 categories · 0 network requests
VACS names every folder in plain English and shows the path, the size, the last-modified date and the call. No folder is listed without a reason.
“nvm versions → check first — reinstalling Node takes a while.”
Four safety levels
Safe goes straight to the Trash. Check first confirms with the reason shown, because you’ll pay to rebuild it. Command has no delete button at all — for a live Docker VM it copies docker system prune -a to your clipboard instead. Never is measured and displayed so the total adds up, but no action exists for it.
Reversible by design
Normal cleanup moves items to the macOS Trash, where Put Back works until you empty it. Permanent deletion happens only inside the Trash view, and no step anywhere asks for sudo.
Shipped as a signed release for macOS 14+ on Apple Silicon, MIT licensed, with zero telemetry and a docs site built alongside it.
SAGE
Supervisory Agentic Governance Engine
AESIA × UN Tech Over Hackathon
Coding agents now write files, run shell commands and call APIs on their own. The industry’s answer has mostly been a log you read afterwards. A log is not a control.
Supervision, not audit
SAGE is an open-source governance harness for AI coding agents — Claude Code, Cursor, OpenCode and Cline — that evaluates what an agent is about to do before it happens.
It hooks the Model Context Protocol boundary, which is the one place every tool call has to pass through regardless of which agent is driving. One integration covers all of them.
What it checks
Prompt-risk scoring and security scanners run against each intercepted call, with an EU AI Act compliance path for teams that have to answer to a regulator rather than a retro.
Decisions are written to cryptographic audit logs — so the record can be verified later rather than merely trusted.
Shipped, not slidewared
Built and published inside the hackathon window as sage-governance on npm under MIT — installable the same day it won.
It is also the project I know best from the other side: I use Claude Code daily, and building the supervision layer forced me to be precise about exactly where these tools need a human in the loop.
Hyper–
Orchestrator
Plan · fan out · fuse
Most agent workflows run one step at a time because that is the easy thing to write — even when four of the six steps have nothing to do with each other.
A Planner Agent reads a high-level goal, decomposes it into sub-tasks, and resolves the dependency graph before a single worker starts. What can run together, does.
Adaptive worker pools
Independent branches execute simultaneously with concurrency that adapts to the shape of the DAG, then a fusion pass merges the parallel outputs back into one coherent result.
Every start and finish is streamed in real time — the difference between a system you can operate and one you can only wait on.
Measured against sequential execution
Same goals, same workers, same model — the only variable is the scheduler. The bar on screen shows what sequential execution has managed in the time the parallel run already finished.
Why it’s deliberately small
LangGraph and PydanticAI are frameworks. This is a single file with almost no dependencies, because the point was to understand the primitive — DAG resolution, backpressure, result fusion — rather than wrap someone else’s.
Built for the Zo Computer platform against its /zo/ask API.
Thinker–
Curator
The salience debate
A language model can only see a limited window. As a conversation grows, things fall out of it — and the model does not know which of them mattered.
Existing answers are either reactive (retrieve only once someone asks) or naive (store everything and drown the index in noise). Neither decides what is worth keeping.
Two agents, one argument
A Thinker reads the conversation as it happens and proposes facts it believes are salient. A Curator scores each proposal and decides what is actually admitted to long-term memory.
The disagreement between them is the mechanism, not a bug — it is the debate the paper is named for.
Proactive, not reactive
Because curation happens before the context window fills rather than at query time, retrieval starts from a memory store that has already been filtered for importance.
A RAG pipeline categorises memory streams via vector embeddings, which is where the gain shows up most clearly: multi-hop queries, where the answer requires stitching two separately-stored facts together.
Context
Graduate research at Rutgers, co-authored with Tejaswini Abburi, delivered as a working dual-agent system with training notebooks, benchmarks and an API rather than a paper alone.
Sawit
Saw it for you
Instagram’s Saved folder is a wall of thumbnails. No search, no text, no way to ask “what was that budget split?” six months later. So people share reels to themselves in DMs and end up with a second pile they also can’t query.
Share a reel to Sawit and about a minute later it’s a note: the title, the steps, the numbers and the caveats — searchable.
The part that was actually hard
Most reels never say it out loud. The useful content is text on screen over music, so speech transcription alone comes back empty.
Sawit reads the frames: a 12-image multimodal pass over sampled stills through NVIDIA NIM, combined with faster-whisper when there is audio worth having. The recipe on the screen gets captured either way.
Finding it again
Notes are indexed as 2048-dimension embeddings alongside SQLite FTS5, so a semantic query needs to share zero words with the note it finds — “how should I split my paycheck” returns the 55/5/10/15/15 reel.
Per-account isolation, 143 passing tests, self-hostable, MIT.
Finished, not maintained
It ran end to end and was deployed for a month. Development stopped because the honest answer to “would I open this every day?” was no — Instagram’s own Saved folder is where people already look, and no amount of polish moves a habit that isn’t there.
The code is public because the hard parts — reading text off frames, meaning-based search, per-account isolation and eight production-only bugs — were worth writing down rather than deleting.
Got something hard
to build? Let’s talk.
Open to software, cloud, DevOps, platform and AI engineering roles. Based in the United States and ready to relocate anywhere for the right team. I’m on F-1 OPT with STEM extension eligibility, so I’m looking for employers able to support work authorisation long-term.