<?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 Rajesh Naga Nekkanti on Medium]]></title>
        <description><![CDATA[Stories by Rajesh Naga Nekkanti on Medium]]></description>
        <link>https://medium.com/@nnrajesh3006?source=rss-849514a33289------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*2zx_DbyBNTnZe1-m</url>
            <title>Stories by Rajesh Naga Nekkanti on Medium</title>
            <link>https://medium.com/@nnrajesh3006?source=rss-849514a33289------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:35:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nnrajesh3006/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[“Context” Is All You Need: Inside the Six Operations]]></title>
            <link>https://medium.com/@nnrajesh3006/context-is-all-you-need-inside-the-six-operations-ebb6c25aa8d3?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebb6c25aa8d3</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[context-engineering]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 09:40:49 GMT</pubDate>
            <atom:updated>2026-02-25T09:40:49.307Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Three sophistication levels. What each operation actually looks like.</em></p><p>Series: <a href="https://medium.com/@nnrajesh3006/context-is-all-you-need-4d9e43fe2d22">Context Is All You Need</a> · Article 2 of 4</p><p>Imagine this: your AI system retrieves exactly the right document. The data is there. The intent is clear. The model generates a confident answer — and it is wrong. Not randomly wrong. Wrong in a specific, reproducible way that makes you wonder if you built something broken at its core.</p><p>You debug the model. You swap the prompt. You upgrade the RAG pipeline. Nothing changes.</p><p>The real problem? One of six operations was running at the wrong sophistication level. The system had the right information and no idea what it meant.</p><p>This article is your guide to those six operations — and the skill that matters most when designing an AI system: knowing at which level to run each one.</p><h3><strong>The Three Levels: A Shared Language</strong></h3><p>Before we go inside each operation, you need a single mental model that applies to all six. Every operation runs at one of three sophistication levels. These are not product tiers. They are design choices — and matching the right level to the right problem is the discipline this article builds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9BkRgDqdUfIuPP2UVEkw8Q.png" /></figure><blockquote><strong>The principle in one sentence: </strong>Autonomous is not better than Foundational — it is more complex, more costly, and introduces new failure modes. Choose the level that matches your problem’s volatility, not the level that sounds most impressive.</blockquote><h3><strong>The Six Operations: How They Fit Together</strong></h3><p>Every AI framework you’ve heard of — RAG, agents, fine-tuning, memory systems, guardrails — is a strategy for orchestrating some combination of six context operations. Each one asks a different design question. Each one can fail in a distinct, diagnosable way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RkANhi7Ib2Wn16EvTlgezQ.png" /></figure><p>Notice the curved arrow from WRITE back into SELECT and PERSIST. That’s the evaluation loop: the output the system generates becomes context for future decisions. WRITE is the only operation that creates new information — which makes it the only operation where hallucination originates.</p><p><strong>Five Principles to Hold While You Read</strong></p><p>These are not abstract values. They are diagnostic tools. Read them now, then test each one against the operations that follow.</p><ol><li><strong>Every operation runs at a level — choose deliberately. </strong>Netflix runs PERSIST at Advanced — personalized recommendation models built from structured viewing history — not Autonomous, because their recommendation domain is stable enough. That’s not a limitation. That’s deliberate design.</li><li><strong>The chain is only as strong as its weakest operation. </strong>Most teams invest heavily in SELECT — they build RAG pipelines — while leaving FORMAT at zero. The model retrieves the right information and still misinterprets it because nobody defined what “revenue” means in their company. Upgrading the model fixes nothing. The SELECT investment underperforms not because retrieval failed, but because FORMAT was never built.</li><li><strong>WRITE is the only operation that creates. </strong>SELECT finds. COMPRESS distills. FORMAT structures. ISOLATE scopes. PERSIST stores. Only WRITE generates information that didn’t exist before. In context-engineered systems, hallucination is primarily a WRITE problem — the generation step produced content not grounded in what was retrieved. This is the category of hallucination you can engineer against.</li><li><strong>Autonomous is different, not better. </strong>Moving an operation to Autonomous adds cost, complexity, and new failure modes. A stable, predictable domain rarely benefits from Autonomous operations. A high-volatility, high-stakes domain — real-time trading, medical decision support — might. The upgrade cost must justify the problem complexity.</li><li><strong>Composition order is a design decision, not a fixed rule. </strong>SELECT before COMPRESS before FORMAT is common — but some architectures open with FORMAT first to establish what business terms mean before anything is retrieved. The right order matches your information flow; it isn’t a universal template.</li></ol><h3><strong>The Six Operations, Inside Out</strong></h3><p>Each operation below follows the same structure: what it does at each level, what a real system looks like at each level, what breaks when the level doesn’t match the problem, and the tradeoff you’re always navigating.</p><ol><li><strong>SELECT — Acquiring the Right Context</strong></li></ol><blockquote><em>Design question: What information does the system need, and how does it find it?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3GCTDWcS3H-iUCQQ9IRm7g.png" /></figure><p>At its simplest, SELECT is keyword search — the system finds pages containing your exact words. At its most capable, a SELECT operation decides on its own which files to read, runs multiple searches, and iterates until it has enough context to act. You never specify what to retrieve.</p><p><strong>When it breaks: </strong>You ask a customer service chatbot a question and get an answer about something vaguely related but not quite right. It found something. It found the wrong something.</p><p><strong>Key tradeoff: </strong>Semantic search finds things keyword search misses — but it can also return plausible-sounding-but-wrong results. GraphRAG (Microsoft) requires a pre-built knowledge graph and adds relational reasoning on top of retrieval — that makes it a distinct architectural tier above Hybrid RAG, not a synonym for it. Don’t move to Autonomous SELECT unless your problem actually requires the system to decide when and whether to retrieve. Most don’t.</p><p><strong>2. COMPRESS — Distilling Context to Signal</strong></p><blockquote><em>Design question: How much information is too much — and what do you keep?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ynMXB6AtyG5tiO2Qig40YA.png" /></figure><p>Gmail groups all replies into one thread and shows the newest message first. That’s COMPRESS at Foundational — keep the most recent, collapse the rest. At Advanced, LangChain’s ConversationSummaryMemory automatically calls an LLM to summarize older turns and replaces raw history with that summary, preserving meaning without preserving length. At Autonomous, Letta acts like an operating system managing RAM — the agent autonomously decides what to keep in active context, what to compress and archive, and when to retrieve archived context based on task relevance. No human specifies what to drop.</p><p><strong>When it breaks: </strong>You paste a 50-page document into an AI tool and ask a question. The AI gives an answer that ignores the key passage on page 34. It didn’t fail to read it — it failed to weight it. The signal was buried.</p><p><strong>Key tradeoff: </strong>Every compression loses something. Pre-set sliding windows are cheap and fast but rigid — they drop old context even when it’s relevant. LLM summarization is flexible but adds cost and latency. The most underused technique: intentional token budgeting — deciding explicitly how much context space each source gets before the query runs, rather than letting the window fill and hoping for the best.</p><p><strong>3. FORMAT — Structuring Context for Consumption</strong></p><blockquote><em>Design question: Will the model understand what this information means — not just what it says?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DIN1ihvUd8atlPhO_7ahFQ.png" /></figure><p>Telling ChatGPT “You are a customer service expert. Be friendly.” is FORMAT at Foundational — you’re giving the model instructions on how to behave. Airbnb’s Minerva is FORMAT at Advanced: before Minerva, different teams computed “nights booked” with slightly different SQL and got different numbers from the same data. Minerva created a single governed definition of every metric. Now every analyst, dashboard, and AI query draws from the same definition. At Autonomous, Palantir AIP reads the Foundry Ontology — a governed layer of named business objects, their properties, and their relationships. AI agents query the Ontology rather than raw tables. FORMAT is pre-encoded, not prompted.</p><p><strong>When it breaks: </strong>The AI retrieves the right data. It generates a confident answer. The answer uses the word “revenue” — but it means what your company calls “bookings.” Nobody told it the difference. This isn’t a hallucination. It’s a FORMAT failure.</p><p><strong>Key tradeoff: </strong>FORMAT is infrastructure, not prompt engineering. A system prompt that says “be helpful” is FORMAT at Foundational. A governed semantic layer that defines every KPI in your organization is FORMAT at Advanced. The gap between them is the difference between an AI that sounds right and one that is right. Most enterprise AI projects fail here — and the reason isn’t technical. Building the FORMAT layer requires business stakeholders to agree on what terms mean before engineering can encode them. “Active user,” “revenue,” “churn” — these are organizational debates, not configuration tasks. The engineering takes days. The alignment takes months. That’s why it doesn’t get built.</p><p><strong>4. ISOLATE — Scoping Context to Prevent Pollution</strong></p><blockquote><em>Design question: Who sees what — and what must stay out?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V1v8IYyJs6z8ukTdx2oFXw.png" /></figure><p>Gmail showing only your emails is ISOLATE at Foundational — basic identity-based filtering. Slack channels are ISOLATE at Advanced: a Slack AI bot can only read channels it has access to; it can’t combine what it learns in #engineering with what it says in #sales. At Autonomous, AWS Bedrock Guardrails defines what topics, content, and data sources an AI agent is allowed to touch — and enforces those rules automatically at inference time. The agent is blocked from out-of-scope context even if that context would help it answer better.</p><p><strong>When it breaks: </strong>You ask a company’s AI assistant about the sales pipeline. It gives you an answer that’s slightly wrong — wrong in a way that makes you wonder if it pulled in someone else’s data. Not a hack, not a breach — just context pollution. The AI saw something it shouldn’t have, and you never knew.</p><p><strong>Key tradeoff: </strong>Too much isolation and the system misses cross-domain insight — a customer success agent that can’t see pricing can’t answer questions that require both. Too little and you get context pollution, compliance risk, and AI that surfaces data it shouldn’t. In multi-agent systems, treat context boundaries like API contracts: explicit, enforced, versioned.</p><p><strong>5. PERSIST — Storing Context Across Time and Steps</strong></p><blockquote><em>Design question: What should the system remember — and what should it be allowed to forget?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*397I0W3GySe3T06xGg14sg.png" /></figure><p>Netflix remembering your watch history is PERSIST at Foundational — every show you’ve watched stored, no cross-session learning beyond that catalog. At Advanced, vector databases like Milvus or pgvector store facts, preferences, and past interactions semantically — meaning the system can retrieve relevant memories by meaning, not just exact match. At Autonomous, ChatGPT Memory is the clearest example: the model autonomously decides what to save from a conversation without user instruction, persisting those facts across all future sessions. You don’t manage the memory — the system does.</p><p><strong>When it breaks: </strong>You spend 20 minutes explaining your project’s constraints to an AI assistant. Next session: it has no memory of any of it. You start over. The system isn’t broken — it’s just running PERSIST at Foundational for a problem that needs Advanced.</p><p><strong>Key tradeoff: </strong>More persistence creates more privacy and compliance surface. A system that remembers everything creates a record that can be audited, subpoenaed, or breached. Fine-tuning is the extreme end of PERSIST — it bakes context permanently into model weights, giving you zero flexibility but maximum recall efficiency. Match the memory type to the use case: some problems compound value over time; others should start fresh every session.</p><p><strong>6. WRITE — Generating New Context</strong></p><blockquote><em>Design question: What does the system create — and what keeps it grounded?</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iCE0h5vt-0sF1P7B1JXo6Q.png" /></figure><p>Template-based generation is WRITE at Foundational — fixed patterns, simple outputs, no intermediate reasoning. At Advanced, Chain-of-Thought prompting (Wei et al., 2022) has the model reason step-by-step before generating, dramatically improving output quality for complex tasks. At Autonomous, frameworks like CrewAI (44,400+ GitHub stars, 100,000+ certified developers) and LangGraph (trusted in production by Klarna, Replit, Elastic) coordinate multiple agents that each contribute to a final output — self-correcting, grounded generation across multiple reasoning steps.</p><p><strong>When it breaks: </strong>An AI gives you a confident, detailed, well-formatted answer that contains a fact that simply isn’t true. Nobody told it to lie. It extrapolated — and WRITE had no grounding mechanism to catch the fabrication.</p><p><strong>Key tradeoff:️ </strong>WRITE is the only operation that creates information that didn’t exist before — which is both its power and its danger. Every other operation transforms what already exists. The goal at every level is grounding: keeping WRITE tethered to what was actually retrieved and formatted. That’s why the evaluation loop (WRITE feeding back into SELECT and PERSIST) exists — to catch and correct what fabrication looks like before it compounds. In practice, three controls make this concrete: grounding checks (verify that every claim in the output maps to a retrieved source), faithfulness scoring (tools like RAGAS, DeepEval, and TruLens measure whether the output is supported by context — treat these scores as feedback signals for the next context cycle, not as a QA checkbox after the fact), and human review at high-stakes junctions (the Autonomous level does not eliminate human oversight; it changes where that oversight is applied). Build these controls before you scale WRITE to Autonomous.</p><h3><strong>Six Design Questions — Answer These Before You Build</strong></h3><p>The most common mismatch: teams invest in SELECT (they build RAG) while leaving FORMAT at zero. Answer all six questions before investing in any one operation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gi3wAYgslcjMpcv-3NwMMw.png" /></figure><p><strong>Fix the Operation, Not the Model</strong></p><p>Most AI debugging sessions start with the model. Wrong model, wrong prompt, wrong stack.</p><p>Start somewhere else: identify which of the six operations is running at a sophistication level your problem has outgrown. That’s almost always where the system is actually breaking. Fix the operation before you blame the model.</p><blockquote><strong>The takeaway: </strong>The models are converging. The context is diverging. You now have a vocabulary for exactly where that divergence happens — and how to engineer it.</blockquote><p>Article 3 takes these six design questions and applies them to three real enterprise problems — anomaly detection, self-service analytics, proactive intelligence — showing what the answers look like when composed into a working architecture.</p><p>Article 4 asks a different kind of question: not “what should I build?” but “where is my organization today, and what’s the path forward?” The Context Maturity Model maps every operation against four organizational maturity levels.</p><h3><strong>Companion Resource: Methodology Reference</strong></h3><p>The six operations in this article each have a full methodology map — matching every level (Foundational, Advanced, Autonomous) to the specific frameworks, tools, and techniques practitioners use in production.</p><p>That reference — covering SELECT, COMPRESS, FORMAT, ISOLATE, PERSIST, and WRITE with GitHub star counts, paper citations, and tool comparisons current as of February 2026 — is published as a separate companion document to keep this article in its intended register.</p><p><strong>→ </strong><a href="https://medium.com/@nnrajesh3006/companion-resource-methodology-reference-9ed38da32cb8"><strong>See the Methodology Reference companion document.</strong></a></p><p><em>Rajesh Nekkanti is a data and analytics leader with 12+ years building enterprise data platforms, semantic layers, and agentic AI systems. He writes about context engineering at the intersection of traditional analytics and AI.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebb6c25aa8d3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Companion Resource: Methodology Reference]]></title>
            <link>https://medium.com/@nnrajesh3006/companion-resource-methodology-reference-9ed38da32cb8?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ed38da32cb8</guid>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 08:29:16 GMT</pubDate>
            <atom:updated>2026-02-25T08:29:16.706Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJjbCMWNGnRGevdc206JVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x97vF7HZCq1hzOZuC_b0Fw.png" /></figure><h3>References</h3><p>[¹]: Cursor Agent reads and searches the codebase autonomously, deciding which files to access based on the user’s task description. Cursor Agent documentation: <a href="https://docs.cursor.com/agent">https://docs.cursor.com/agent</a>. Claude Code operates on the same principle — Anthropic Engineering, “Effective Context Engineering for AI Agents,” 2025: <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents</a></p><p>[²]: LangChain ConversationSummaryMemory automatically summarizes conversation history when it grows beyond the token limit, replacing raw history with an LLM-generated summary. Note: ChatGPT’s standard product silently truncates older turns (sliding window) — it does not LLM-summarize them. LangChain documentation: <a href="https://python.langchain.com/docs/">https://python.langchain.com/docs/</a></p><p>[³]: Letta (formerly MemGPT): Packer, C., et al., “MemGPT: Towards LLMs as Operating Systems,” arXiv:2310.08560, 2023. <a href="https://arxiv.org/abs/2310.08560">https://arxiv.org/abs/2310.08560</a>. GitHub: <a href="https://github.com/letta-ai/letta">https://github.com/letta-ai/letta</a>. Actively maintained as of February 2026 (Context Repositories Feb 2026, Conversations API Jan 2026, Letta Code Dec 2025). On the MemGPT → Letta rename: <a href="https://www.letta.com/blog/memgpt-and-letta">https://www.letta.com/blog/memgpt-and-letta</a></p><p>[⁴]: Airbnb Engineering, “How Airbnb Achieved Metric Consistency at Scale with Minerva,” Medium Engineering Blog, 2021. <a href="https://medium.com/airbnb-engineering/how-airbnb-achieved-metric-consistency-at-scale-f23cc53dea70">https://medium.com/airbnb-engineering/how-airbnb-achieved-metric-consistency-at-scale-f23cc53dea70</a></p><p>[⁵]: Palantir Foundry Ontology — the business object layer that defines named entities, their properties, and their relationships for AI agents to query directly, rather than querying raw tables. Palantir AIP: <a href="https://www.palantir.com/platforms/aip/">https://www.palantir.com/platforms/aip/</a>; Palantir Foundry: <a href="https://www.palantir.com/platforms/foundry/">https://www.palantir.com/platforms/foundry/</a></p><p>[⁶]: Model Context Protocol (MCP): Anthropic, November 2024 launch. Donated to the Agentic AI Foundation (Linux Foundation), December 9, 2025. As of early 2026: 10,000+ active public MCP servers; 97M+ monthly SDK downloads; adopted by ChatGPT (March 2025), Cursor, Gemini, Microsoft Copilot, and VS Code. MCP specification: <a href="https://modelcontextprotocol.io/specification/2025-11-25">https://modelcontextprotocol.io/specification/2025-11-25</a>. Donation announcement: <a href="https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation">https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation</a></p><p>[⁷]: AWS Bedrock Guardrails: enforces topic blocks, content filters, and data scope for AI agents at inference time, without requiring manual filtering per response. Documentation: <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html">https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html</a></p><p>[⁸]: ChatGPT Memory: the model autonomously decides what to save from a conversation without user instruction, persisting those facts across future sessions. OpenAI Help Center — Memory FAQ: <a href="https://help.openai.com/en/articles/8590148-memory-faq">https://help.openai.com/en/articles/8590148-memory-faq</a></p><p>[⁹]: Devin, Cognition AI — purpose-built autonomous software engineering agent: <a href="https://www.cognition.ai/">https://www.cognition.ai</a>. Claude Code context architecture: Anthropic Engineering, “Effective Context Engineering for AI Agents,” 2025: <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents</a></p><p>[¹⁰]: RAG evaluation tools, verified February 2026. RAGAS: benchmark standard for RAG-specific faithfulness evaluation. DeepEval: most feature-complete open-source option as of 2026, with 14+ metrics spanning RAG, agentic, and conversational use cases. TruLens: Snowflake-backed following the May 2024 TruEra acquisition; strongest for runtime monitoring and basic LLM app observability. Sources: RAG evaluation tool comparison, December 2025: <a href="https://research.aimultiple.com/rag-evaluation-tools/">https://research.aimultiple.com/rag-evaluation-tools/</a>; TruLens + Snowflake: <a href="https://www.snowflake.com/en/blog/trulens-open-source-ai/">https://www.snowflake.com/en/blog/trulens-open-source-ai/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ed38da32cb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Context” is all you need: The Context]]></title>
            <link>https://medium.com/@nnrajesh3006/context-is-all-you-need-4d9e43fe2d22?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d9e43fe2d22</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Fri, 20 Feb 2026 17:45:48 GMT</pubDate>
            <atom:updated>2026-02-25T08:50:14.402Z</atom:updated>
            <content:encoded><![CDATA[<p>Series: <a href="https://medium.com/@nnrajesh3006/context-is-all-you-need-4d9e43fe2d22">Context Is All You Need</a> · Article 1 of 4</p><p>The enterprise AI stack has never been richer — or harder to reason about.</p><p>RAG pipelines. Agentic workflows. Fine-tuned models. Vector stores. Orchestration layers. Semantic layers. Knowledge graphs. Every month, a new pattern gets a name. Every quarter, a new framework promises to resolve the coordination problem between all the others. And in every post-mortem, in every hallway conversation after a demo that didn’t land, the same question surfaces: <em>why didn’t that work?</em></p><p>The teams moving fastest through that complexity aren’t necessarily the ones with the biggest budgets or the most sophisticated models. They’re the ones who’ve built a clear mental model for what every piece of the stack is actually doing — and how those pieces connect.</p><p>The coding agent category made this case plainest. Anthropic’s Claude Code earned enterprise adoption not by fielding the best model, but by engineering codebase context with precision — what to read, what to index, what to carry across sessions, when to ask rather than assume.[⁶] Cursor built a $29 billion business on the same discipline and maintained its $1 billion ARR even as Claude Code expanded into the enterprise market.[⁶] Two companies, the same underlying insight: the hard problem was never the model. It was what you fed it.</p><p>The pattern holds beyond code. Glean reached $100 million ARR in under three years not by building a better search engine, but by building the connective tissue between enterprise knowledge and the models that need to query it.[⁷] OpenClaw — an open-source autonomous agent connecting AI to messaging platforms — became one of the fastest-growing projects in GitHub history by answering one architectural question first: what context should the agent accumulate, where should it store it, and how should it retrieve it?[⁸]</p><p>None of them won on model quality.</p><p>Most teams haven’t built that model. They’ve built implementations.</p><p>They’ve selected the right framework, assembled the right components, deployed the right infrastructure — and still can’t explain, with precision, why the system underperforms on certain queries, why the agent loses the thread on step four, why the retrieval returns relevant documents that the model somehow ignores. The components are understood individually. The architecture isn’t understood as a whole.</p><p>This series provides that whole-system understanding.</p><p>After 12+ years building enterprise data platforms and Agentic AI systems, I arrived at one conclusion: every analytical system and every AI system — from a data warehouse to an autonomous agent — is solving exactly the same underlying problem.</p><p><em>How do you get the right information, to the right consumer, in the right format, at the right time?</em></p><p>Answer that question well, and your system works. Answer it poorly, and no model upgrade will fix it. That single problem has six dimensions — six operations that, composed in different ways, produce every architecture in the modern AI stack. Name them, understand their depth, and the complexity that seemed overwhelming becomes a design space you can reason about and build in.</p><p>That is what this series is for.</p><h3>The Name for What We’ve Always Done</h3><p>As a data and analytics leader, I’ve built platforms that turn fragmented enterprise data into something useful — across every era of the discipline. Data warehousing. Business intelligence. Analytics engineering. Now AI and agentic systems. The name changes every few years. The problem statement has not.</p><p><em>What information does the consumer need? Where does it live? How should it be structured? What noise needs to be filtered? Who should see what? And how do you make the answer available at the moment it’s needed?</em></p><p>Every project I’ve worked on — whether building a unified customer data platform across dozens of business units or architecting production agentic AI systems with multi-agent pipelines and hundreds of thousands of indexed vectors — was, at its core, an exercise in answering those questions.</p><p>I didn’t have a name for it.</p><p>Then, in June 2025, Andrej Karpathy posted something on X that clarified what I had been doing all along:</p><blockquote><em>“+1 for ‘context engineering’ over ‘prompt engineering’. People associate prompts with short task descriptions you’d give an LLM in your day-to-day use. When in every industrial-strength LLM app, </em><strong><em>context engineering is the delicate art and science of filling the context window with just the right information for the next step.</em></strong><em>“[¹]</em></blockquote><p>That sentence stopped me. Not because it was about LLMs — but because it described my entire career. Building a semantic layer so analysts could query enterprise sales or marketing data without knowing the join logic? Context engineering. Designing a governance framework that enforced what each stakeholder could see — and what stayed out of reach? Context engineering. Engineering RAG pipelines that surface the right information from hundreds of thousands of indexed documents before a model answers a question? Context engineering.</p><p>Naming a thing gives you power over it. Once you see context engineering as the unifying discipline, the history and the future of both data analytics and AI engineering snap into focus.</p><h3>The Central Thesis</h3><p><strong>Every AI application framework — whether it’s RAG, agentic, fine-tuning, multi-modal, or prompt engineering — ultimately reduces to one fundamental challenge: how do you provide the right context, at the right time, in the right format, to get useful results?</strong></p><p>This is not a simplification. It is a clarification.</p><p>Consider what’s happening at the model level right now. Sebastian Raschka’s detailed comparisons of LLM architectures[²] show that from GPT-2 (2019) through DeepSeek V3 (2024) and the latest frontier models, the core transformer architecture has remained structurally unchanged. The details evolved — positional encoding, attention mechanisms, activation functions — but the essential design Vaswani et al. described in 2017 is the same. Seven years of engineering refinement. The same fundamental structure underneath.</p><p>What this means in practice: for the general language and reasoning tasks that drive most enterprise AI use cases, capability is becoming a commodity. Gaps remain — in specialized reasoning, multimodal grounding, cost at scale — but they are narrowing.</p><p>Every organization running on the same frontier model will soon have access to roughly equivalent raw capability for those problems. The performance differences between frontier models — from OpenAI’s o-series to Anthropic’s Claude to Google’s Gemini — are real, but shrinking on the benchmarks that matter most to enterprise. The differentiator is not which model you use. The differentiator is what you put in front of it.</p><p>The AI race isn’t about who has the best model. It’s about who assembles the best context.</p><h3>The Framework: Six Context Operations</h3><p>If context engineering is the discipline, it needs a vocabulary. After mapping every major AI and analytics framework through the lens of context — RAG variants, agentic patterns, fine-tuning approaches, memory systems, guardrail frameworks, evaluation methods — I found that everything reduces to six fundamental operations. These are not categories of tools. They are the verbs of context engineering.</p><h3>SELECT — Acquiring the Right Context</h3><p><em>What information does the system need, and how does it find it?</em></p><p>SELECT is the retrieval operation. It ranges from a human analyst writing a SQL query — specifying exactly what to retrieve — all the way to an agentic RAG system that decides autonomously when to retrieve, from where, how many times, and whether to verify what it got before using it.</p><p>Every retrieval pattern is a SELECT strategy: keyword search, semantic vector similarity, hybrid retrieval, graph traversal, corrective retrieval, self-checking retrieval. The sophistication varies; the operation is the same.</p><h3>COMPRESS — Distilling Context to Signal</h3><p><em>How do you reduce information while preserving what matters?</em></p><p>Enterprise data doesn’t fit in a context window. Neither does a long conversation history, a 200-page knowledge base, or a year’s worth of KPI trends. COMPRESS is the operation that makes the useful subset fit.</p><p>It ranges from pre-aggregated rollups in a data warehouse — where a human decided in advance what to summarize — to agent-managed compression where the system dynamically decides what to retain, what to summarize, and what to drop based on the current task. Every compression decision trades fidelity for fit. The art is losing the noise without losing the signal.</p><h3>FORMAT — Structuring Context for Consumption</h3><p><em>How do you present information so the consumer can use it effectively?</em></p><p>FORMAT is what gives context meaning — structure the model can actually interpret. For AI systems, this includes system prompts (behavioral framing for the model), few-shot examples (showing the model what good output looks like), structured output schemas (type-safe contracts for responses), and increasingly, ontologies and data catalogs that give the model metadata about the data itself.</p><p>Data practitioners know this operation by another name: the semantic layer. When you define what “active user” means in your organization, what counts as “revenue,” how customer segments map to regional hierarchies — you are building a FORMAT layer. You are structuring the meaning of data, not just its storage.</p><p>The FORMAT layer is where most enterprise AI projects succeed or fail. If the model doesn’t know what “revenue” means in your company — which system is authoritative, what deductions apply, how it differs from “bookings” — no amount of model capability compensates.</p><h3>ISOLATE — Scoping Context to Prevent Pollution</h3><p><em>How do you ensure each consumer sees only what’s relevant and authorized?</em></p><p>Every AI system has a scope problem: too much context degrades reasoning, and the wrong context is worse than none. ISOLATE is the operation that defines the boundary — what each component should see, and what it should not.</p><p>In multi-agent systems, this is existential: Agent A’s working context bleeding into Agent B’s reasoning can corrupt the output of a system that looked correct at every individual step. At the governance level, ISOLATE is row-level security — this user can see this data, not that data. At its most sophisticated, it’s dynamic, compliance-aware context scoping where an AI agent automatically restricts its own context based on sensitivity classifications, residency requirements, or regulatory constraints — without being told explicitly.</p><h3>PERSIST — Storing Context Across Time and Steps</h3><p><em>How does the system remember what matters beyond the current interaction?</em></p><p>PERSIST is what bridges the gap between a stateless LLM call and an intelligent system with organizational memory. At its most basic, it’s a data warehouse — the enterprise’s curated, governed, persistent record of what happened. At its most sophisticated, it’s episodic memory: a system that recalls past incidents when similar situations arise, learns from each interaction, and writes improved instructions for its future self based on what worked.</p><p>Fine-tuning is PERSIST taken to an extreme: encoding context permanently into the model’s weights so it doesn’t need to be provided at runtime. You trade dynamic flexibility for parametric recall.</p><h3>WRITE — Generating New Context</h3><p><em>How does the system create new information that feeds back into the loop?</em></p><p>WRITE is the most powerful and most dangerous operation. When an analyst writes a root cause narrative in a post-mortem report, that’s WRITE. When a language model generates chain-of-thought reasoning before producing an answer, that intermediate reasoning is WRITE — new context created by the system itself, used to improve the next step. When an agent reflects on its output, identifies errors, and generates corrective instructions for the next attempt, that’s WRITE.</p><p>WRITE is where hallucination is generated. The causes may be distributed across other operations — bad retrieval, missing ground truth, inadequate formatting — but the fabrication happens here. Every time a system generates context that didn’t exist before, it introduces the risk of fabrication. This is why quality controls — faithfulness checks, grounding evaluations, human review at critical decision points — are essential guardrails specifically on the WRITE operation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C37MYc23gpQ9GoiJ" /></figure><p>Six operations. That’s the complete vocabulary. Every AI and analytics framework — every pattern, every tool, every architecture — is a strategy for orchestrating some combination of SELECT, COMPRESS, FORMAT, ISOLATE, PERSIST, and WRITE. Once you have that vocabulary, something clarifying happens to the landscape of AI engineering.</p><p><em>(A note on the taxonomy: these operations are not perfectly orthogonal — fine-tuning lives at the boundary of PERSIST and FORMAT; agents frequently chain SELECT and WRITE in the same step. This is a practitioner’s vocabulary, not a formal system. The value is not precision but clarity: six distinctions that consistently reveal where production systems go wrong.)</em></p><h3>Every Framework, One Lens</h3><p>You stop thinking about AI frameworks as distinct, competing technologies and start seeing them as different answers to the same underlying questions.</p><p><strong>RAG</strong> is primarily a SELECT strategy. The LLM doesn’t change; only what you put in its context window does. Every variant — naive RAG, hybrid RAG, GraphRAG, corrective RAG, self-RAG, agentic RAG — is a different approach to the SELECT operation, differing in how the retrieval decision is made, verified, and executed.</p><p><strong>Fine-tuning</strong> is a PERSIST strategy. You are encoding domain context permanently into the model’s weights so you don’t have to provide it at runtime. It trades dynamic flexibility (you can’t update without retraining) for inference efficiency (no retrieval overhead). This is not a superior approach to RAG — it’s a different context persistence tradeoff.</p><p><strong>Prompt engineering</strong> is primarily a FORMAT + ISOLATE strategy. System prompts define the behavioral context (FORMAT: “you are a senior financial analyst”). Few-shot examples show the model the expected output structure. Scope constraints define what the model should and should not engage with (ISOLATE: “only answer questions about Q4 financial results”).</p><p><strong>Agentic frameworks</strong> — LangGraph, CrewAI, AutoGen, OpenAI Agents SDK — are full context management loops. An agent observes (SELECT + COMPRESS), reasons (WRITE), acts (uses context to change the world), and iterates. The sophistication of an agentic system is the sophistication of how it manages each of those operations across multiple steps, tools, and time.</p><p><strong>Memory systems</strong> — MemGPT, Zep, LangChain Memory — are PERSIST + SELECT systems. They store context from prior interactions and retrieve it when relevant. The hard problems are the PERSIST decisions (what to remember, what to forget) and the SELECT decisions (when to retrieve, which memories are relevant).</p><p>Once you see this, the question “should we use RAG or fine-tuning or agents?” becomes the wrong question. The right question is: <strong>what composition of context operations does my specific problem require, and at what level of sophistication does each operation need to operate?</strong></p><p>That is a design question. This framework is a design tool.</p><h3>Why Context Quality Beats Model Quality</h3><p>This is the claim that matters most for how organizations should invest.</p><p>The quality ceiling of any AI system is set by the quality of its context, not the capability of its model.</p><p>This isn’t theoretical. MIT’s NANDA (Networked Agents and Decentralized AI) research initiative found that approximately 95% of generative AI pilot programs at enterprises fail to deliver measurable ROI — the vast majority stall without meaningful business impact.[³] When I look at failed AI implementations, the pattern is almost never “wrong model.” It’s “wrong context”: the model was given data it couldn’t interpret because it lacked a semantic layer, or it was given too much irrelevant information and the signal was buried, or it had no memory of previous interactions and repeated the same mistakes, or it had no governance layer and surfaced data employees shouldn’t have seen.</p><p>Research confirms what practitioners know: context placement matters enormously even when you’ve retrieved the right information. Liu et al.’s study at Stanford demonstrated that language model performance degrades significantly when relevant information appears in the middle of a long context window — even for models explicitly designed to handle long contexts.[⁴] Subsequent long-context benchmarks have refined but not overturned this finding: while frontier models have improved, the principle holds that structure and position within the context window affect whether the model uses information correctly.[⁴a] Retrieving the right information is necessary but insufficient. How you present it determines whether it works.</p><p>Meanwhile, Retrieval-Augmented Generation — the industry’s primary response to the context quality problem — has become the dominant enterprise AI pattern. On enterprise platforms, vector databases supporting RAG applications grew 377% year-over-year, with 70% of organizations already deploying generative AI turning to vector databases and RAG to customize models with proprietary data.[⁵] Enterprises aren’t investing in RAG because they love the architecture. They’re investing because they’ve learned that giving the model better context produces better results than giving it a better model.</p><p>Every evaluation failure is fundamentally a context failure. Low relevance scores? The SELECT operation retrieved the wrong information. Low faithfulness scores? The WRITE operation generated content not grounded in the retrieved context. High hallucination rates? The PERSIST operation failed to make ground-truth information available. Before blaming the model, ask: what was wrong with the context?</p><h3>What’s Coming in This Series</h3><p>This article established the thesis and introduced the vocabulary. The next three go deeper.</p><p>Article 2 reveals each operation as a full design space — SELECT alone spans eight distinct retrieval strategies, from a human writing SQL to an autonomous agentic system. Article 3 applies the framework to three real enterprise problems, showing how operations chain into architectures. Article 4 closes with the Context Maturity Model — a self-assessment grid mapping every operation against four organizational maturity levels — and the emerging role this framework points toward: the Context Architect.</p><p>The core claim of this series is not that AI frameworks don’t matter. It’s that they all matter in the same way — as different strategies for orchestrating the same six operations. The debate about which framework to pick is the wrong conversation. The right conversation is about what context architecture your specific problem requires.</p><p>Stop picking frameworks. Start designing context architectures.</p><p>The models are converging. The context is diverging.</p><p>The organizations that understand the difference will define what comes next.</p><h3>References</h3><p>[¹]: Andrej Karpathy, X (formerly Twitter), June 25, 2025.</p><p><a href="https://x.com/karpathy/status/1937902205765607626">Andrej Karpathy@karpathy</a></p><p><a href="https://x.com/karpathy/status/1937902205765607626">+1 for “context engineering” over “prompt engineering”. People associate prompts with short task descriptions you’d give an LLM in your day-to-day use. When in every industrial-strength LLM app, context engineering is the delicate art and science of filling the context window</a></p><p><a href="https://x.com/karpathy/status/1937902205765607626">tobi lutke @tobi</a></p><p><a href="https://x.com/karpathy/status/1937902205765607626">I really like the term “context engineering” over prompt engineering. It describes the core skill better: the art of providing all the context for the task to be plausibly solvable by the LLM.</a></p><p><a href="https://x.com/karpathy/status/1937902205765607626">8:54 AM · Jun 25, 2025 · 2.36M Views</a></p><p><a href="https://x.com/karpathy/status/1937902205765607626">524 Replies · 2.08K Reposts · 14.3K Likes</a></p><p>[²]: Sebastian Raschka, “The Big LLM Architecture Comparison,” <em>Ahead of AI</em>, 2025.</p><p><a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison?utm_source=substack&amp;utm_campaign=post_embed&amp;utm_medium=web">Ahead of AI</a></p><p><a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison?utm_source=substack&amp;utm_campaign=post_embed&amp;utm_medium=web">The Big LLM Architecture Comparison</a></p><p><a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison?utm_source=substack&amp;utm_campaign=post_embed&amp;utm_medium=web">Last updated: Feb 11, 2026 (added GLM-4.7 at the bottom…</a></p><p><a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison?utm_source=substack&amp;utm_campaign=post_embed&amp;utm_medium=web">Read more</a></p><p><a href="https://magazine.sebastianraschka.com/p/the-big-llm-architecture-comparison?utm_source=substack&amp;utm_campaign=post_embed&amp;utm_medium=web">7 months ago · 1773 likes · 86 comments · Sebastian Raschka, PhD</a></p><p>. The original transformer architecture: Vaswani et al., “Attention Is All You Need,” <em>NeurIPS</em>, 2017. <a href="https://arxiv.org/abs/1706.03762">https://arxiv.org/abs/1706.03762</a></p><p>[³]: MIT NANDA (Networked Agents and Decentralized AI), MIT Media Lab, <em>The GenAI Divide: State of AI in Business 2025</em>, August 2025. Based on 300+ publicly disclosed AI initiatives, 52 structured interviews, and 153 survey responses from senior leaders. Full report: <a href="https://mlq.ai/media/quarterly_decks/v0.1_State_of_AI_in_Business_2025_Report.pdf">https://mlq.ai/media/quarterly_decks/v0.1_State_of_AI_in_Business_2025_Report.pdf</a>. Covered by Fortune, August 18, 2025: <a href="https://fortune.com/2025/08/18/mit-report-95-percent-generative-ai-pilots-at-companies-failing-cfo/">https://fortune.com/2025/08/18/mit-report-95-percent-generative-ai-pilots-at-companies-failing-cfo/</a></p><p>[⁴]: Nelson F. Liu, Kevin Lin, John Hewitt, et al., “Lost in the Middle: How Language Models Use Long Contexts,” <em>Transactions of the Association for Computational Linguistics</em>, Vol. 12, 2024, pp. 157–173. <a href="https://arxiv.org/abs/2307.03172">https://arxiv.org/abs/2307.03172</a></p><p>[⁴a]: HELMET (ICLR 2025): Howard Yen, Tianyu Gao, et al., “HELMET: How to Evaluate Long-Context Language Models Effectively and Thoroughly,” Princeton NLP / Intel Labs, <em>ICLR 2025</em>. <a href="https://arxiv.org/abs/2410.02694">https://arxiv.org/abs/2410.02694</a>. HELMET explicitly tests the lost-in-the-middle phenomenon (Appendix E.4) on frontier models including GPT-4o at 128K and finds performance gaps widen with context length — the problem is refined, not resolved. Corroboration: Hsieh et al., “Found in the Middle: Calibrating Positional Attention Bias Improves Long Context Utilization,” <em>ACL Findings 2024</em>. <a href="https://arxiv.org/abs/2406.16008">https://arxiv.org/abs/2406.16008</a>.</p><p>[⁵]: RAG and vector database growth: Databricks, <em>2024 State of Data + AI</em>, June 2024, based on anonymized usage data from 10,000+ global Databricks customers including 300+ Fortune 500 companies (data period: February 2023–March 2024). Blog summary: <a href="https://www.databricks.com/blog/state-ai-enterprise-adoption-growth-trends">https://www.databricks.com/blog/state-ai-enterprise-adoption-growth-trends</a>. Note: growth figures reflect Databricks platform usage. Enterprise AI adoption context: McKinsey &amp; Company, <em>The State of AI 2025</em>, <a href="https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai">https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai</a>.</p><p>[⁶]: Claude Code context architecture: Anthropic Engineering, “Effective Context Engineering for AI Agents,” 2025, <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents</a> (”the smallest set of high-signal tokens that maximize the likelihood of your desired outcome”). Technical design: <a href="https://code.claude.com/docs/en/how-claude-code-works">https://code.claude.com/docs/en/how-claude-code-works</a>. Cursor valuation and ARR: CNBC, “AI startup Cursor raises $2.3 billion funding round at $29.3 billion valuation,” November 2025. <a href="https://www.cnbc.com/2025/11/13/cursor-ai-startup-funding-round-valuation.html">https://www.cnbc.com/2025/11/13/cursor-ai-startup-funding-round-valuation.html</a>. Fortune, “Cursor has growing revenue and a $29 billion valuation,” December 2025. <a href="https://fortune.com/2025/12/11/cursor-ipo-1-billion-revenue-brainstorm-ai/">https://fortune.com/2025/12/11/cursor-ipo-1-billion-revenue-brainstorm-ai/</a></p><p>[⁷]: Glean ARR and valuation: TechCrunch, “Enterprise AI startup Glean lands a $7.2B valuation,” June 2025. <a href="https://techcrunch.com/2025/06/10/enterprise-ai-startup-glean-lands-a-7-2b-valuation/">https://techcrunch.com/2025/06/10/enterprise-ai-startup-glean-lands-a-7-2b-valuation/</a>. Glean Series F announcement: <a href="https://www.glean.com/press/glean-raises-150m-series-f-at-7-2b-valuation-to-accelerate-enterprise-ai-agent-innovation-globally">https://www.glean.com/press/glean-raises-150m-series-f-at-7-2b-valuation-to-accelerate-enterprise-ai-agent-innovation-globally</a></p><p>[⁸]: OpenClaw GitHub repository (206,000 stars): <a href="https://github.com/openclaw/openclaw">https://github.com/openclaw/openclaw</a>. Creator Peter Steinberger joins OpenAI: TechCrunch, February 15, 2026, <a href="https://techcrunch.com/2026/02/15/openclaw-creator-peter-steinberger-joins-openai/">https://techcrunch.com/2026/02/15/openclaw-creator-peter-steinberger-joins-openai/</a>; CNBC, <a href="https://www.cnbc.com/2026/02/15/openclaw-creator-peter-steinberger-joining-openai-altman-says.html">https://www.cnbc.com/2026/02/15/openclaw-creator-peter-steinberger-joining-openai-altman-says.html</a>. Architecture and context design: Milvus Blog, “What Is OpenClaw?” <a href="https://milvus.io/blog/openclaw-formerly-clawdbot-moltbot-explained-a-complete-guide-to-the-autonomous-ai-agent.md">https://milvus.io/blog/openclaw-formerly-clawdbot-moltbot-explained-a-complete-guide-to-the-autonomous-ai-agent.md</a></p><p><em>Rajesh Nekkanti is a data and analytics leader with 12+ years building enterprise data platforms, semantic layers, and agentic AI systems. He writes about context engineering at the intersection of traditional analytics and AI.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d9e43fe2d22" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Analytics Evolution: From Report Builder to Agent Orchestrator]]></title>
            <link>https://medium.com/@nnrajesh3006/the-analytics-evolution-from-report-builder-to-agent-orchestrator-c577b0f5c2bb?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/c577b0f5c2bb</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[sales]]></category>
            <category><![CDATA[analytics]]></category>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[data-visualization]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 10:04:23 GMT</pubDate>
            <atom:updated>2026-01-27T10:04:23.895Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kk6nfBZcwTgVwTPNQ3p_WQ.png" /></figure><p>A sales operations team receives an urgent Slack message at 9:07 AM: “Top enterprise deal just slipped to Q2. What happened?” In 2023, this question triggered a familiar cascade — open Salesforce, filter opportunity views, pivot to Tableau for historical win rates, export to Excel for custom calculations, draft findings in a deck. Four hours later, leadership has their answer.</p><p>In 2026, the response arrives in seconds. An autonomous agent detected the stage change, cross-referenced the account’s engagement velocity against similar enterprise deals, identified the deviation (no executive sponsor meeting in the past 21 days), queried the sales rep’s calendar API, found three cancelled meetings, and surfaced a correlation: the champion changed roles six days ago. The agent didn’t wait for a human to ask the question. It observed the anomaly, reasoned through the diagnostic sequence, and escalated with context.</p><p>This isn’t a glimpse of the future. It’s the present reality separating organizations that have made the leap from descriptive analytics to agentic autonomy — and those still treating dashboards as the apex of business intelligence.</p><h3>The Four Phases: How We Got Here</h3><p>The evolution from static reporting to autonomous agents didn’t happen overnight. It unfolded across four distinct paradigms, each expanding what was possible while revealing new limitations.</p><h4>Phase 1: Descriptive &amp; Diagnostic BI (2010–2020)</h4><p>The dashboard era answered one question: <em>What happened?</em> Tools like Tableau, Power BI, and Salesforce Reports became the universal interface for organizational intelligence. Analysts spent the majority of their time on data cleaning rather than actual analysis. Data was siloed across systems. SQL queries ran against yesterday’s snapshot. Latency was measured in hours. Business users learned to accept that insights arrived after decisions were already made. The analyst’s role was clear: build reports, refresh data, field ad-hoc requests from stakeholders who couldn’t navigate the dashboard themselves. The dashboard paradigm locked organizations into a reactive posture.</p><h4>Phase 2: Predictive &amp; Prescriptive ML (2020–2023)</h4><p>Machine learning promised to move beyond “what happened” to “what will happen.” Lead scoring algorithms ranked prospects. Forecasting models predicted pipeline conversion. Churn risk scores flagged at-risk accounts. But predictive models remained fundamentally read-only.[¹] A lead score of 92/100 still required a human to decide whether to route it to an Account Executive or an inside sales rep. The algorithm couldn’t send the email, update the CRM status, or trigger the nurture campaign. Trust remained fragile — black-box models that couldn’t explain their reasoning created institutional skepticism, especially when predictions failed.[²] Dashboards evolved to incorporate ML-powered insights, but the interface remained static. The human was still the bottleneck between insight and action.</p><h4>Phase 3: Generative Assistive AI (2023–2025)</h4><p>Large language models introduced conversational interfaces to analytics. RAG architectures enabled natural language queries: “Show me Q4 pipeline by region” generated dashboards on demand. LLM co-pilots drafted email responses, summarized meeting notes, suggested next steps. Analysts became prompt engineers, learning to coax better outputs from generative models. But co-pilots remained stateless and passive.[³] They waited for human prompts. They couldn’t maintain context across sessions or execute multi-step workflows without constant supervision. Each interaction started from scratch. The human remained the orchestrator, the decision-maker, and the executor. Natural language query interfaces represented an evolution of dashboards, not a replacement.</p><h4>Phase 4: Agentic Autonomy (Early Adoption, 2025–26)</h4><p>Cognitive architectures like LangGraph, Salesforce Agentforce, and Microsoft Copilot Agents fundamentally changed the question from “show me” to <em>“do this for me.”</em> Agents maintain state across interactions, reason through multi-step sequences, use tools autonomously, and execute workflows without waiting for human prompts.[¹] This isn’t a distant roadmap — it’s the current standard among early adopters in 2025 and current year.</p><h4>The Architectural Shift: From Insight to Execution</h4><p>The progression from predictive models to co-pilots to agents represents a fundamental architectural change: closing the loop from insight to execution. Consider a production deployment at a B2B SaaS company that illustrates this transformation.</p><p><strong>The Autonomous Usage Analytics Agent in Action:</strong> A product engagement monitoring agent continuously analyzes customer usage telemetry across the enterprise portfolio, detecting that Acme Corp’s API call volume dropped 68% over seven days — a statistically significant anomaly given their historical 12-month average and current $780K ARR. Without human intervention, it queries the revenue database to identify upcoming renewal timeline (34 days), cross-references usage patterns against similar accounts to calculate churn risk probability (82%), segments the affected user cohort to pinpoint that their data science team (primary product champions) ceased activity entirely, and retrieves the customer success manager’s last touchpoint (41 days ago — outside policy threshold). The agent drafts a personalized alert to the account executive with diagnostic context, auto-generates a customer outreach email highlighting unused product capabilities that could restore value, creates a high-priority workflow task with recommended talking points, and escalates to the Regional VP with risk quantification and intervention strategy.[⁴] The entire sequence — from observation to action — executes without human initiation.</p><p>This contrasts sharply with earlier paradigms. Predictive models generated insights without action: a churn prediction algorithm could flag an at-risk customer, but a human had to decide whether to offer a discount, schedule an executive call, or escalate to customer success. Co-pilots provided suggestions without autonomy: a sales assistant could draft an email response, but the rep had to review it, edit it, approve it, and click send.</p><p>Agents invert this flow. They observe data continuously, reason through decision trees, and take action autonomously within defined guardrails, surfacing information to humans only when judgment calls exceed their authority. The implication for business intelligence teams is stark: the competitive advantage is no longer how quickly analysts can build dashboards. It’s how effectively they can architect autonomous systems that reason and act in real-time.</p><h3>Production Examples: The 2026 Landscape</h3><p>The dashboard isn’t dying — it’s being disintermediated. As <a href="https://www.tableau.com/blog/agentic-analytics-new-paradigm-for-business-intelligence">Tableau’s 2026 vision articulates</a>, agentic analytics empowers humans to collaborate with AI agents to transform the entire data-to-action workflow. <a href="https://www.accelirate.com/agentic-ai-tableau-next-analytics/">Tableau Next</a> includes AI agents — Data Pro, Concierge, and Inspector — that automate repetitive tasks, proactively deliver insights, and trigger workflows based on evolving data.</p><p><a href="https://www.salesforceben.com/sales-cloud-top-salesforce-spring-26-features/">Salesforce’s Sales Workspace</a> represents this paradigm shift: no longer a destination for viewing reports, it’s an intelligent hub where reps see agent activity, ready-to-action items, and performance analytics in a unified interface. The workspace shows <em>how Agentforce has been helping</em> across meetings, opportunities, leads, and account research — making the agent’s labor visible alongside human work.</p><p><a href="https://powerbi.microsoft.com/en-us/blog/power-bi-january-2026-feature-summary/">Microsoft Power BI’s Novemeber 2025 and January 2026 updates</a> introduced standalone Copilot agents that can “find and analyze any report, semantic model, and Fabric data agent” across the organization, with <a href="https://github.com/microsoft/powerbi-modeling-mcp">Model Context Protocol (MCP) support</a> enabling custom agents to query semantic models remotely. Dashboards become data sources that agents consume, not destinations that humans visit.</p><p><strong>“Applications like CRM, ERP, and BI dashboards still hold data and workflows, but the agent becomes the interface — abstracting complexity and delivering outcomes, not dashboards.”</strong> — <a href="https://appinventiv.com/blog/ai-ui-replacing-apps-and-buttons/">Appinventiv AI UI Research</a></p><h3>Barriers to Adoption: Why This Is Harder Than It Looks</h3><p>The promise of agentic autonomy collides with harsh realities. Organizations racing to deploy agents are discovering that production readiness requires solving challenges that didn’t exist in the dashboard era:</p><p><strong>Data Quality Imperative:</strong> 84% of data leaders say their data strategies are not ready for AI.[⁵] This reveals the “Maintenance Trap” — a fundamental shift in how organizations handle data quality. Report Builders cleaned datasets manually for humans, who tolerate typos and apply institutional context. Agent Orchestrators must architect automated pipelines for machines, which crash on inconsistent formats and hallucinate from dirty data. When an agent autonomously updates pricing based on competitor analysis, it cannot recognize that a scraped product listing represents a discontinued SKU from 18 months ago. The maintenance burden hasn’t decreased — it’s multiplied. Organizations must now engineer validation layers, deduplication logic, and schema enforcement that were unnecessary when humans served as the final quality checkpoint. Bad data leads to bad automated actions, at scale, without review.[⁵].</p><p><strong>Hallucination Risk:</strong> In creative applications, LLM hallucinations are tolerable. In forecasting and financial planning, invented facts are catastrophic. The solution is grounding: Retrieval-augmented generation (RAG) architectures ensure agents retrieve facts from trusted sources rather than generating plausible-sounding fictions.[⁶] Industry benchmarks suggest organizations should target &lt;2% hallucination rates for agents operating in high-stakes domains like financial reporting or regulatory compliance.[⁷]</p><p><strong>Workslop Challenge:</strong> When agents can draft reports and generate recommendations with zero marginal cost, organizations risk drowning in low-quality outputs.[⁸] The solution requires distinguishing two operating modes. “<strong>Human-in-the-loop”</strong> applies to high-stakes scenarios where agents pause for explicit approval — approving $50K+ discounts, recommending workforce changes, or triggering compliance workflows. The agent proposes, the human authorizes, then executes. “<strong>Human-on-the-loop” </strong>applies to high-volume, low-risk operations where agents act autonomously while humans monitor outcomes — routing 500 leads via firmographic scoring, updating CRM fields from email sentiment, or flagging churn risk. The agent acts, logs reasoning, and humans audit exceptions. Organizations that conflate these modes either create approval bottlenecks that negate automation benefits or grant excessive autonomy that amplifies error impact.[³].</p><p><strong>Security Considerations:</strong> Agents with tool access create new attack surfaces. Prompt injection can trick agents into exposing sensitive data or executing unauthorized actions.[⁹][¹⁰] Production deployments require input sanitization layers, permission scoping, and governance frameworks that define which systems agents can access and which actions require human approval.</p><h3>The Agent Orchestrator Role: Engineering Autonomous Systems</h3><p>The progression from Report Builder to Data Scientist to Prompt Engineer now reaches its next evolution: the Agent Orchestrator. This isn’t a cosmetic title change — it represents a fundamental shift in how analytics teams create value.</p><p><strong>What They Do:</strong></p><ol><li><strong>Design cognitive workflows</strong> — Breaking complex business processes into atomic steps that agents can execute, defining decision trees for escalation, and architecting multi-agent workflows where specialized agents collaborate (e.g., monitoring agent → analysis agent → reasoning agent → action agent).</li><li><strong>Write system prompts and define tool capabilities</strong> — Encoding business logic (“always check CRM for existing opportunities before creating new records”), risk guardrails (“never approve discounts &gt;20% without human review”), and domain knowledge into agent instructions. Defining which APIs agents can call, what parameters they require, and what outputs to expect.</li><li><strong>Set guardrails and risk thresholds</strong> — Defining operating envelopes: spending limits for procurement agents, discount approval thresholds for sales agents, data retention policies for customer support agents. These evolve as organizations build trust and observe agent behavior.</li><li><strong>Monitor agent performance with new KPIs</strong> — Goal Accuracy (target: 85%+), Hallucination Rate (target: &lt;2%), Effective Escalation Rate (target: 10–20%), Pipeline Hygiene Score (target: 95%+), Cost Per Outcome (not cost per query, but cost per completed workflow).[⁷]</li><li><strong>Architect data quality pipelines</strong> — Building validation layers — deduplication logic, schema enforcement, anomaly detection — that ensure agents operate on trustworthy data. This often requires refactoring existing data pipelines that were “good enough” for human analysts but inadequate for autonomous systems.</li><li><strong>Champion governance</strong> — Translating organizational policies into technical guardrails: which data sources can agents access? Which actions require human approval? What audit trails must be maintained for regulatory compliance?</li></ol><p><strong>Skills Required:</strong></p><ol><li><strong>Computational thinking</strong> — Breaking complex processes into atomic, executable steps. Understanding state management, error handling, and asynchronous workflows.</li><li><strong>“Vibe coding”</strong> — Describing business logic in natural language precise enough for AI to implement it correctly.[⁸] This is computational linguistics applied to business processes.</li><li><strong>System design</strong> — Architecting multi-agent workflows where specialized agents collaborate, share context, and hand off tasks. Understanding orchestration patterns like sequential chains, parallel execution, and conditional branching.</li><li><strong>Domain expertise</strong> — Understanding the business context agents operate in. An Orchestrator designing sales agents needs to understand pipeline stages, win rates, and sales methodologies — not just LangGraph syntax.</li></ol><p>As <a href="https://eightfold.ai/blog/most-important-job-2026/">Eightfold AI’s analysis suggests</a>, human roles are shifting from “doing the work” toward orchestrating systems of work. <strong>“Humans are moving from middleware positions to endpoints, with AI agents becoming the orchestrators of processes.”</strong></p><h3>What’s Next: Emerging Trends</h3><p>The agent revolution is accelerating. Three emerging trends will define the next phase:</p><p><strong>Agent-to-Agent (A2A) Economy:</strong> In late 2026, early adopters are piloting procurement agents that negotiate directly with supplier sales agents.[¹¹] No human brokers. Two autonomous systems exchange requirements, pricing constraints, and counteroffers until they reach agreement or escalate exceptions. The implications are profound: B2B sales teams will need to optimize not for human persuasion, but for “Agent SEO” — making their offerings discoverable and attractive to buying algorithms.[¹²][¹³]</p><p><strong>Self-Optimizing Systems:</strong> Current agents execute workflows humans design. The next generation will optimize their own strategies.[¹⁴] A lead routing agent might A/B test different scoring algorithms, measure conversion outcomes, and autonomously adopt the highest-performing model. Orchestrators will shift from designing fixed workflows to setting optimization objectives and constraints.</p><p><strong>The New Competitive Moat:</strong> In the dashboard era, competitive advantage came from proprietary data. In the agent era, it comes from orchestration sophistication. Two companies with identical datasets will see radically different outcomes based on how effectively their agents reason, collaborate, and act. Organizations with mature orchestration frameworks capture 2–3x more value specifically because they’ve mastered the governance and technical challenges.[⁴]</p><h3>Conclusion: The Mandate for Analytics Leaders</h3><p>The dashboard paradigm served organizations well for 15 years. It democratized access to data, enabled evidence-based decision-making, and established analytics as a strategic function. But it locked organizations into a reactive posture: waiting for questions, building reports, and relying on humans to bridge the gap from insight to action.</p><p>The agentic paradigm inverts this model. Intelligence becomes proactive. Systems don’t wait for questions — they observe patterns, detect anomalies, reason through implications, and act autonomously within governed boundaries. The dashboard isn’t dead; it’s being transformed from a destination humans visit into a component layer that agents query, just as they query CRM, ERP, and external data sources.</p><p>For analytics professionals, this represents the most significant role evolution since the shift from Excel to BI platforms. The mandate is clear: pivot from building reports humans read to architecting systems that reason and act.</p><p>The organizations that make this transition in 2026 — building data governance frameworks, training Agent Orchestrators, and deploying production-grade autonomous workflows — will capture 2–3x more value than peers still treating dashboards as the apex of business intelligence.[⁴]</p><p>The future of analytics isn’t about analyzing the past. It’s about engineering autonomous systems that act on insights in real-time. The question for every analytics leader is no longer “how quickly can we build this dashboard?” It’s “which decisions should we automate, and which require human judgment?”</p><p>The answer to that question will define competitive advantage for the next decade.</p><h3>References</h3><p>[¹]: Gartner. (2023, March 1). “Gartner Predicts Three Ways Autonomous Technologies Will Impact the FP&amp;A and Controller Functions in Finance.” Press release. <a href="https://www.gartner.com/en/newsroom/press-releases/2023-03-01-gartner-preditcts-three-ways-autonomous-technologies-will-impact-the-fpanda-and-controller-functions-in-">https://www.gartner.com/en/newsroom/press-releases/2023-03-01-gartner-preditcts-three-ways-autonomous-technologies-will-impact-the-fpanda-and-controller-functions-in-</a></p><p>[²]: DevriX. (2026). “AI in RevOps? Too Much or Not Enough?” <a href="https://devrix.com/tutorial/ai-revops/">https://devrix.com/tutorial/ai-revops/</a></p><p>[³]: Salesforce. (2026). “Autonomous vs Assistive Agents: Which is Right for Your Small Business?” <a href="https://www.salesforce.com/blog/autonomous-vs-assistive-agents/">https://www.salesforce.com/blog/autonomous-vs-assistive-agents/</a></p><p>[⁴]: McKinsey. (2025). “Agents for growth: Turning AI promise into impact.” <a href="https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/agents-for-growth-turning-ai-promise-into-impact">https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/agents-for-growth-turning-ai-promise-into-impact</a></p><p>[⁵]: Salesforce. (2026). “Study: 84% of Technical Leaders Need Data Overhaul for AI Strategies to Succeed.” <a href="https://www.salesforce.com/news/stories/data-analytics-trends-2026/">https://www.salesforce.com/news/stories/data-analytics-trends-2026/</a></p><p>[⁶]: CX Today. (2026). “AI Hallucinations Start With Dirty Data: Governing Knowledge for RAG Agents.” <a href="https://www.cxtoday.com/customer-analytics-intelligence/ai-hallucinations-start-with-dirty-data-governing-knowledge-for-rag-agents/">https://www.cxtoday.com/customer-analytics-intelligence/ai-hallucinations-start-with-dirty-data-governing-knowledge-for-rag-agents/</a></p><p>[⁷]: DataRobot. (2026). “How to measure agent performance: metrics, methods, and ROI.” <a href="https://www.datarobot.com/blog/how-to-measure-agent-performance/">https://www.datarobot.com/blog/how-to-measure-agent-performance/</a></p><p>[⁸]: Salesforce. (2026). “The Future of AI Agents: Top Predictions and Trends to Watch in 2026.” <a href="https://www.salesforce.com/uk/news/stories/the-future-of-ai-agents-top-predictions-trends-to-watch-in-2026/">https://www.salesforce.com/uk/news/stories/the-future-of-ai-agents-top-predictions-trends-to-watch-in-2026/</a></p><p>[⁹]: Microsoft Defender Cloud Blog. (2026). “Plug, Play, and Prey: The security risks of the Model Context Protocol.” <a href="https://techcommunity.microsoft.com/blog/microsoftdefendercloudblog/plug-play-and-prey-the-security-risks-of-the-model-context-protocol/4410829">https://techcommunity.microsoft.com/blog/microsoftdefendercloudblog/plug-play-and-prey-the-security-risks-of-the-model-context-protocol/4410829</a></p><p>[¹⁰]: Medium — Tahir. (2025). “How to Secure Model Context Protocol (MCP).” <a href="https://medium.com/@tahirbalarabe2/how-to-secure-model-context-protocol-mcp-01339d9e603c">https://medium.com/@tahirbalarabe2/how-to-secure-model-context-protocol-mcp-01339d9e603c</a></p><p>[¹¹]: YouTube — Google Cloud. (2026). “How to build an AI agent with MCP, ADK, and A2A on Google Cloud.” <a href="https://www.youtube.com/watch?v=6mQwHqK1I5w">https://www.youtube.com/watch?v=6mQwHqK1I5w</a></p><p>[¹²]: Airia. (2026). “2026: The State of Agentic AI in Retail.” <a href="https://airia.com/2026-the-state-of-agentic-ai-in-retail/">https://airia.com/2026-the-state-of-agentic-ai-in-retail/</a></p><p>[¹³]: Microsoft. (2026). “Microsoft propels retail forward with agentic AI capabilities.” <a href="https://news.microsoft.com/source/2026/01/08/microsoft-propels-retail-forward-with-agentic-ai-capabilities-that-power-intelligent-automation-for-every-retail-function/">https://news.microsoft.com/source/2026/01/08/microsoft-propels-retail-forward-with-agentic-ai-capabilities-that-power-intelligent-automation-for-every-retail-function/</a></p><p>[¹⁴]: Medium — Ronald Kimmons. (2026). “AI Agents vs Traditional AI: Which Is Better For Your Startup in 2026?” <a href="https://medium.com/@agoranation.rmk/ai-agents-vs-traditional-ai-which-is-better-for-your-startup-in-2026-f7abc64ba78e">https://medium.com/@agoranation.rmk/ai-agents-vs-traditional-ai-which-is-better-for-your-startup-in-2026-f7abc64ba78e</a></p><h3>Sources</h3><ul><li><a href="https://www.tableau.com/blog/agentic-analytics-new-paradigm-for-business-intelligence">Agentic Analytics: A New Paradigm for Business Intelligence — Tableau</a></li><li><a href="https://www.accelirate.com/agentic-ai-tableau-next-analytics/">Agentic AI Meets Tableau Next — Accelirate</a></li><li><a href="https://www.salesforceben.com/sales-cloud-top-salesforce-spring-26-features/">Sales Cloud: Top 8 Salesforce Spring ’26 Features — Salesforce Ben</a></li><li><a href="https://powerbi.microsoft.com/en-us/blog/power-bi-january-2026-feature-summary/">Power BI January 2026 Feature Summary — Microsoft</a></li><li><a href="https://github.com/microsoft/powerbi-modeling-mcp">Power BI Modeling MCP Server — Microsoft GitHub</a></li><li><a href="https://www.cio.com/article/4046967/the-end-of-dashboards-genai-and-agentic-workflows-transform-business-intelligence.html">The End of Dashboards? GenAI and Agentic Workflows Transform Business Intelligence — CIO</a></li><li><a href="https://appinventiv.com/blog/ai-ui-replacing-apps-and-buttons/">AI Agent-Driven UIs: Revolutionizing App Navigation &amp; Design — Appinventiv</a></li><li><a href="https://www.deloitte.com/us/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/ai-agent-orchestration.html">Unlocking Exponential Value with AI Agent Orchestration — Deloitte</a></li><li><a href="https://www.multimodal.dev/post/agentic-ai-statistics">10 AI Agent Statistics for 2026 — Multimodal.dev</a></li><li><a href="https://eightfold.ai/blog/most-important-job-2026/">The Most Important Job of 2026 is the AI Agent Orchestration Specialist — Eightfold AI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c577b0f5c2bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Claude Code Setup: A Practical Guide for Production Development]]></title>
            <link>https://medium.com/@nnrajesh3006/my-claude-code-setup-a-practical-guide-for-production-development-971cf47fccdc?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/971cf47fccdc</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 00:14:45 GMT</pubDate>
            <atom:updated>2026-01-20T00:45:26.113Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4nD6j_7ncrCJr5mieiUeSQ.png" /></figure><p>Every AI coding session starts the same way: you explain your project, your constraints, your preferences. Then Claude forgets. You explain again. It suggests something that would crash your app. You correct it. Rinse, repeat.</p><p>I spent a few weeks building a Rust + iOS application using Claude Code, but I kept encountering this recurring issue. The AI coding assistant was capable, but it had no memory. Every session was groundhog day.</p><p>Then I discovered that Claude Code has native features for persistent context — features that most developers don’t know exist. I built a system around them, and it changed everything.</p><p>This guide shares that system. It’s not theoretical. It’s the exact setup I use daily for production development.</p><p><strong>How to Use This Guide</strong></p><p>This guide is structured in three parts:</p><p><em>Part 1: The Concept</em> — Understand what we’re building and why it works. Read this first.</p><p><em>Part 2: Quick Start</em> — Get a working setup in 10 minutes. Follow this if you want to start using it today.</p><p><em>Part 3: Deep Dive</em> — Learn each component in detail. Reference this as you expand your setup.</p><p>If you’re skeptical, read Part 1. If you’re convinced, skip to Part 2. If you’re already using Claude Code and want to level up, jump to Part 3.</p><h3><strong>Part 1: The Concept:</strong></h3><p><strong>The Problem with AI Coding Assistants</strong></p><p>AI coding assistants are stateless. They don’t remember that your iOS app crashes if you use Metal GPU in background threads. They don’t know that your team prefers composition over inheritance. They can’t recall that you spent three hours last week explaining your database schema.</p><p>Every session, you start from zero.</p><p>Some developers cope by pasting context at the start of each conversation. Others maintain a text file of “things to tell Claude.” Both approaches are manual, error-prone, and don’t scale.</p><p><strong>The Solution: Structured Context</strong></p><p>Claude Code solves this with a simple but powerful feature: it automatically reads a file called `CLAUDE.md` at the start of every session.</p><p>This means you can write down your project context once, and Claude will know it forever.</p><p>But here’s the insight that took me months to discover: `CLAUDE.md` shouldn’t contain your context. It should <em>*point to*</em> your context.</p><p>Think of it like a table of contents in a book. The table of contents doesn’t contain the chapters — it tells you where to find them. Similarly, `CLAUDE.md` should be a lightweight router that directs Claude to detailed context files based on what you’re working on.</p><p>This approach has three benefits:</p><blockquote>1. Relevant context, not everything<strong> </strong>— When you’re working on iOS code, you don’t need database schema cluttering the context window. The router pattern loads only what’s needed.</blockquote><blockquote>2. Maintainable over time — Small, focused files are easier to update than one massive document.</blockquote><blockquote>3. Reusable across projects<strong> </strong>— Your iOS constraints file can be copied to any iOS project.</blockquote><h3><strong>The Architecture</strong></h3><p>The system I use has five components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TUxw8D0Ma7qsXeIbPOXnuw.png" /></figure><p><strong>CLAUDE.md</strong> is your entry point. It loads automatically and tells Claude where to find everything else.</p><p><strong>Memory</strong> holds context that changes over time: what you’re building, why you’re building it, where you are in the project, and what decisions you’ve made.</p><p><strong>Rules</strong> encode hard constraints — things that cause crashes, security vulnerabilities, or production outages if violated. These are non-negotiable.</p><p><strong>Personas</strong> define expert roles. Instead of Claude being a generalist, it can become an iOS specialist who prioritizes memory efficiency, or a database architect who thinks in schemas and indexes.</p><p><strong>Commands</strong> automate multi-step workflows. Instead of typing five git commands, you type `/commit` and Claude handles the rest.</p><h3><strong>Why This Works</strong></h3><p>The power of this system isn’t any single component — it’s how they work together.</p><p>When you edit a Swift file, Claude can automatically load your iOS constraints. When you ask about database changes, it can adopt the database architect persona. When you’re ready to commit, a single command handles staging, committing, pushing, and creating a pull request.</p><p>The result: Claude behaves like a team member who has read all your documentation, remembers all your decisions, and follows all your conventions. Not because it actually remembers, but because the relevant context loads automatically.</p><h3><strong>Part 2: Quick Start</strong></h3><p>You can have a working setup in 10 minutes. Here’s how.</p><p><strong>Step 1: Create the Folder Structure</strong></p><p>Open your terminal in your project root and run:</p><pre>mkdir -p .claude/memory .claude/rules .claude/personas .claude/commands</pre><p>This creates the folders you need. That’s the entire structure.</p><p><strong>Step 2: Create Your Entry Point</strong></p><p>Create a file at `.claude/CLAUDE.md`. This is the only file Claude loads automatically, so it’s your starting point.</p><p>Here’s a minimal version:</p><pre># Project: [Your Project Name]<br>## What This Is<br>[One paragraph describing your project]<br>## Quick Commands<br>- Build: `[your build command]`<br>- Test: `[your test command]`<br>- Run: `[your run command]`<br>## Context Files<br>When working on this project, reference these files for detailed context:<br>- Product &amp; business context: [productContext.md](memory/productContext.md)<br>- Technical architecture: [systemPatterns.md](memory/systemPatterns.md)<br>- Current status: [activeContext.md](memory/activeContext.md)</pre><p>Replace the bracketed sections with your project details. Keep it short — this file should be scannable in 30 seconds.</p><p><strong>Step 3: Add Your Business Context</strong></p><p>Create `.claude/memory/productContext.md`. This is where you explain <em>what</em> you’re building and <em>why</em>.</p><p>Write it like you’re onboarding a new team member. Cover:</p><p>- <em>The problem you’re solving</em> — What pain point does this address?</p><p>- <em>Who it’s for </em>— Who are your users?</p><p>- <em>How it works</em> — High-level description of the product</p><p>- <em>What success looks like </em>— How do you measure if it’s working?</p><p>This doesn’t need to be long. A few paragraphs is enough. The goal is to give Claude the business context it needs to make sensible suggestions.</p><p>For example, if you’re building a mobile app for busy professionals, Claude should know that. It will make different recommendations than if you’re building a data analysis tool for researchers.</p><p><strong>Step 4: Add Your Current Status</strong></p><p>Create `.claude/memory/activeContext.md`. This is your “where we are now” file.</p><p>Include:</p><p>- <em>Current focus</em> — What are you working on this week?</p><p>- <em>Recent decisions</em> — What did you decide and why?</p><p>- <em>Blockers </em>— What’s preventing progress?</p><p>- <em>Next steps</em> — What comes after the current task?</p><p>Unlike other files, this one changes frequently. Update it when you finish a major task, make a significant decision, or start a new work stream.</p><p>Pro tip: commit this file to git. When you start a fresh Claude session tomorrow, it will know exactly where you left off.</p><p><strong>That’s It</strong></p><p>You now have a working Claude Code setup. Start a new Claude Code session in your project, and it will automatically load your `CLAUDE.md`, which points to your context files.</p><p>The next time you ask Claude about your project, it will have context. Not because it remembered your last conversation, but because your context is encoded in files that persist.</p><p>Everything in Part 3 builds on this foundation. Add components as you feel the need — you don’t have to implement everything at once.</p><h3><strong>Part 3: Deep Dive</strong></h3><p><strong>3.1 The Entry Point: CLAUDE.md</strong></p><p>The most common mistake with `CLAUDE.md` is putting too much in it.</p><p>I’ve seen developers create 500-line files with their entire database schema, all their coding standards, every API endpoint, and their full product roadmap. This defeats the purpose. Claude’s context window fills up immediately, and most of that context is irrelevant to the current task.</p><p>`CLAUDE.md` should be a router, not a repository.</p><p>A good `CLAUDE.md` has three sections:</p><p><strong>Overview</strong> — What is this project, in one or two sentences? This orients Claude immediately.</p><p><strong>Quick reference</strong> — Build commands, test commands, common operations. Things you’d put on a sticky note.</p><p><strong>Pointers</strong> — Links to detailed context files, organized by when you’d need them. Working on the frontend? Here’s where to find UI patterns. Touching the database? Here’s the schema reference.</p><p>Keep the entire file under 50 lines. If it’s longer, you’re putting content in there that belongs in a separate file.</p><p><strong>3.2. Memory Files: Context That Evolves</strong></p><p>The `memory/` folder holds context about your project that changes over time.</p><p>I use three files:</p><p><strong>productContext.md</strong> answers “what are we building and why?” This is business context — the problem, the users, the goals. It changes when your product direction changes, which should be infrequent.</p><pre># Product Context<br><br>## Vision<br>What problem does this solve? For whom?<br><br>## Current Goals<br>What are we building this quarter?<br><br>## User Personas<br>Who uses this and how?</pre><p><strong>systemPatterns.md</strong> answers “how do we build things here?” This is technical context — your architecture, your patterns, your conventions. It changes when you adopt new patterns or make architectural decisions.</p><pre># System Patterns<br><br>## Architecture<br>- Frontend: React + TypeScript<br>- Backend: Rust + Tauri<br>- Database: SQLite with vector search<br><br>## Key Patterns<br>- Use repository pattern for data access<br>- All async operations use Result types<br>- UI components follow atomic design</pre><p><strong>activeContext.md</strong> answers “where are we right now?” This is session context — current tasks, recent decisions, blockers, next steps. It changes frequently, sometimes multiple times per day.</p><pre># Active Context<br><br>**Current Task**: Implementing user authentication<br>**Blocked By**: Waiting for OAuth credentials<br>**Last Updated**: 2025-01-19<br><br>## Recent Decisions<br>- Chose JWT over session tokens for mobile support<br>- Using bcrypt for password hashing<br><br>## Next Steps<br>1. Implement login endpoint<br>2. Add token refresh logic<br>3. Create auth middleware</pre><p>The key insight is separating stable context from volatile context. Your product vision doesn’t change often. Your current task changes constantly. By putting them in different files, you can update one without touching the others.</p><p><strong>3.3. Rules: Non-Negotiable Constraints</strong></p><p>Rules are different from context. Context helps Claude make good suggestions. Rules prevent Claude from making dangerous ones.</p><p>A rule should have three components:</p><p><strong>The constraint</strong> — State it clearly and unambiguously. “Never use Metal GPU in iOS Share Extensions.”</p><p><strong>The consequence</strong> — What happens if this rule is violated? “iOS will crash the app immediately with no recovery.”</p><p><strong>The correct approach</strong> — What should be done instead? “Use Vision framework, which runs on the Neural Engine and is safe in background contexts.”</p><p>The consequence is the most important part. Claude is more likely to follow a rule when it understands why the rule exists. “Don’t do X because it will crash” is more compelling than “Don’t do X.”</p><p>Organize rules by domain. I have separate files for iOS platform constraints, Rust language patterns, and database conventions. When I’m working on iOS code, I don’t need to load Rust rules, and vice versa.</p><pre># [Platform/Domain] Constraints<br><br>## Rule 1: [Short Name]<br><br>### The Rule<br>State it clearly in one sentence.<br><br>### Why<br>What breaks? What&#39;s the consequence?<br><br>### Wrong ❌<br>```code<br>// The pattern that causes problems<br>```<br><br>### Correct ✅<br>```code<br>// The pattern that works</pre><p><strong>3.4. Personas: Expert Roles</strong></p><p>Personas transform Claude from a generalist into a domain expert.</p><p>A generalist AI will give you correct but generic advice. An iOS specialist persona will give you advice that accounts for memory constraints, app lifecycle, and platform conventions. It will ask questions a real iOS developer would ask.</p><p>A persona file should define:</p><p><strong>Expertise</strong> — What does this expert know deeply? What frameworks, patterns, and tools are they fluent in?</p><p><strong>Priorities</strong> — What does this expert optimize for? An iOS specialist might prioritize memory efficiency and user experience. A database architect might prioritize query performance and data integrity.</p><p><strong>Decision framework</strong> — How does this expert approach problems? What questions do they ask? What tradeoffs do they consider?</p><pre># [Role] Persona<br><br>## Expertise<br>What does this expert know deeply?<br><br>## Priorities<br>What do they optimize for?<br><br>## Decision Framework<br>How do they approach problems?<br><br>## Common Tasks<br>What do they typically help with?</pre><p>You invoke a persona by referencing it in your `CLAUDE.md` (“When working on iOS code, act as the iOS specialist”) or explicitly in conversation (“Act as the database architect and review this schema”).</p><p>Personas are optional but powerful. Start without them, and add them when you find yourself repeatedly explaining the same domain-specific considerations.</p><p><strong>3.5. Commands: Automated Workflows</strong></p><p>Commands let you automate multi-step operations.</p><p>Create a markdown file in `.claude/commands/` describing the workflow. When you type the command name (like `/commit`), Claude executes the steps.</p><p>For example, a commit workflow might:</p><pre>1. Run `git status` to see what&#39;s changed<br>2. Run `git diff` to review the changes<br>3. Analyze the changes and draft a commit message<br>4. Stage the relevant files<br>5. Create the commit<br>6. Push to remote<br>7. Create a pull request if requested</pre><p>Instead of typing these commands manually, you type `/commit` and Claude handles it.</p><p>Good candidates for commands are operations that:</p><p>- Have multiple steps</p><p>- You do frequently</p><p>- Have consistent patterns</p><p>- Are error-prone when done manually</p><p>I use commands for git workflows, test execution, and build processes. Each encodes the “right way” to do something, so I don’t have to remember the details.</p><p><strong>3.6. Advanced: Automatic Context Injection</strong></p><p>Everything so far requires Claude to read files when you tell it to. But Claude Code supports something more powerful: hooks that run automatically.</p><p>Pre-tool hooks execute before Claude uses a tool. You can use them to inject context based on what Claude is about to do.</p><p>For example: when Claude is about to edit a Swift file, automatically load the iOS constraints. When it’s about to modify a database migration, load the schema reference.</p><p>This requires a small shell script that checks what file is being edited and outputs relevant context. The setup is more involved, so I recommend getting comfortable with the basic system first. Once you find yourself repeatedly loading the same context for the same types of files, hooks become worthwhile.</p><pre>Create `.claude/settings.json`:<br><br>json<br>{<br>  &quot;hooks&quot;: {<br>    &quot;preToolUse&quot;: [<br>      {<br>        &quot;matcher&quot;: &quot;Edit|Write&quot;,<br>        &quot;hooks&quot;: [<br>          {<br>            &quot;type&quot;: &quot;command&quot;,<br>            &quot;command&quot;: &quot;.claude/hooks/pre-tool-use.sh \&quot;$TOOL_NAME\&quot; \&quot;$TOOL_INPUT\&quot;&quot;<br>          }<br>        ]<br>      }<br>    ]<br>  }<br>}<br></pre><h3><strong>Where to Go From Here</strong></h3><p>Start simple. Create the folder structure, add your business context, and use it for a week.</p><p>Notice what context you keep repeating to Claude. That’s a signal to add it to your memory files.</p><p>Notice what mistakes Claude keeps making. That’s a signal to add a rule.</p><p>Notice what workflows you do repeatedly. That’s a signal to create a command.</p><p>The system grows with your needs. There’s no need to implement everything at once.</p><h3><strong>Final Thoughts</strong></h3><p>The insight behind this setup is simple: structure beats memory.</p><p>AI assistants don’t have persistent memory, but they can read files. By encoding your context in files that load automatically, you get the benefits of memory without relying on the AI to actually remember.</p><p>This isn’t about making Claude smarter. It’s about giving Claude the context it needs to be smart in your specific situation.</p><p>The Anthropic team built Claude Code with the right primitives — auto-loading files, custom commands, and tool hooks. This guide shows one way to use them. I’m sure there are others.</p><p>If you build something interesting with this approach, I’d like to hear about it.</p><p><em>For the foundational concepts behind context engineering, see my previous article: “</em><a href="https://medium.com/@nnrajesh3006/the-layer-i-was-missing-context-engineering-for-ai-c643b3c615fd"><em>The Layer I Was Missing: Context Engineering for AI.</em></a><em>”</em></p><p><em>A quick note: The visuals in this article were generated using Google NotebookLM, and Claude helped polish the writing. The technical discoveries and implementation? Those came from my weekend efforts. 😊</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=971cf47fccdc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Knowledge Graphs in Your Pocket: Entity Extraction Without the Cloud]]></title>
            <link>https://medium.com/@nnrajesh3006/knowledge-graphs-in-your-pocket-entity-extraction-without-the-cloud-5f54bb4d0010?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f54bb4d0010</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[knowledge-graph]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Tue, 13 Jan 2026 05:13:14 GMT</pubDate>
            <atom:updated>2026-01-13T05:13:14.049Z</atom:updated>
            <content:encoded><![CDATA[<h3>I built a knowledge graph with zero API calls. Here’s what I learned about Apple’s Neural Engine.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H_XqJNSUQlaSgVEPysGEpw.png" /></figure><h3>The Problem I Didn’t Know I Had</h3><p>During my winter break exploration into on-device AI, I kept hitting the same wall: a majority of AI apps or solutions I looked at relied on cloud APIs for entity extraction. OpenAI’s API for entity recognition. Google’s Natural Language API for relationship extraction. AWS Comprehend for named entity recognition.</p><p>They all promised the same thing: “Give us your text, and we’ll tell you who’s who, what’s what, and how they’re connected.”</p><p>But there was a catch. Actually, three catches:</p><ol><li><strong>Privacy</strong>: Every piece of text gets sent to someone else’s servers</li><li><strong>Latency</strong>: Round-trip API calls add 200–500ms per request</li><li><strong>Cost</strong>: $0.001–0.003 per 1,000 characters adds up fast</li></ol><p>I wondered: Could I build a personal knowledge graph entirely on-device, with zero cloud dependencies?</p><p>Turns out, the answer is yes. And Apple’s been quietly building the tools to do it since iOS 12.</p><h3>The Apple Neural Engine Secret</h3><p>Here’s what most developers miss: <strong>Apple’s NaturalLanguage framework runs on the Neural Engine (ANE), not the CPU or GPU.</strong></p><p>The Neural Engine is a specialized AI accelerator built into every iPhone since the iPhone X. On the latest chips, it delivers <strong>15.8 TFLOPS of AI processing power</strong> while consuming a fraction of the energy the GPU would use.</p><p>But here’s the kicker: the NaturalLanguage framework gives you direct access to this power with just a few lines of Swift code.</p><pre>import NaturalLanguage<br><br>let tagger = NLTagger(tagSchemes: [.nameType])<br>tagger.string = text<br><br>tagger.enumerateTags(<br>    in: text.startIndex..&lt;text.endIndex,<br>    unit: .word,<br>    scheme: .nameType<br>) { tag, range in<br>    if let tag = tag {<br>        let entity = String(text[range])<br>        print(&quot;\(entity): \(tag.rawValue)&quot;)<br>    }<br>    return true<br>}</pre><p>That’s it. <strong>No API keys. No server calls. No privacy trade-offs.</strong></p><p>And it extracts:</p><ul><li><strong>Person names</strong> (personalName)</li><li><strong>Places</strong> (placeName)</li><li><strong>Organizations</strong> (organizationName)</li></ul><h3>Building the Knowledge Graph</h3><p>The real challenge wasn’t extraction — it was <strong>canonicalization</strong>. How do you know “Apple”, “Apple Inc.”, and “Apple Computer” all refer to the same entity?</p><p>Cloud APIs solve this with massive entity databases. Google knows that “Apple” in a tech article probably means Apple Inc., while “apple” in a recipe means the fruit.</p><p>But on-device? You need a different strategy.</p><h4>The Entity Resolution Pipeline</h4><p>Here’s the architecture I landed on (still exploring better ways!):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zipCZRVU6BDkn2yYr4yzWg.png" /></figure><p><strong>1. Extract Raw Entities</strong></p><pre>struct Entity {<br>    let name: String              // &quot;Apple Inc.&quot;<br>    let type: EntityType          // .organization<br>    let mentionText: String       // Original text &quot;Apple&quot;<br>    let confidence: Double        // 0.0-1.0<br>    let offsetStart: Int<br>    let offsetEnd: Int<br>}</pre><p><strong>2. Normalize Names</strong></p><pre>func normalizeEntity(_ name: String, type: EntityType) -&gt; String {<br>    var normalized = name.trimmingCharacters(in: .whitespacesAndNewlines)<br>    // Remove common suffixes<br>    if type == .organization {<br>        normalized = normalized<br>            .replacingOccurrences(of: &quot;, Inc.&quot;, with: &quot;&quot;)<br>            .replacingOccurrences(of: &quot; LLC&quot;, with: &quot;&quot;)<br>            .replacingOccurrences(of: &quot; Corp.&quot;, with: &quot;&quot;)<br>    }<br>    // Lowercase for matching (store original for display)<br>    return normalized.lowercased()<br>}</pre><p><strong>3. Deduplicate with Fuzzy Matching</strong></p><p>For on-device fuzzy matching, I used <strong>Levenshtein distance</strong> with a threshold:</p><pre>func areEntitiesDuplicate(_ a: String, _ b: String) -&gt; Bool {<br>    let distance = levenshteinDistance(a, b)<br>    let maxLength = max(a.count, b.count)<br>    let similarity = 1.0 - (Double(distance) / Double(maxLength))<br>    return similarity &gt; 0.85  // 85% similarity threshold<br>}</pre><p><strong>4. Create Canonical Names</strong></p><p>The first high-confidence mention becomes the canonical name:</p><pre>func getCanonicalName(for entity: Entity) -&gt; String {<br>    // Check if we&#39;ve seen a similar entity before<br>    if let existing = findSimilarEntity(entity.name, type: entity.type) {<br>        return existing.canonicalName<br>    }<br>    // First high-confidence mention becomes canonical<br>    if entity.confidence &gt; 0.75 {<br>        return entity.name<br>    }<br>    return entity.mentionText<br>}</pre><h3>The Database Schema</h3><p>To make this work, I designed a <strong>three-table relational structure</strong>:</p><p><strong>entities</strong> — Knowledge graph nodes</p><pre>CREATE TABLE entities (<br>    id TEXT PRIMARY KEY,<br>    entity_type TEXT,           -- person, location, organization, concept<br>    name TEXT,                  -- Display name<br>    canonical_name TEXT,        -- Deduplicated identifier<br>    confidence REAL             -- 0.0-1.0 average across mentions<br>);</pre><p><strong>entity_mentions</strong> — Graph edges</p><pre>CREATE TABLE entity_mentions (<br>    id TEXT PRIMARY KEY,<br>    entity_id TEXT REFERENCES entities(id),<br>    capture_id TEXT,            -- Link to source document<br>    mention_text TEXT,          -- Original text span<br>    offset_start INTEGER,<br>    offset_end INTEGER<br>);</pre><p><strong>links</strong> — Entity relationships</p><pre>CREATE TABLE links (<br>    id TEXT PRIMARY KEY,<br>    from_entity_id TEXT REFERENCES entities(id),<br>    to_entity_id TEXT REFERENCES entities(id),<br>    link_type TEXT,             -- co-occurrence, references, related<br>    strength REAL,              -- 0.0-1.0<br>    auto_detected BOOLEAN<br>);</pre><p>The magic happens in the <strong>links</strong> table. When two entities appear in the same document, I create a co-occurrence link with strength proportional to proximity:</p><pre>func detectRelationships(in document: Document) -&gt; [Link] {<br>    let entities = document.entities<br>    var links: [Link] = []<br>    for i in 0..&lt;entities.count {<br>        for j in (i+1)..&lt;entities.count {<br>            let distance = abs(entities[i].offsetStart - entities[j].offsetEnd)<br>            // Entities within 100 characters get linked<br>            if distance &lt; 100 {<br>                let strength = 1.0 - (Double(distance) / 100.0)<br>                let link = Link(<br>                    fromEntityId: entities[i].id,<br>                    toEntityId: entities[j].id,<br>                    linkType: .coOccurrence,<br>                    strength: strength,<br>                    autoDetected: true<br>                )<br>                links.append(link)<br>            }<br>        }<br>    }<br>    return links<br>}</pre><h3>The Privacy Advantage</h3><p>This is where on-device processing shines.</p><p><strong>Cloud-based entity extraction:</strong></p><ul><li>❌ Every document sent to third-party servers</li><li>❌ Text content logged for model training</li><li>❌ Entity graphs reveal personal connections</li><li>❌ Subject to data breaches and subpoenas</li></ul><p><strong>On-device with NaturalLanguage framework:</strong></p><ul><li>✅ Text never leaves your device</li><li>✅ No API logs or audit trails</li><li>✅ Knowledge graph stays local</li><li>✅ Works offline (airplane mode, no connection)</li></ul><p>For personal data management, this privacy advantage is <strong>non-negotiable</strong>. Your notes, highlights, and captured content shouldn’t be training someone else’s AI models.</p><h3>Performance Reality Check</h3><p>Let’s talk numbers. I tested on an iPhone 14 Pro with a mix of web articles, PDFs, and text notes.</p><p><strong>Processing Time (per 1,000 words):</strong></p><ul><li>Entity extraction: <strong>~80ms</strong> (NaturalLanguage framework on ANE)</li><li>Canonicalization: <strong>~15ms</strong> (string matching + Levenshtein distance)</li><li>Database insert: <strong>~5ms</strong> (SQLite with batch inserts)</li><li><strong>Total: ~100ms per document</strong></li></ul><p><strong>Comparison to Cloud APIs:</strong></p><ul><li>OpenAI GPT-4 entity extraction: <strong>~800ms</strong> (network latency + inference)</li><li>Google Natural Language API: <strong>~400ms</strong> (network latency)</li><li>AWS Comprehend: <strong>~350ms</strong> (network latency)</li></ul><p><strong>On-device is 3–8x faster</strong> when you factor in network round-trips.</p><p><strong>Accuracy (manual validation on 100 documents):</strong></p><ul><li>Precision (% of extracted entities that are correct): <strong>91.2%</strong></li><li>Recall (% of actual entities found): <strong>87.5%</strong></li><li>F1 Score: <strong>89.3%</strong></li></ul><p>Cloud APIs (GPT-4, Google NLP) score <strong>92–95% F1</strong>, but the 5–6% gap disappears when you consider:</p><ul><li>No network failures or timeouts</li><li>No API rate limits or quotas</li><li>No cost per request</li><li>Perfect privacy</li></ul><h3>When On-Device Falls Short</h3><p>Let’s be honest: there are limits.</p><p><strong>What NaturalLanguage framework does well:</strong></p><ul><li>Person names (e.g., “Steve Jobs”, “Marie Curie”)</li><li>Place names (e.g., “San Francisco”, “Mount Everest”)</li><li>Organization names (e.g., “Apple”, “United Nations”)</li></ul><p><strong>What it struggles with:</strong></p><ul><li><strong>Domain-specific entities</strong>: “JAK2 V617F mutation” (medical), “ERC-721” (crypto)</li><li><strong>Disambiguating context</strong>: “Apple” the company vs. “apple” the fruit</li><li><strong>Complex relationships</strong>: “Steve Jobs founded Apple in 1976 with Steve Wozniak”</li></ul><p>For these cases, you need either:</p><ol><li><strong>Fine-tuned models</strong> (Core ML + custom training data)</li><li><strong>Hybrid approach</strong> (on-device first, cloud for edge cases)</li><li><strong>Rule-based augmentation</strong> (regex patterns for domain terms)</li></ol><p>I went with option 3: augmenting NaturalLanguage with lightweight regex patterns for common domain-specific entities.</p><h3>Real-World Use Cases</h3><p>Here’s what I’ve built with this on-device knowledge graph:</p><p><strong>1. Automatic Tag Suggestions</strong> When saving a new article, the knowledge graph suggests tags based on previously extracted entities. If “Steve Jobs” appears in 15 articles tagged #technology and #business, the next article mentioning him gets auto-suggested with those tags.</p><p><strong>2. Connection Discovery</strong> Query: “What connects Person X and Organization Y?” The graph traverses entity links to find shared documents, co-mentioned people, and overlapping topics.</p><p><strong>3. Entity Timeline</strong> For any entity (person, place, organization), show a chronological feed of every mention across all captured content. Like a personal Wikipedia built from your own reading history.</p><p><strong>4. Contextual Search</strong> Instead of keyword search, search by entity: “Show me everything related to Apple” returns articles about the company, iPhone launches, Steve Jobs interviews, and App Store news — even if those documents don’t mention “Apple” directly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xDwXx57zdoj-M9GQQWUnTA.png" /></figure><h3>The Broader Trend: On-Device NLP is Here</h3><p>Apple’s not alone in pushing AI to the edge. Here’s what’s happening industry-wide:</p><ul><li><strong>Meta’s Llama models</strong>: Now runnable on-device with quantization (3B params in ~2GB)</li><li><strong>Google’s Gemini Nano</strong>: On-device LLM for Pixel phones</li><li><strong>Microsoft’s Phi-2</strong>: 2.7B parameter model optimized for mobile</li></ul><p>But Apple’s advantage is <strong>ecosystem integration</strong>. The Neural Engine, NaturalLanguage framework, Core ML, and Vision framework work seamlessly together — and they’ve been shipping on every iPhone for years.</p><p>Most developers just haven’t discovered them yet.</p><h3>Key Takeaways</h3><p>If you’re building AI-powered apps in 2026, here’s what I learned:</p><ol><li><strong>Check on-device first</strong>: Before reaching for cloud APIs, see if Apple’s frameworks (NaturalLanguage, Vision, Core ML) can handle it. You might be surprised.</li><li><strong>Privacy is a feature</strong>: Users are waking up to data privacy. “Runs entirely on your device” is becoming a competitive advantage.</li><li><strong>Optimize for ANE</strong>: If you’re training custom Core ML models, profile for Neural Engine performance. It’s 10x faster than CPU for NLP tasks.</li><li><strong>Entity resolution matters</strong>: Extracting entities is easy. Canonicalizing them without a massive entity database requires thoughtful design.</li><li><strong>Graph queries unlock value</strong>: Once you have entities + relationships in a graph structure, you can answer questions that keyword search can’t touch.</li></ol><h3>Further Reading</h3><p>If you missed my previous posts on ‘on-device AI’:</p><ul><li><a href="#"><strong>The Tiered Inference Strategy: Solving the iOS Background Crash Problem</strong></a> — How to run LLMs in iOS Share Extensions without triggering Metal GPU crashes</li><li><a href="#"><strong>The Layer I Was Missing: Context Engineering for AI</strong></a> — Building a Memory Bank system for persistent AI context across sessions</li></ul><p><strong>Have you experimented with on-device NLP?</strong> What frameworks or techniques have you found most effective? Drop a comment — I’d love to hear about your experiences.</p><p>#GenAI #OnDeviceAI #KnowledgeGraphs #Privacy #iOS #MachineLearning #NaturalLanguage</p><h3>Sources</h3><ul><li><a href="https://developer.apple.com/documentation/NaturalLanguage">Apple Natural Language Framework Documentation</a></li><li><a href="https://dl.acm.org/doi/10.1145/3724420">Empowering Edge Intelligence: A Comprehensive Survey on On-Device AI Models (ACM Computing Surveys)</a></li><li><a href="https://astrikos.ai/on-device-ai-vs-cloud-ai-whats-better-for-tomorrows-smart-infrastructure/">On-Device AI vs Cloud AI — Astrikos AI</a></li><li><a href="https://towardsdatascience.com/entity-resolved-knowledge-graphs-6b22c09a1442/">Entity-Resolved Knowledge Graphs (Towards Data Science)</a></li><li><a href="https://machinelearning.apple.com/research/neural-engine-transformers">Deploying Transformers on the Apple Neural Engine (Apple ML Research)</a></li><li><a href="https://en.wikipedia.org/wiki/Neural_Engine">Apple Neural Engine Performance Evolution (Wikipedia)</a></li><li><a href="https://blog.graphlet.ai/the-rise-of-semantic-entity-resolution-45c48d5eb00a">The Rise of Semantic Entity Resolution (Graphlet AI Blog)</a></li></ul><p><em>A quick note: The visuals in this article were generated using Google NotebookLM, and Claude helped polish the writing. The technical discoveries and implementation? Those came from my weekend efforts. 😊</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f54bb4d0010" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Layer I Was Missing: Context Engineering for AI]]></title>
            <link>https://medium.com/@nnrajesh3006/the-layer-i-was-missing-context-engineering-for-ai-c643b3c615fd?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/c643b3c615fd</guid>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[ai-on-device]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 19:23:42 GMT</pubDate>
            <atom:updated>2026-01-05T19:42:10.759Z</atom:updated>
            <content:encoded><![CDATA[<p>Why “Prompt Engineering” wasn’t enough to build my on-device AI app.</p><p>In my <a href="https://medium.com/@nnrajesh3006/the-tiered-inference-strategy-solving-the-ios-llm-background-crash-7e1195453188">first post</a>, I shared what I learned about on-device AI — a “Tiered Inference” strategy for handling the technical challenges of running LLMs on mobile devices.</p><p>That was the technical puzzle.</p><p>This post is about something else I discovered along the way — something I didn’t expect to be the harder problem.</p><h3>The Walls I Kept Hitting</h3><p>My holiday break project seemed straightforward: use AI tools to help me build an on-device AI experience. Learn by doing.</p><p>But I kept running into the same frustrations:</p><p><strong>The forgetting problem.</strong> Every new session, I’d have to re-explain what the project was about. What we’d already decided. What approaches we’d tried and rejected. The AI had no memory of our previous work together.</p><p><strong>The limit problem.</strong> Context windows would fill up. Sessions would hit caps. I’d have to start fresh, losing continuity.</p><p><strong>The drift problem.</strong> Even within a session, as conversations got longer, the AI would lose track of earlier context. It would suggest things we’d already ruled out, or contradict decisions we’d made twenty messages ago.</p><p>I’d spend 20 minutes getting the AI to understand my folder structure, only for it to hallucinate a file path three prompts later. I wasn’t coding; I was constantly reminding the AI who it was.</p><p>I assumed these were just technical limitations I had to work around. The cost of using AI tools in their current state.</p><p>But the more I worked through it, the more I realized: I wasn’t managing context well. And neither were the tools.</p><h3>The Realization</h3><p>Here’s what shifted for me.</p><p>I started treating every session like it was standalone — feed in the prompt, get the output, move on. When I hit limits, I’d just start over and re-explain everything.</p><p>But that approach meant I was doing the same work repeatedly. And the AI couldn’t build on what it had learned because I wasn’t giving it a way to retain and organize that knowledge.</p><p>The problem wasn’t the AI’s capability. The problem was <strong>context</strong> — how I was (or wasn’t) structuring the information the AI needed to help me effectively.</p><p>When I started researching this, I found I wasn’t alone.</p><h3>A Term I Hadn’t Heard Before</h3><p>In my reading, I kept encountering a phrase that barely existed a year ago: <strong>context engineering.</strong></p><p>Anthropic’s team describes it this way:</p><blockquote><em>“Building with language models is becoming less about finding the right words and phrases for your prompts, and more about answering the broader question of ‘what configuration of context is most likely to generate our model’s desired behavior?’”</em></blockquote><p>Shopify’s CEO Tobias Lütke put it more simply:</p><blockquote><em>“I really like the term ‘context engineering’ over prompt engineering. It describes the core skill better: the art of providing all the context for the task to be plausibly solvable by the LLM.”</em></blockquote><p>This distinction clicked for me immediately.</p><p><strong>Prompt engineering</strong> = crafting the right question.</p><p><strong>Context engineering</strong> = designing what the AI knows, remembers, and can access when it tries to answer.</p><p>I’d been focused on writing better prompts. But my real problem was that the AI didn’t have the right context to work with — and I hadn’t built a system to provide it.</p><h3>What I Started Doing Differently</h3><p>Once I had this framing, I changed my approach.</p><p><strong>I built a “Memory Bank.”</strong> Instead of assuming the AI would “remember,” I created a structured repository of context that persists across sessions:</p><ul><li><strong>Project brief</strong>: What are we building and why?</li><li><strong>Decision log</strong>: What did we decide, and what was the reasoning?</li><li><strong>Technical context</strong>: Architecture, patterns, constraints</li><li><strong>Progress tracker</strong>: What’s done, what’s in progress, what’s blocked?</li></ul><p>Practically speaking, my Memory Bank started as a simple folder of Markdown files (projectContext.md, decisions.md, progress.md). Before starting a task, I wouldn&#39;t just type a prompt—I&#39;d explicitly load the relevant context files. It wasn&#39;t high-tech, but it forced a separation between <strong>storage</strong> (the bank) and <strong>working memory</strong> (the active chat).</p><p>This became the source of truth. Before each session, the relevant parts of the Memory Bank get loaded in. After each session, I update it with new decisions and learnings.</p><p><strong>I separated “Active Context” from the Memory Bank.</strong> Not everything in the Memory Bank is relevant to every task. So I created an Active Context layer — a curated subset that’s specific to what I’m working on right now.</p><p>Think of it this way:</p><ul><li><strong>Memory Bank</strong> = everything the project knows (persistent, comprehensive)</li><li><strong>Active Context</strong> = what this specific task needs to know (focused, current)</li></ul><p>This separation was key. It allowed me to treat the LLM as different “agents” — a UI persona, a Backend persona, a QA persona — feeding each one only the slice of the Memory Bank they needed. These weren’t autonomous agents running in parallel; they were roles I’d ask the LLM to play, each with tailored context for their specific task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1JekedCGwDDw6JfQ8DMhAQ.png" /><figcaption><em>A central Memory Bank feeding specific context to role-based agents. (courtesy: Gemini Nano)</em></figcaption></figure><p><strong>I got intentional about what goes where.</strong> Not everything is equally important. I started thinking in layers:</p><ul><li><strong>Shared context</strong>: Project goals, architecture decisions, constraints — things every role needs</li><li><strong>Task context</strong>: Specific requirements, relevant code, immediate history — things only this task needs</li><li><strong>Disposable context</strong>: Scratch work, exploration, dead ends — things that shouldn’t pollute the Memory Bank</li></ul><p><strong>I planned for context maintenance.</strong> Context isn’t static. As my project evolved, earlier decisions became outdated. I had to actively update and prune, not just accumulate. The Memory Bank needs gardening, not just filling.</p><p><strong>I accepted that some context work is manual.</strong> There’s no escaping it — someone has to decide what context matters, keep it current, and structure it for the AI. Right now, that someone is me. The tools don’t do this automatically (yet).</p><h3>The Bigger Pattern</h3><p>As I researched context engineering, I noticed something interesting.</p><p>The challenges I was hitting on my small personal project? They scale up. The same problems show up in any AI implementation — just bigger and more expensive.</p><p>AI systems that don’t retain learning. Workflows that require constant re-explanation. Agents that hallucinate because they lack the information they need.</p><p>And the same solution applies: think about context deliberately, not as an afterthought.</p><p>What stuck with me: there’s now an emerging ecosystem around context — protocols like MCP (Model Context Protocol), tools specifically for context management, frameworks adding state persistence as a core feature. When infrastructure gets built around a concept, it’s no longer theoretical.</p><p>The divide I keep reading about — between AI implementations that work and those that don’t — seems to come down to this. Not who has better models or more compute. But who has thought carefully about context.</p><h3>Resources That Helped Me</h3><p>Part of my learning process was collecting resources. Here’s what I found most useful:</p><p><strong>The Foundational Read</strong></p><ul><li><a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">Anthropic: Effective Context Engineering for AI Agents</a> — This is where the concept clicked for me. Worth reading start to finish.</li></ul><p><strong>Frameworks to Understand</strong></p><ul><li><strong>Model Context Protocol (MCP)</strong>: A standard for how AI systems connect to context sources (documents, tools, databases)</li><li><strong>LangGraph</strong>: Focuses on stateful AI workflows — maintaining context across steps</li><li><strong>CrewAI</strong>: Role-based AI agents with structured ways to share context between them</li></ul><p><strong>For Continued Learning</strong></p><ul><li>Latent Space podcast (swyx &amp; Alessio) — Practitioner-focused discussions on AI development</li><li>Thoughtworks Technology Radar — Now tracks context management as an emerging practice</li></ul><h3>What I’m Taking Away</h3><p>I started this holiday project to learn about on-device AI. I didn’t expect the bigger lesson to be about context.</p><p>But looking back, it makes sense. The AI models are impressive. The frameworks are powerful. The compute is accessible.</p><p>What’s not solved — what I have to solve for my own project — is the context layer:</p><ul><li>Where does the knowledge come from that the AI needs?</li><li>How do I keep it current?</li><li>How do I structure it so the AI can actually use it?</li><li>How do I maintain it over time as things change?</li></ul><p>These aren’t glamorous questions. But I’m increasingly convinced they’re the ones that matter.</p><h3>Still Figuring It Out</h3><p>I’m two posts into this learning journey. I don’t have it all figured out.</p><p>But I wanted to share this because the term “context engineering” was new to me a few weeks ago — and understanding it has already changed how I approach my project.</p><p>If you’re building with AI tools and hitting similar walls, maybe it’s not about better prompts or more powerful models.</p><p>Maybe it’s about context.</p><p><em>This is Part 2 of my holiday learning series. </em><a href="https://medium.com/@nnrajesh3006/the-tiered-inference-strategy-solving-the-ios-llm-background-crash-7e1195453188"><em>Part 1 covered the Tiered Inference Strategy</em></a><em> for on-device AI.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c643b3c615fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Tiered Inference Strategy: Solving the iOS LLM Background Crash]]></title>
            <link>https://medium.com/@nnrajesh3006/the-tiered-inference-strategy-solving-the-ios-llm-background-crash-7e1195453188?source=rss-849514a33289------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e1195453188</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[coreml]]></category>
            <category><![CDATA[ai-on-device]]></category>
            <dc:creator><![CDATA[Rajesh Naga Nekkanti]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 18:25:37 GMT</pubDate>
            <atom:updated>2026-01-02T18:25:37.817Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why your on-device AI fails when the screen goes dark — and how to use the Apple Neural Engine (ANE) to fix it.</h3><p>The “100ms rule” is the gold standard for mobile UX. When a user initiates a data-heavy capture via a system extension, they expect the app to acknowledge it instantly and “figure the rest out later.”</p><p>In the world of on-device LLMs, “figuring it out later” usually means background processing. But if you’re using popular libraries like llama.cpp, your &quot;later&quot; is likely ending in a crash.</p><p>If you’ve seen IOGPUMetalError: Insufficient Permission, you’ve hit the hard wall of iOS security: <strong>The GPU is a foreground-only citizen.</strong></p><h3>The Wall: Why GGUF + Background = Crash</h3><p>Most developers start with GGUF models because the ecosystem is vast. You link llama.cpp, set gpu_layers = 99, and it’s blazing fast. Then you try to run that same logic in a Background Task or a Share Extension.</p><p><strong>The result?</strong> A fatal crash.</p><p>The root cause isn’t just that the GPU is busy; it’s that iOS prohibits the initialization of a Metal compute context from a background thread to preserve thermal headroom and battery. Even if you set gpu_layers = 0, many Rust and Swift wrappers for llama.cpp eagerly initialize the Metal backend at the library level the moment the model loads.</p><h3>The Exploration: Why “Hacking” Fails</h3><p>Before arriving at a stable architecture, I explored the common “quick fixes” that most teams eventually regret:</p><ol><li><strong>The Lazy-Init Patch:</strong> Forking the C++ library to defer Metal setup. <em>Maintenance Nightmare:</em> Every time the upstream library updates, your fork breaks.</li><li><strong>The Dual-Binary Bloat:</strong> Bundling one CPU-only and one GPU-enabled binary. <em>UX Killer:</em> Your app size doubles, and dynamic loading on iOS is a signing minefield.</li><li><strong>Manual Processing:</strong> Forcing the user to open the app to start the “intelligence” phase. <em>Retention Killer:</em> If the AI isn’t ready when the user opens the app, the magic is gone.</li></ol><h3>The Solution: Tiered Inference (The Handoff)</h3><p>The most efficient way to build on-device AI in 2026 isn’t to pick one engine — it’s to orchestrate the <strong>Background-to-Foreground Handoff.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vI9tEz1McvzxH6PUW5o-Ow.png" /><figcaption>Image Courtesy — Gemini Nano</figcaption></figure><h3>Tier 1: The Background (Core ML + ANE)</h3><p>On iOS, the <strong>Apple Neural Engine (ANE)</strong> is the hero of the background. Unlike the GPU, the ANE is managed by Core ML, which handles background transitions gracefully.</p><ul><li><strong>The Strategy:</strong> Use a highly quantized Core ML model (like Llama-3.2–1B in 4-bit) for the initial data triage.</li><li><strong>The Result:</strong> The ANE processes the capture while the phone is in the user’s pocket. It’s low-power, thermal-safe, and perfectly legal in the eyes of the OS.</li></ul><h3>Tier 2: The Foreground (Metal + GPU)</h3><p>Once the user enters the app, you unleash the full power of the GPU for deeper reasoning or interactive chat.</p><ul><li><strong>The Strategy:</strong> Use your existing GGUF/Metal implementation.</li><li><strong>The Result:</strong> Because the app is now in the foreground, you have permission to use the GPU at full tilt. You can “refine” the background work or provide a chat interface with zero latency.</li></ul><h3>Implementation: The Rust-Swift Bridge</h3><p>To make this work in a cross-platform framework like Tauri, you need a conditional “Dual-Path” logic. In your processor.rs:</p><pre>async fn process_data_capture(&amp;self, raw_content: String) {<br>    #[cfg(target_os = &quot;ios&quot;)]<br>    {<br>        // Check if we are in the background<br>        if is_background_thread() {<br>            // CALL SWIFT BRIDGE: Run Core ML (ANE)<br>            let result = core_ml_bridge::quick_analyze(raw_content).await;<br>            self.db.store_preliminary(result);<br>        }<br>    }<br>    #[cfg(not(target_os = &quot;ios&quot;))]<br>    {<br>        // Desktop/Android: Standard llama.cpp GPU path<br>        llm_engine::full_inference(raw_content).await;<br>    }<br>}</pre><h3>Why This Wins in 2026</h3><p>By adopting a tiered approach, you stop fighting the OS and start working with the hardware. You provide a “Zero-Wait” experience where the intelligence is ready the moment the screen turns on — all while keeping your app’s power footprint within Apple’s strict guidelines.</p><p>Stay tuned to learn more about my journey in building on device intelligence with Privacy and reduced costs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e1195453188" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>