Muzammil Ayaz Kabeer
Full Stack & Applied AI Engineer based in Chennai
I build engines that decide. What a student should practice next. Whether a generated question is actually new. How a piece of code was logically constructed.
Six years of shipping production AI systems and backend services, mostly 0 to 1: taking a rough product idea to something real users rely on every day.
Explore My Work ↓LSRW Language Lab
A CEFR-aligned assessment engine handling hundreds of student sessions daily. I built the adaptive autopilot, and fixed a generator that had started repeating itself by giving it a memory of its own output.
1. The Adaptive Autopilot
Averaging skill scores lets a strong reader hide a weak speaker. So reading, listening, writing and speaking each clear an independent threshold, and promotion waits on consistency across a rolling five-to-seven session window. Session length escalates on a separate loop, so students neither sprint past their level nor stall inside it.
Run a few sessions. The weakest skill decides every move.
2. “Negative RAG”
An LLM with no record of what it has already produced starts circling: different words, same ideas. Every output stays technically valid, which is why a basic uniqueness check never catches it. That is not a prompting problem, it is a missing memory layer.
So every accepted question is embedded and stored, and each new candidate is checked against the whole history. Anything at or above cosine 0.85 is rejected and pushed into LangGraph state as negative context for the next attempt. Three consecutive rejections trigger a density check, and a saturated topic gets abandoned outright.
3. IELTS Bundling
Practice arrives as 24-question IELTS bundles pinned to a single CEFR level: 12 reading, 10 listening, one writing task and one speaking cue card. An LCG-based distribution keeps delivery non-repeating without storing a per-student shuffle. Content generation and autopilot selection stay fully separate, so either can change without breaking the other.
4. Speech & Scoring
Listening audio comes from Azure AI Speech, with speech rate tiered by CEFR level. Spoken answers are transcribed by AssemblyAI. Scoring escalates only as far as it needs to: rule-based keys first, BERT similarity next, and LLM rubric grading for what is left.
NeoEval
Test-case pass or fail tells you whether code works, not whether the student understood the problem. That signal thinned noticeably once students started coding with AI, and manual review does not scale past a few hundred submissions. So I built a classifier that grades the shape of the attempt.
Persona Classification
Submissions sort into four auditable bands. The classifier returns a strict schema rather than prose, covering approach, execution and confidence, so any judgement can be inspected and argued with. Low-confidence cases route to a human instead of publishing quietly.
Evaluated with deepeval against a synthetic C++ dataset built with deliberate persona-subtype variation, to find where the band boundaries blur before real students did. Later extended to SQL and JDBC with repair-effort scoring.
Phase two moves upstream of the code entirely: typing dynamics become features for gradient-boosted models that separate original work from copied. Behaviour is considerably harder to fake than a final answer.
{
"is_genuine_attempt": true,
"approach": "correct",
"execution": "minor_errors",
"why": "off-by-one on the upper bound",
"confidence": 0.86
}
Personal Brain (Graph RAG)
Outside production systems, I have been building a personal knowledge base that retrieves over a graph rather than a flat vector index. Vector proximity finds passages that sound alike; a graph can answer why two things are connected.
Built on LangGraph workflows with Model Context Protocol servers, mapping relationships between concepts so retrieval can traverse them instead of ranking them.
Experience & Stack
Backend & Orchestration
FastAPI, Node.js, LangGraph, AutoGen/AG2, Celery, TaskIQ, Redis
Data & Infrastructure
AWS (ECS, Fargate, ALB), Terraform, PostgreSQL, pgvector, Docker
Evaluation & ML
deepeval, DSPy, LangFuse, Phoenix, LightGBM, XGBoost
2024 – Present
Senior Software Engineer, AI @ iamneo
LSRW and NeoEval, above. Also an agent-orchestrated AI Copilot with intent-based routing across specialist agents, and a token-metered usage system with wallet management, real-time deduction and role-based access across thousands of exam sessions. The Copilot ships in beginner and expert modes, with Socratic prompting for beginners. Runs on AWS ECS/Fargate behind an ALB, provisioned with Terraform, with PostgreSQL on RDS and TaskIQ workers.
2021 – 2024
Full Stack Developer @ VisAI Labs
An Electron and Node.js desktop application for high-precision 3D object dimensioning, deployed across manufacturing sites. Bridged C++ measurement modules into Node through node-addon-api for sub-millisecond hardware communication, and moved measurement data off distributed machines over RabbitMQ, cutting reporting lag by roughly 60%. Docker-based microservices on the edge devices handled automated backups and over-the-air updates to the machines.
2020 – 2021
Programmer Analyst Trainee @ Cognizant
Enterprise database applications, and a first look at how large systems are actually maintained.
2020
B.Tech, Mechatronics — SRM Institute of Science and Technology
79%. Reasonable preparation for systems that have to survive the physical world.
Let's Talk
Happy to discuss assessment engines, agent orchestration, or why your generator keeps repeating itself.