Ahmad Imran Picture

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.

SentryLoop — Autonomous Incident Investigation Agent

An autonomous agent that investigates production incidents and drafts fix proposals

LangGraphFastAPIPostgres + pgvectorNeonLangfuseVercel
thumbnail
CogniLead — Inbound Lead Qualification & CRM Enrichment Agent

Qualifies inbound leads and enriches CRM records automatically, without manual review

LangGraphFastAPIHubSpot APITavilyPostgresVercel
thumbnail
Lumen — Multi-Node Research Agent

A multi-node LangGraph pipeline that researches, cross-checks sources, and writes reports

LangGraphFastAPIPostgresRailway
thumbnail
Captur — AI Meeting Transcriptor Tool

Turns raw meeting recordings into structured, organized minutes automatically

LangChainFastAPIGroqReact / ViteRailwayVercel
thumbnail
AskMyDocs — RAG Q/A System

Answers questions directly from your documents using retrieval-augmented generation

FAISSHuggingFace embeddingsGroqHuggingFace Spaces
thumbnail

[ Process ]

How I Architect

01

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.

02

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.

03

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.

04

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.

05

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.

06

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

$live_agent_status.sh — zsh

> 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 ]

Core Technologies

LangGraph icon
LangGraph
FastAPI icon
FastAPI
Python icon
Python
Postgres icon
Postgres
pgvector icon
pgvector
Neon icon
Neon
Langfuse icon
Langfuse
LiveKit icon
LiveKit
Groq icon
Groq
React icon
React
Vite icon
Vite