Engineering AI Agents for Real-World Action
I build autonomous multi agentic systems. I take the product from 0 -> 1.
[ About Me ]
I build systems that know when to ask, decide, and hand over.
As a kid, I was addicted to mobile phones, remote control cars, and video games. I used to wonder how they worked. How does an app open when you tap it? How does a phone sense your touch? How do games get built to look and feel the way they do? Eventually I learned that programming is what powers all of it, every mobile and every computer. That's what pulled me in.
At matriculation level, I had to choose between Computer Science and Biology. Almost everyone around me pushed me toward biology. I picked computer science anyway, because I already loved it and I was amazed by what the field could do. What really got me was realizing that almost every piece of software people use every day is built through computer science.
I started in web development, building with HTML, CSS, JavaScript, React, Next.js, and Node.js. That work took me through cloud computing before a mentor pointed me toward a bigger shift: agentic AI was becoming the next real wave, not just another framework to learn.
I'm based in Pakistan, and I learn by building, not by watching. My early projects were tutorial-driven, and when a mentor told me straight that my portfolio lacked original work, I dropped them and started over from blank repositories instead. That's still how I work: build a rough version, trace where it breaks, fix the weakest part, and repeat, rather than following a course from start to finish.
My focus now is genuine dynamic agents: systems where an LLM decides what to do at runtime instead of following a fixed pipeline. That means real guardrails, evals, human approval steps before anything ships, and memory that persists across runs, not just chatbots that answer one question at a time.
[ Projects ]
Projects I'm proud of
Autonomous agents, RAG systems, and speech intelligence built with rigorous error handling and production guardrails.
[ Process ]
How I Architect
Diagnose
Find the actual failure mode before touching code. On Lumen, extraction failures looked like an input-size problem, but the real cause was an unset max_tokens default silently truncating output.
Build the rough loop
Get the smallest version running end to end first. Lumen started as a two-node skeleton deployed from a blank repo, SentryLoop's investigation logic started as a plain while-loop before becoming a LangGraph StateGraph, once I knew what actually needed to survive.
Guard the boundaries
Every autonomous action gets a hard limit, enforced at more than one layer. SentryLoop's propose-only rule lives in a database constraint, not just a prompt. CogniLead's human-review gate is fully deterministic, never left to the model's judgment.
Engineer the context
What the model sees matters more than how much. SentryLoop rewrites a bounded summary each step instead of replaying a growing log. Lumen fixed a hardcoded thread ID that was silently mixing state between unrelated runs.
Design for failure, not just success
Every path has to end somewhere defined, never a silent crash. CogniLead's write-back checks exactly which step succeeded before retrying, so a failed run resumes correctly instead of duplicating work or restarting from zero.
Validate against reality
Test against real, already-documented bugs, not invented ones. SentryLoop's evals ran on real bugs already logged in Lumen's history, so a correct diagnosis is a real signal, not a convenient one.
[ Now ]
What I'm building now
> Currently building: Triax Agent — Multi-tenant AI agent that triages support tickets, retrieves answers from each company's own knowledge base, and drafts customer-ready resolutions, holding low-confidence responses for human approval instead of auto-sending them. Built with LangGraph for multi-agent orchestration, Postgres with pgvector for tenant-isolated retrieval, and an eval harness that grades draft quality against real resolved tickets, it's designed to show production-grade agentic AI: tool calling, human-in-the-loop review, observability, and per-tenant data isolation
[ Stack ]




