<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Meerarn on Medium]]></title>
        <description><![CDATA[Stories by Meerarn on Medium]]></description>
        <link>https://medium.com/@meerarenunair?source=rss-4ce8e063918f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*53qUXBFrF12Fyopi</url>
            <title>Stories by Meerarn on Medium</title>
            <link>https://medium.com/@meerarenunair?source=rss-4ce8e063918f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 08:31:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@meerarenunair/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[I Built a RAG System That Refuses to Answer When It Can’t Prove Its Source]]></title>
            <link>https://medium.com/@meerarenunair/i-built-a-rag-system-that-refuses-to-answer-when-it-cant-prove-its-source-722c2546382f?source=rss-4ce8e063918f------2</link>
            <guid isPermaLink="false">https://medium.com/p/722c2546382f</guid>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[business-analysis]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Meerarn]]></dc:creator>
            <pubDate>Sat, 19 Sep 2026 22:48:29 GMT</pubDate>
            <atom:updated>2026-09-19T22:48:29.495Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>What requirements traceability has to do with the biggest gap in AI governance right now</strong></h3><p>I asked my own AI assistant a simple question: what are the six knowledge areas in the BABOK Guide? It answered instantly, confidently, and in a nicely formatted list. Three of the six names it gave me don’t exist. Not paraphrased wrong, not close-but-off invented outright, the way a student invents a plausible-sounding answer on a test they didn’t study for.</p><p>The system caught it anyway. Not because it “knew” the answer was wrong, it doesn’t have that kind of self-awareness but because I’d built a rule into it: every factual claim has to end with a citation tag pointing at a real source chunk, or the answer gets thrown out before I ever see it. No tag, no answer. That fabricated list of knowledge areas had zero citations anywhere in it, so it got rejected automatically. I only found out it was hallucinated because I went back and read the raw, rejected output out of curiosity.</p><p>That’s the whole reason this project exists, and it’s a more useful story than “I built a chatbot,” so let me back up and explain it properly.</p><h3>What “citation-enforced” actually means, mechanically</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*vR_BuyH2OsdsmcJB7vObkA.gif" /></figure><p>RAG : retrieval-augmented generation is the standard pattern for grounding an LLM in your own documents instead of just its training data. You embed a bunch of text into a vector database, and when someone asks a question, you retrieve the most relevant chunks and stuff them into the model’s prompt before it generates an answer. Most RAG tutorials stop there. The model has the right context in front of it, so presumably it’ll use it, and that’s treated as good enough.</p><p>It isn’t, and anyone who’s actually used one of these systems knows it isn’t. Having the right context in the prompt doesn’t stop a model from ignoring it and answering from its own (possibly wrong, possibly outdated) training data instead. There’s no built-in mechanism that forces the model to actually ground its answer in what you gave it.</p><p>So I added one. Every chunk I retrieve gets tagged with a short id : scrum_guide, rag_wikipedia, whatever right in the context the model sees. The system prompt tells the model, explicitly, that every factual claim has to end with [source_id: &lt;id&gt;] naming the chunk it came from. Then, separately from the model, I run the raw output through a regex looking for that exact tag. If it&#39;s not there, the function returns a rejection status instead of the answer. The model never gets a say in whether its answer is &quot;good enough&quot; to show me that decision happens outside of it, mechanically, every time.</p><p>This sounds almost too simple to be worth writing about, and that’s kind of the point. It’s not a clever prompt trick or a fancy new architecture. It’s a basic engineering pattern generate, then verify, then gate applied to a place most people don’t bother applying it.</p><h3>The eval, and what it actually costs you</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ny89KgVqYzDIxEtRef-1Vw.png" /></figure><p>I built the local stack Ollama for running a small model (llama3.2:3b) and generating embeddings, Qdrant as the vector store, LlamaIndex for chunking and retrieval, Firecrawl for the one-time scrape that builds the knowledge base and pointed it at a corpus of BABOK, Scrum, Postman API testing, and RAG/LLM reference material. Then, before I built any of the citation logic, I wrote ten questions with known-correct sources and expected keywords, and a script that would score any system I built against them honestly. I wanted a number, not an impression.</p><p>Ran the same ten questions through two versions: one with the citation rule enforced, one without.</p><p>The enforced version answered 8 of the 10 questions. Every single one it answered, it could back up with a real, correct source 100% citation precision. The unenforced version answered all 10, fluently, and couldn’t back up a single one. 0%.</p><p>That’s the trade being made here, stated plainly: enforcement costs you some coverage. Two questions came back rejected instead of answered. In exchange, everything that does come through is verifiable, and everything from the unenforced version is not, even when it happens to be right.</p><h3>Two things that went wrong, which taught me more than the parts that worked</h3><p>First: early on, the model kept getting rejected for citations that were actually there, just in the wrong format (source_id: scrum_guide) in parentheses instead of [source_id: scrum_guide] in brackets. My regex was doing exactly what I told it to do; the model just wasn&#39;t reliably following the exact format I&#39;d specified in the prompt. I fixed it by adding one concrete example of the correct format directly in the system prompt, and the failure mode mostly went away. Worth remembering: a 3-billion-parameter local model needs to be shown the format, not just told the rule.</p><p>Second, and more embarrassing: I’d hand-picked a few source URLs for the corpus without checking they actually resolved. Three of them had moved or been removed, and Firecrawl happily scraped their “Page not found” content and returned it as a successful result because technically, it was a successful scrape of <em>a</em> page, just not the page I wanted. My ingestion script only checked whether the scraped text was long enough to be plausible content, and a 404 page has enough boilerplate text to clear that bar. I only caught it because the resulting answers were suspiciously thin. The fix was to also check the actual HTTP status code Firecrawl reports for the target page, not just the text length. This is the kind of bug that’s obvious in hindsight and invisible until you go looking for it.</p><p>Neither of these is a groundbreaking discovery. They’re the ordinary, slightly tedious bugs you find when you actually build and test something instead of describing how it would theoretically work.</p><h3>Why I think this connects to something bigger than a personal project</h3><p>There’s a real, current conversation happening about AI governance; how organizations are supposed to hold AI systems accountable for what they output, especially now that regulation like the EU AI Act is starting to require documented, traceable records of how an AI system produced a given result. IIBA, the organization behind business analysis certification, put out something recently making a point I found genuinely sharp: most AI governance frameworks are being written by lawyers and data scientists, and they don’t speak the language business analysts speak natively acceptance criteria, traceability, requirements that link a stated need to a verifiable output.</p><p>That’s not a coincidence, and it’s not really a new skill BAs need to learn. Traceability <em>is</em> the BA skill. Linking a business requirement to the specific artifact that satisfies it, and being able to show your work when someone asks “how do we know this actually does what it’s supposed to do,” is close to the entire discipline. It’s just aimed at AI systems.</p><p>This project is a small, working version of that idea, not a slide about it. The citation tag is the acceptance criterion. The rejection logic is the enforcement. The eval script is the verification that the enforcement actually does what it claims. None of it required inventing anything new it required applying an old discipline to a new kind of system.</p><h3>If you want to poke at it</h3><p>The whole thing is public: <a href="https://github.com/meerarnr/private-research-assistant">github.com/meerarnr/private-research-assistant</a>. Corpus, eval set, both the enforced and unenforced query paths, and the real results file are all there including the fabricated BABOK answer, still sitting in eval_results.json, rejected exactly the way it was supposed to be.</p><p>If you’re building something similar, the one thing I’d tell you before anything else: write the eval before you write the thing it’s testing. It’s the only part of a project like this that can’t be faked by a good screenshot.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=722c2546382f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everyone’s Building AI Agents. Almost Nobody’s Watching Them After Deployment.]]></title>
            <link>https://medium.com/@meerarenunair/everyones-building-ai-agents-almost-nobody-s-watching-them-after-deployment-e801ad5edf22?source=rss-4ce8e063918f------2</link>
            <guid isPermaLink="false">https://medium.com/p/e801ad5edf22</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[llmops]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Meerarn]]></dc:creator>
            <pubDate>Thu, 11 Jun 2026 04:46:52 GMT</pubDate>
            <atom:updated>2026-06-11T04:46:52.917Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P92MOEK4MjdxhsPrNwByXA.gif" /></figure><p>I spent the last few weeks reading every “build your first AI agent” tutorial I could find. There are a lot of them. Most follow the same recipe: pick a framework, wire up a few tools, give the model a goal, hit run, watch it book a flight or summarize a PDF. Magic.</p><p>Then I went looking for the tutorial that comes next — the one about what happens when that same agent runs ten thousand times a day for six months against real users and real money.</p><p>That one barely exists.</p><p>My background is a bit of a hybrid — a master’s in computer science, a couple of published ML papers, and the last four years as a technical BA. That mix changes what I notice. My first instinct isn’t “how do I build it” — it’s “what does this cost when it goes wrong, and how would I even know it had?” And the more I learned about agents, the more that second question kept me up.</p><p>So let me do both. First, what an agent actually is and roughly how you’d build one. Then the part the tutorials skip.</p><h3>What an AI agent really is</h3><p>Strip away the hype and an AI agent is a language model that’s allowed to <em>do things</em> instead of just talk.</p><p>A normal chatbot takes your question and writes an answer. That’s it. An agent takes a goal, decides what steps it needs, and acts on them — calling tools, hitting APIs, reading files, sometimes calling other agents — looping until it thinks the goal is met.</p><p>Three pieces make it work:</p><p><strong>The model</strong> is the brain. It reasons about what to do next.</p><p><strong>The tools</strong> are the hands. A search function, a database query, a “send email” action, a calculator. The model decides <em>when</em> to reach for each one.</p><p><strong>The loop</strong> is what makes it an agent and not just a fancy prompt. The model acts, sees the result, reasons again, acts again. It keeps going until it’s done or it gives up.</p><p>That loop is the whole trick. It’s also, as you’ll see, the whole problem.</p><h3>How you’d actually build one</h3><p>You don’t write the reasoning yourself. You wire up the scaffolding and let the model think inside it.</p><p>In practice that means picking a framework — LangChain and LangGraph are the common starting points, LlamaIndex if you’re heavy on document retrieval — and doing four things:</p><ol><li>Define the tools the agent is allowed to use, with a clear description of each so the model knows what it’s for.</li><li>Write a system prompt that tells it who it is and what it’s trying to accomplish.</li><li>Connect it to a model and, usually, a vector database so it can pull in your own data instead of relying on whatever the model memorized.</li><li>Set the rules of the loop — how many steps it gets before you cut it off, what counts as “finished.”</li></ol><p>You can get a working prototype running in an afternoon. That’s the genuinely impressive part, and it’s also the trap. A demo that works on your laptop with five test inputs tells you almost nothing about how it behaves at scale.</p><h3>Where it falls apart</h3><p>Here’s the thing nobody puts in the quickstart guide. An agent in production is a non-deterministic system making multi-step decisions on inputs you’ve never seen, spending money on every step. Of course it breaks. The question is whether you find out before or after a customer does.</p><p>A few of the ways it goes sideways:</p><p><strong>The cost spiral.</strong> Every step in that reasoning loop is an API call, and every call costs tokens. A normal request might be three steps. But give the agent a confusing input and it can loop fifteen times trying to figure itself out, each loop billing you. Multiply one runaway agent by your daily traffic and you’ve got a cloud bill that doesn’t match anyone’s forecast. I’ve read about teams who didn’t catch this until the invoice landed.</p><p><strong>The confident wrong answer.</strong> The model hallucinates a fact, then uses that fake fact as the input to its next step, which feeds the one after that. By the end it’s produced a beautifully formatted, completely fabricated result — and it’s just as confident as when it’s right. There’s no error log. Nothing crashed. It just lied, fluently.</p><p><strong>The silent decay.</strong> Your agent works great in March. By July it’s noticeably worse, and nobody changed the code. The world drifted — your data shifted, the model provider quietly updated something, user behavior moved. Without a baseline you measured against in March, you can’t even prove it got worse. You just feel it.</p><p><strong>The leak.</strong> An agent with database access and a chatty disposition is one badly phrased prompt away from putting a customer’s personal information somewhere it should never be. That’s not a bug ticket. Depending on where you operate, that’s a compliance problem with a number attached.</p><p>None of these throw an exception. That’s what makes them dangerous. Traditional monitoring is built to catch the app falling over. These failures happen while everything is technically running fine.</p><h3>What you actually watch instead</h3><p>This is where AI observability comes in, and where my reading went from interesting to genuinely useful.</p><p>The shift is from “is it up and fast” to “is it <em>right</em>, <em>safe</em>, and <em>affordable</em>.” A few of the things you’d put eyes on:</p><p><strong>Traces of the whole loop.</strong> You want to see every step the agent took — what it reasoned, which tool it called, what came back — not just the final answer. When something goes wrong, the answer rarely tells you why. The trace does. Tools like LangSmith are built around exactly this: making the agent’s invisible decision chain visible.</p><p><strong>Token spend per request, per feature, per user.</strong> Not at the end of the month. Now, with an alarm when a single request burns far more than it should.</p><p><strong>Evals on the output.</strong> Automated checks on whether the answer was actually grounded in real data, whether it stayed relevant, whether it’s coherent. Platforms like Arize AI focus heavily on this — scoring quality continuously instead of waiting for a human to notice.</p><p><strong>Guardrails for the dangerous stuff.</strong> Automatic detection of PII in outputs, toxicity, and jailbreak attempts, so the leak gets caught at the door instead of in the headlines.</p><p><strong>Drift baselines.</strong> A snapshot of how the agent performed when it was healthy, so “it feels worse” becomes “accuracy dropped 12% since launch” — a number you can act on.</p><h3>Why a business analyst cares about any of this</h3><p>Because every one of those failures is a line item.</p><p>The cost spiral is margin. The confident wrong answer is a refund, a churned customer, or a support ticket. The silent decay is a product slowly getting worse while the roadmap assumes it’s fine. The leak is legal exposure.</p><p>Shipping an AI agent with no observability is like launching a product with no QA, no analytics, and no way to read the reviews. You’d never sign off on that for normal software. Somehow, with AI, teams keep doing exactly that — dazzled by the demo, blind to the operations.</p><p>The companies that win with this technology won’t be the ones who deploy agents the fastest. Plenty of people can deploy fast. They’ll be the ones who can tell, at any moment, whether their agent is working — and prove it with a number.</p><p>That gap between “we built it” and “we can actually watch it” is the whole reason I’m moving into this field. It’s a business problem wearing a technical costume, which happens to be exactly the kind of problem I like.</p><p><em>I’m documenting my move from technical BA into AI observability as I go — the tools, the concepts, the things that surprised me. More at </em><a href="https://www.meerarn.com/"><em>meerarn.com</em></a><em>. If you’re building agents in production or working on monitoring them, I’d like to compare notes.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e801ad5edf22" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>