About a year ago, I moved from pure backend and distributed-systems work into building agentic AI systems for real, in production, at work. Somewhere in that year I also started noticing something odd. Several genuinely strong engineers around me, people who could design a real distributed system without blinking, were struggling to get even a basic AI agent working. Not because the underlying systems concepts were unfamiliar to them. Because most tutorials were teaching frameworks, not engineering.
That gap is the reason this series exists.
What I actually built
The work I do at my job isn't mine to publish, and it shouldn't be. So I built a parallel version from scratch, on my own time, under a harder constraint than most real teams ever get: an actual zero budget, not a discounted one. No team, no production traffic, no infrastructure budget, and no Claude Code or Codex either. The whole thing runs on Antigravity and the free tier of the Gemini API. If something didn't work under those limits, the job was to understand why, not throw more compute at it until it did.
It's a multi-agent, RAG-based knowledge system, and it starts small. Parse a document, chunk it, embed it, search it. Nothing that hasn't been done in a hundred tutorials. Where it stops looking like a tutorial is a few stages in, once the system has to route between specialized agents, hold memory across sessions, expose its tools through a real protocol server, and survive the kind of failure modes that only show up once you stop trusting the model's output by default.
The series I wish existed
Before I started building sentinel-agent, I looked up for existing content that could help build a solid, enterprise-grade understanding without overwhelming me with research papers or ML theory. Most content trying to teach this falls into three buckets. Either it's a weekend demo dressed up as a production system, or it's theory with no working code behind it, or, on the rare occasion it's actually good, it's priced like a bootcamp. None of these teach you the thing that actually matters, and the expensive ones share the same core flaw as the free ones: they hand you a finished implementation instead of the reasoning that produced it.
That reasoning matters more than usual here because the ground keeps moving. The library you lean on this month has a real chance of being deprecated or redesigned by next year. I've already watched it happen more than once inside this project. Learning to wire up one specific agent framework teaches you that framework. It doesn't teach you what to do the day it changes underneath you, and in this field, it will.
This was always a systems problem
Strip away the model and the framework of the month, and what's actually sitting underneath an agentic AI system is a distributed system. It needs to scale, stay secure, stay extensible as requirements shift, and degrade gracefully instead of falling over the first time something goes wrong. Anyone who's spent real years building and operating distributed systems already carries instincts for exactly these constraints. What's usually missing isn't the thinking. It's mapping that thinking onto a domain that happens to have a language model sitting inside it instead of a database.
That's also why I think experienced engineers with a few years of production scars often adapt to this space faster than people expect. Agentic AI isn't conceptually more advanced than what came before it. Reasoning under real constraints, financial, infrastructural, and complexity alike, is its own skill, and it's usually built by living through real systems, not by reading about them.
Search engines existed for decades before any of this. Anyone could type into a search box. The actual skill was never in knowing how to search, it was in knowing what to search for. That's almost exactly what's changed, and hasn't changed, with tools like ChatGPT and Claude showing up. My years as an engineer had already taught me what to solve for, the same handful of properties I mentioned above. What I actually had to learn was how to get those same properties out of a system built around an LLM instead of a REST endpoint.
That's what this series actually is. Not a tutorial on one framework that'll need a rewrite in a year. A record of applying the same engineering discipline I'd trust with any production system to this one, and being honest about everywhere it broke along the way. Some things broke here that I didn't see coming. A concurrency library quietly ignored a rate limit I was sure I'd set correctly, and it only surfaced once real data volume hit it. A hardcoded number, three, silently truncated a user's memory with no error at all, the kind of bug you only catch when you go looking for something that should be there and isn't. A cleanup routine closed a network connection out from under a response that was still streaming, because nothing in the code was holding a reference to it anymore.
None of these are exotic. They're the same category of bug you'd find in any distributed system, race conditions, silent failures, a resource cleaned up before its job was done. The only thing that changed is the layer they happened in.
What to expect from this series
This won't be a straight walkthrough from step one to the last milestone. Some posts will explain a concept the way I wish someone had explained it to an engineer with a systems background instead of a machine learning one. Others will read closer to an incident writeup: here's what broke, here's how I found it, here's what actually fixed it, and here's why the obvious fix wouldn't have.
I'm not writing this to hand you a stack to go copy. Whatever's popular a year from now will look different from what's in this repo today, and that's fine, that was never the point. If you're coming from real engineering and want to build the kind of judgment that survives a framework migration instead of just a working demo, that's who this is for.
The full project, code included, lives on GitHub. Link's below, and I'll keep it updated as the series goes.
armanavasthi
/
sentinel-agent
Production-grade agentic RAG system built from scratch. LangGraph multi-agent orchestration, MCP, enterprise middleware, and RAGAS evaluation, with real production bugs diagnosed and fixed along the way.
sentinel-agent
Applied AI & Agentic RAG From Scratch: A Production-Grade LangGraph, MCP & Multi-Agent Tutorial
Welcome to a comprehensive, hands-on applied AI tutorial and repository. We are building enterprise-grade agentic AI systems, not toy demos. If you've searched for a LangGraph tutorial, a Model Context Protocol (MCP) walkthrough, a multi-agent orchestration example, or a production RAG pipeline in Python, this repo builds all of it, from a single-file RAG script up to a distributed, secured, multi-tenant agent platform.
Built with: LangGraph · ChromaDB · Model Context Protocol (MCP) · Langfuse · RAGAS · Gemini API
Table of Contents
- What You Will Build
- Learning Path & Roadmap
- Who This Is For
- Study Guides, Glossaries & Notes
- Exercises, Quizzes, and Runbooks
- Repository Structure
- Environment Setup
- Awesome AI Resources
- Contributions Welcome
What You Will Build (Projects)
Instead of just reading theory, you build a complete, production-grade knowledge base…
Top comments (0)