Context Window

The MCP Tax: Why Heavyweight AI Agents Are Going Broke (and Getting Dumber)

March 31, 202619:00Context Window

This episode explores the paradox where giving advanced AI coding agents more context makes them perform worse and cost more, a phenomenon dubbed "Context Rot" and "token tax." It discusses how GitHub Copilot's ambitious Model Context Protocol faces this challenge, while highlighting the rise of lightweight, local-first tools like ZeroClaw. Listeners will learn about the exorbitant "plumbing bill" of injecting tool schemas and how major AI companies are now building frameworks to use fewer tokens, acknowledging the breaking point of context bloat.

Key Takeaways

Detailed Report

The AI Agent Paradox: Why More Context Means Less Intelligence

Advanced AI coding agents are facing a structural paradox: the conventional wisdom of providing more context and tools to Large Language Models (LLMs) is proving to be financially ruinous and actively degrading their performance. This phenomenon, dubbed the "MCP Tax" and "Context Rot," is forcing industry giants to re-evaluate their strategies while lightweight, local-first tools gain significant traction.

The Costly Burden of the Model Context Protocol (MCP)

GitHub's aggressive rollout of its Copilot Model Context Protocol (MCP) server, exposing over 40 distinct tools, aims to centralize and own the software development lifecycle's routing layer. However, this ambitious ecosystem play faces a fundamental challenge from the physics of LLM context windows.

The $1,600/Day Plumbing Bill

The core issue with MCP is its architectural implementation. To utilize an MCP server, an agent must inject the JSON schema definitions of *every available tool* into its context window at the start of each session, even before processing user code. For GitHub's Copilot, this initial "plumbing" consumes 44,000 to 55,000 tokens per session. At current pricing, this translates to roughly $0.16 per session. For a mid-sized enterprise running 10,000 automated agent sessions daily, this amounts to a staggering $1,600 burned every day, solely for tool definitions the agent may never use.

Context Rot: The Reliability Crisis

Beyond cost, the "load-everything-upfront" approach leads to a significant reliability crisis. A March 2026 benchmark by authentication provider Scalekit rigorously compared CLI versus MCP on Claude Sonnet 4, revealing devastating results for schema bloat.

CLI Dominance in Cost and Reliability

The benchmarks showed CLI to be 10x to 32x cheaper than MCP. For a simple query like "What language is this repo?", a CLI agent used 1,365 tokens, while an MCP agent consumed 44,026 tokens—the delta entirely due to unused tool definitions. This resulted in a 17x cost multiplier for MCP over CLI for 10,000 operations.

More critically, MCP exhibited a 28% failure rate (72% reliability) compared to a 100% reliability score for local CLI tools. This failure rate was not due to AI errors but entirely to TCP-level connection timeouts to remote GitHub servers. The inherent reliability of a local CLI binary, running directly on the machine without remote server dependencies, proved unmatched.

The Counterintuitive Truth: More Context, Dumber AI

The most profound issue is "Context Rot," where increasing information actively makes AI models dumber. Foundational research from Stanford University's "Lost in the Middle" paper demonstrated that LLMs exhibit a U-shaped performance curve, reliably recalling information at the beginning and end of a prompt but suffering catastrophic recall failure for information buried in the middle.

Chroma Research's July 2025 report, "Context Rot: How Increasing Input Tokens Impacts LLM Performance," formalized this. Testing 18 frontier models, including GPT-4.1, they found that *every single model* degraded in reliability as input length increased, with performance dropping by 20% to 50% as token counts moved from 10k to 100k.

How Context Rot Impacts MCP

Because MCP schemas are injected into the system prompt or early conversation history, as a session progresses and the context window fills, these critical tool instructions inevitably slide into the "middle"—the zone where recall drops by over 30%. This causes models to hallucinate tool parameters or forget tools exist. Additionally, injecting related but irrelevant information, such as 42 unused MCP tool schemas, acts as "semantic noise," confusing the model's structured attention mechanisms. LLMs have a finite "attention budget"; every token wasted on unused JSON schemas is a token stolen from core reasoning capabilities.

The Quadratic Trap in Multi-Turn Agents

This context bloat is exacerbated in multi-turn agent tasks. If the base payload is already bloated by 50,000 tokens of MCP schemas, the token count grows quadratically with each turn, pushing costs to unsustainable levels and guaranteeing that the agent will succumb to Context Rot before completing the job.

The Antidote: Skills + CLI and Progressive Disclosure

In response to these challenges, frontier model builders like Anthropic, OpenAI, and Google are pivoting to a "Skills" architecture for their CLI tools, based on the principle of progressive disclosure.

Progressive Disclosure and Agent Skills

Instead of loading an entire encyclopedia of tools upfront, progressive disclosure provides information in three tiers:

  • Metadata (10-30 tokens): A brief description, like "Use this to query the Jira database."
  • Full Instructions (200-2,000 tokens): Loaded dynamically *only* when the agent decides it needs that specific skill.
  • Reference Docs: Loaded only for deep-dive documentation or edge-case errors.

This contrasts sharply with an MCP "Tool," which exposes a rigid API endpoint. An Agent "Skill" provides domain context and behavioral guardrails, teaching the agent *how* to behave within specific business contexts, not just providing a button to push. Benchmarks show agents perform best with two to three focused skills per task, with narrowly scoped skills outperforming generalized ones in task completion rates.

The Unix Philosophy and Ephemeral Code Execution

LLMs, trained on vast amounts of open-source code, naturally "speak" Unix. CLI-based agents can natively chain Unix pipes in a single command, like `grep "error" app.log | jq '.message' | xargs echo`, requiring minimal context overhead. In contrast, the same result via MCP would necessitate sequential, prescriptive round-trips, stifling improvisation, burning context, and increasing latency.

The most advanced pattern emerging is bypassing tool calls entirely in favor of ephemeral code execution. For instance, an agent analyzing a massive dataset can write a script to filter data locally, execute it via CLI, and then read only the concise output back into its context window, dramatically reducing token usage and boosting reasoning accuracy.

The File System as Memory

Advanced agents are deprecating the context window as a state store. Instead of carrying conversational history and data in the LLM's memory, they use the local file system as long-term memory, writing state to local markdown or JSON files and reading it only when necessary, thus keeping the active context window pristine.

The Hybrid Future: Right Tool for the Right Job

The verdict is not that MCP is obsolete, but that its role must be refined. The question is who the agent is acting for. For developer tools, local data orchestration, personal workflows, or token-sensitive scaling on *your* machine, ambient CLI credentials are superior.

However, for multi-tenant SaaS, enterprise environments requiring strict OAuth boundaries, and compliance auditing, MCP remains necessary. If the agent acts on behalf of *other people's users* across third-party services, MCP's structured authorization is legally and architecturally required.

The ultimate enterprise architecture of 2026 is the Hybrid Stack: "Skills" as the intelligence and routing layer, CLI handling all local code execution and data filtering to protect the context window, and MCP acting strictly as the governed gateway for external access, utilized only when crossing network and identity boundaries. This approach leverages the strengths of each method while mitigating their inherent limitations.

Show Notes

Works Referenced

  • Lost in the Middle: How Language Models Use Long Contexts: Foundational research from Stanford University proving LLMs exhibit a U-shaped performance curve where recall suffers for information in the middle of a prompt.
  • Context Rot: How Increasing Input Tokens Impacts LLM Performance: A landmark report published by Chroma Research in July 2025, formalizing the phenomenon of context degradation in LLMs as input length increases.
  • Model Context Protocol (MCP): A protocol designed for LLMs to integrate with external tools, identified as a source of significant cost and reliability issues due to excessive context loading.
  • GitHub Copilot: An AI coding agent that aggressively rolled out its official MCP server, exposing numerous tools to its ecosystem, serving as a primary example of the "MCP Tax."
  • OpenClaw: A popular open-source autonomous agent, noted for its efficiency and community adoption.
  • ZeroClaw: A hyper-optimized Rust alternative to OpenClaw, praised for its tiny binary size, low RAM usage, and lightning-fast response times, embodying a local-first approach.
  • Anthropic: An AI company that experienced a Claude Code leak and is actively formalizing "Agent Skills" specifications for its CLI tools.
  • OpenAI Codex: An AI model mentioned alongside Anthropic and Google for formalizing "Agent Skills" specifications for CLI tools.
  • Google Gemini: An AI model mentioned alongside Anthropic and OpenAI for formalizing "Agent Skills" specifications for CLI tools.
  • Scalekit: An authentication provider that published rigorous benchmarks in March 2026, comparing CLI versus MCP performance and reliability, highlighting MCP's inefficiencies.
  • Claude Sonnet 4: A large language model from Anthropic, used in benchmarks to illustrate the cost implications of token usage.
  • GPT-4.1: A frontier model mentioned as one of the 18 models tested in Chroma Research's "Context Rot" report.
  • Unix Philosophy: A software design philosophy emphasizing building simple, modular tools that can be combined, which LLMs naturally excel at for chaining commands.

Glossary

  • Model Context Protocol (MCP): A protocol designed for LLMs to integrate with external tools, which, despite its intent, can lead to significant cost and reliability issues due to the requirement of injecting large tool schemas into the LLM's context.
  • Token Tax: The hidden, exorbitant cost incurred when an LLM consumes a large number of tokens for "plumbing" information, such as tool schemas, before it can even begin to perform actual work.
  • Context Rot: A phenomenon where an LLM's reasoning and recall capabilities degrade as the amount of input text in its context window increases, especially when irrelevant information is present, leading to decreased reliability.
  • Context Window: The limited amount of text (measured in tokens) that an LLM can process and "remember" at any given time, impacting its ability to reason and recall information.
  • LLM (Large Language Model): An artificial intelligence model trained on vast amounts of text data, capable of understanding, generating, and reasoning with human language.
  • Progressive Disclosure: An interaction design principle applied to AI agents, where information or functionality (like detailed tool instructions) is revealed only when the agent decides it is needed, optimizing context usage.
  • Agent Skills: A new architecture for AI agents that provides dynamically loaded capabilities, offering domain context and behavioral guardrails rather than just rigid API endpoints, enabling more efficient and contextualized agent behavior.
  • CLI (Command Line Interface): A text-based interface used to interact with computer programs, which efficient AI agents leverage for local code execution, Unix piping, and data filtering to protect the context window.
  • Quadratic Trap: A problem in multi-turn AI agent loops where the token count, and thus cost, grows exponentially with each interaction, making unconstrained, multi-turn tasks unsustainable and prone to Context Rot.
  • Attention Budget: The finite capacity an LLM has to focus its processing power on different parts of its input, implying that every token spent on irrelevant information detracts from its core reasoning and logic capabilities.
  • Unix Philosophy: A software development philosophy that advocates for building simple, modular, and interoperable programs, which aligns with how LLMs can efficiently chain local CLI commands.

Full Transcript

HostImagine paying a massive premium for a service, only to find out that the more you pay, the worse the service gets. That's precisely what's happening with some of the most advanced AI coding agents right now.
ExpertIt's a structural paradox. The prevailing wisdom has been: give an LLM more context, more tools, more information, and it will perform better. But new data shows that this approach isn't just financially ruinous; it's actively making these sophisticated AI models dumber.
HostWe're talking about a "token tax" that's costing enterprises thousands of dollars a day just for "plumbing" and a phenomenon called "Context Rot" that's tanking reliability.
ExpertAnd the industry giants are quietly scrambling to fix it, while a new wave of lightweight, local-first tools are eating their lunch.
HostLet's get caught up on the critical movements in the world of AI coding. First up, GitHub Copilot. They've been making a massive push with their Model Context Protocol, or MCP.
ExpertAbsolutely. GitHub just aggressively rolled out its official Copilot MCP server, exposing over 40 distinct tools directly to its agent ecosystem. We're talking everything from PR review configurations to webhook management.
HostSo, they're really trying to centralize and own the entire routing layer of the software development lifecycle, aren't they? It feels like a classic platform lock-in strategy.
ExpertExactly. They want Copilot to be the orchestrator for all your dev tools. But the sharp take here is that while it's an ambitious ecosystem play, the sheer physics of LLM context windows might make this heavyweight, "load-everything-upfront" approach structurally unsound. Which, as we'll dive into, is the core of our story today.
HostFascinating. Moving on to some upstarts that are definitely worth watching: OpenClaw and ZeroClaw. What's happening in that corner of the world?
ExpertOpenClaw, an open-source autonomous agent, has been a massive hit, hitting over 214,000 GitHub stars by February. But even more interesting is its hyper-optimized Rust alternative, ZeroClaw. This thing ships as a tiny 3.4MB binary and uses less than 5MB of RAM at runtime, delivering lightning-fast 180ms response times.
HostThat's a stark contrast to some of the Python and Node.js-bloated frameworks we've seen, which can chew up gigabytes of memory. This is a pivot towards local-first execution.
ExpertPrecisely. It requires no external cloud compute. While the trillion-dollar giants are battling over cloud API standards and subscriptions, the open-source community is quietly building these lightning-fast, local alternatives that can run on a $10 Linux board. They might just end up eating a significant portion of the incumbents' market.
HostIncredible. Next up, a bit of a gaffe from Anthropic: a Claude Code leak, alongside some significant CLI updates.
ExpertA classic oopsie. On March 31st, Anthropic suffered a massive packaging error, leaking roughly 512,000 lines of Claude Code’s internal TypeScript source code via npm. It’s a literal blueprint for how frontier companies build high-agency tools.
HostAnd concurrently, Anthropic, OpenAI's Codex, and Google's Gemini are all formalizing "Agent Skills" specifications for their CLI tools, really promoting progressive disclosure of information.
ExpertThat's the key. This shift implicitly acknowledges that feeding an agent an entire encyclopedia of tools at once actually breaks its reasoning capabilities. My sharp take here is that when the very companies selling you tokens are actively building frameworks to help you use *fewer* of them, you know the context-bloat problem has reached a breaking point.
HostThat's a great overview of the landscape. Now, let's dive into the core issue we hinted at: this hidden, exorbitant cost that's crippling some of these heavyweight AI agents. The source material calls it the "$1,600/day plumbing bill."
ExpertIt's a brutal reality check. The Model Context Protocol, MCP, was designed to solve this N-by-M data integration problem—how LLMs connect with external tools. But the architectural implementation has created a massive financial sinkhole.
HostAnd the problem, as I understand it, is that to use an MCP server, the agent has to inject the JSON schema definitions of *every available tool* into its context window, even before it reads a single line of user code.
ExpertPrecisely. Take GitHub’s Copilot MCP server, for instance. It exposes 43 distinct tools. Injecting the names, descriptions, JSON schemas, field enums, and system instructions for these tools consumes roughly 44,000 to 55,000 tokens per session. That's just the setup, the "plumbing."
HostSo you're paying before the agent even begins to "think" or do any actual work. What does that look like in real dollars and cents?
ExpertWell, at current Claude Sonnet 4 pricing, which is $3.00 per million input tokens, a 55,000-token payload costs about $0.16 per session. That might not sound like much on its own, but then you hit the enterprise multiplier.
HostWhich is?
ExpertFor a mid-sized enterprise running 10,000 automated agent sessions a day—think automated PR reviews or CI/CD debugging—that translates to a staggering $1,600 burned daily. All of that money is just for those initial tool definitions.
HostWow. $1,600 a day just to tell the AI what tools *exist*, before it even decides to use them.
HostThat comparison really drives it home. But it's not just about cost, is it? We're also seeing a reliability crisis emerge from this approach.
ExpertAbsolutely. Cost is just half the story. Authentication provider Scalekit published a rigorous 75-run benchmark in March 2026 comparing CLI versus MCP on Claude Sonnet 4. The results were a devastating indictment of schema bloat.
HostAnd what did they find?
ExpertCLI won on every single metric. It proved to be 10x to 32x cheaper than MCP. For a basic query, like "What language is this repo?", a CLI agent used 1,365 tokens. The MCP agent? 44,026 tokens. The delta was entirely due to the injection of 42 tool definitions the agent never even touched.
HostThat's an astonishing difference for such a simple task.
ExpertIt is. Scalekit estimated that for 10,000 operations, the CLI approach cost roughly $3.20, while the direct MCP approach cost $55.20. That's a 17x cost multiplier. But the real kicker was reliability.
HostTell me about it.
ExpertThe Scalekit benchmarks revealed a 28% failure rate for MCP. That's a 72% reliability score. Compare that to a 100% reliability score for local CLI tools.
HostA 28% failure rate is huge! And it wasn't due to the AI hallucinating or making bad calls, was it?
ExpertNo, it wasn't. The 28% failure rate was driven entirely by TCP-level connection timeouts to GitHub’s remote servers. It underscores a fundamental truth: a local CLI binary runs directly on your machine. There's no remote server to time out, no connection pool to exhaust. As industry experts note, "the binary is on your machine" is a reliability guarantee that no amount of remote infrastructure engineering can match.
HostSo, we've got this massive financial hit and a significant reliability problem. But the source material hints at something even more profound: the physics of "Context Rot," where *more* information actually makes the AI dumber. That feels incredibly counterintuitive.
ExpertIt does, doesn't it? For so long, the prevailing assumption in the AI industry has been that larger context windows equate to better performance. But that's simply false. Foundational research from Stanford University, in a paper called "Lost in the Middle: How Language Models Use Long Contexts," proved this.
HostWhat did they discover?
ExpertLLMs exhibit a U-shaped performance curve. They reliably recall information at the very beginning and the very end of a prompt, but they suffer catastrophic recall failure for information buried in the middle.
HostSo, if you put something important in the middle of a very long prompt, the model is likely to forget it?
ExpertExactly. And Chroma Research formalized this phenomenon in July 2025 with their landmark report, "Context Rot: How Increasing Input Tokens Impacts LLM Performance."
HostWhat did Chroma's study reveal?
ExpertThey tested 18 frontier models, including GPT-4.1. And they found that *every single model* degraded in reliability as input length increased, even when the task remained simple and the context window was nowhere near full. Performance dropped by 20% to 50% as token counts moved from 10k to 100k.
HostSo the more context you give it, the less reliable it becomes. And how does this tie back to the MCP problem?
ExpertBecause MCP schemas are injected into the system prompt or early conversation history, as a session progresses and the context window fills with conversation, those critical tool instructions inevitably slide right into the "middle" of the context window. That's the exact zone where recall drops by over 30%. The models start hallucinating tool parameters or forgetting tools exist entirely.
HostIt's like trying to find a specific sentence in a book where all the important sentences are only at the very beginning or the very end, and everything in the middle is a blur.
ExpertA perfect analogy. Chroma also found that adding related but irrelevant information—what they called "distractors"—amplifies these errors. Injecting 42 unused MCP tool schemas, for example, acts as semantic noise, confusing the model's structured attention mechanisms.
HostThat leads us to the concept of "attention budgets," doesn't it?
ExpertYes. Anthropic’s own internal Context Engineering Guides document that LLMs possess a finite "attention budget." Attention is a zero-sum game. Every token wasted on a JSON schema for a tool the agent won't use—like a PR review configuration during a simple code read—is a token stolen from its core reasoning and logic capabilities.
HostAnd this problem is only exacerbated by how autonomous agents actually operate, especially in multi-turn tasks.
ExpertThat's where the "quadratic trap" comes in, a danger in multi-turn agent loops where an agent writes code, tests it, reads the error, and then rewrites it.
HostBecause in each turn, it's carrying forward the full conversation history.
ExpertExactly. If the base payload is already bloated by 50,000 tokens of MCP schemas, the token count grows quadratically. Turn one is 50k tokens. Turn two is 55k. Turn three is 60k. This quadratic token growth pushes the cost of unconstrained, multi-turn agent tasks to unsustainable levels, while simultaneously guaranteeing that the agent will succumb to Context Rot before it even finishes the job. It's a death spiral.
HostThis all paints a pretty bleak picture for the heavyweight, everything-in-context approach. So, what's the antidote? The source material talks about the "Skills + CLI" approach.
ExpertThis is where the industry is rebelling against MCP bloat. Frontier model builders like Anthropic, OpenAI, and Google are pivoting to a "Skills" architecture for their CLI tools, based on the principle of **progressive disclosure**.
HostProgressive disclosure, meaning you only reveal information as it's needed?
ExpertPrecisely. Instead of the whole encyclopedia upfront, you give the agent a table of contents. It's structured in three tiers: First, just metadata, 10 to 30 tokens, like "Use this to query the Jira database." Second, full instructions, 200 to 2,000 tokens, loaded dynamically *only* when the agent decides it needs that skill. And third, reference docs for deep-dive documentation, loaded only for edge-case errors.
HostThat's a much more efficient way to manage context. And there's a fundamental difference between an MCP "Tool" and an Agent "Skill," isn't there?
ExpertThere is. An MCP "Tool" exposes a rigid API endpoint, like `POST /jira/issue`. It forces the LLM to guess the context of how your business actually uses Jira. An Agent "Skill," on the other hand, provides domain context and behavioral guardrails. For example, "I am operating in the finance department's Jira. Default all new tickets to High priority and tag the compliance team." Skills teach the agent *how* to behave, not just giving it a button to push.
HostSo, it's about teaching the agent the *why* and *how*, not just the *what*. And are we seeing data to back this up?
ExpertWe are. Recent benchmarks have revealed that when it comes to context, more is definitely not better.
HostWhat did they find to be the sweet spot?
ExpertAgents perform best when equipped with exactly two to three focused skills per task. And critically, highly detailed, narrowly scoped skills significantly outperformed comprehensive, generalized skillsets in task completion pass rates.
HostThat's a huge improvement. This also ties into what the source material calls the "Unix Philosophy."
ExpertExactly. Because LLMs are trained on billions of lines of open-source code, they naturally "speak" Unix. They understand how to chain commands together. A CLI-based agent can natively chain Unix pipes in a single command, like `grep "error" app.log | jq '.message' | xargs echo`. That requires exactly one tool call and minimal context overhead.
HostBut an MCP orchestration would be completely different.
ExpertFor the same result via MCP, the agent would have to make sequential, prescriptive round-trips: Call the file-read tool, wait for LLM response, call the JSON parser tool, wait for LLM response. This stifles agent improvisation, burns context on every round-trip, and dramatically increases latency. It's a far less efficient approach.
HostSo, if context bloat is an architectural flaw, and progressive disclosure with CLI-based skills is the antidote, what does this mean for the future of enterprise software architecture? What's the definitive verdict for our listeners?
ExpertThe most advanced pattern emerging is actually bypassing tool calls entirely in favor of ephemeral code execution. For instance, an agent asked to analyze a massive dataset can now bypass direct tool calls.
HostUnder the old MCP way, how would that work?
ExpertThe agent might pull a large dataset directly into its context window, burning massive tokens and immediately triggering Context Rot. It's a non-starter.
HostAnd the new way?
ExpertThe agent can instead write a script to filter the data locally, execute the script via CLI, and then only read the final, concise output back into its context window. This dramatically reduces token usage and boosts reasoning accuracy.
HostThat's a truly remarkable efficiency gain. So, it's about moving computation outside the precious context window.
ExpertAnd using the file system as memory. We're seeing the deprecation of the context window as a state store. Instead of carrying conversational history and data in the LLM's memory, advanced agents like OpenClaw use the local file system as their long-term memory. They write state to local markdown or JSON files and read it only when necessary, keeping the active context window pristine.
HostSo the verdict isn't that MCP is dead, then? It sounds like it still has a place.
ExpertExactly. The question isn't CLI or MCP. It's who is your agent acting for? If the agent is acting on *your* behalf on *your* machine, for developer tools, local data orchestration, personal workflows, or token-sensitive scaling, then ambient CLI credentials are the superior choice.
HostBut for broader, more regulated scenarios?
ExpertMCP remains necessary for multi-tenant SaaS, enterprise environments requiring strict OAuth boundaries, and compliance auditing. If the agent is acting on behalf of *other people's users* across third-party services, MCP's structured authorization is legally and architecturally required.
HostSo, we're heading towards a hybrid future.
ExpertAbsolutely. The ultimate enterprise architecture of 2026 is the Hybrid Stack: Skills at the top as the intelligence and routing layer. CLI handles all local code execution, Unix piping, and data filtering to protect the context window. And MCP acts strictly as the governed gateway for external access, utilized only when crossing network and identity boundaries. It's about using the right tool for the right job, and understanding the inherent limitations of each.
ExpertSo, summing up our discussion today, there are a few key insights I think listeners should really take away.
HostFirst, that context bloat is truly an architectural flaw, not just a billing issue. Injecting those massive MCP schemas, like Copilot's 55,000-token payload, actively degrades model reasoning and can lead to hallucination loops because of "Context Rot."
ExpertSecond, progressive disclosure is rapidly becoming the new standard. Giving agents a "table of contents" through "Skills" rather than the whole book upfront reduces token usage by up to 32x and drastically improves task pass rates.
HostThird, agents are fundamentally better at Unix than they are at rigid API calls. Because LLMs are trained on vast amounts of open-source code, they naturally excel at composing local CLI commands via Unix pipes, whereas those rigid MCP endpoints force them into expensive, sequential round-trips.
ExpertAnd finally, a critical takeaway is the need to keep data out of the context window. The most efficient agents are those that write code to process data locally and use the file system for state memory, rather than trying to pass raw data through the LLM itself.
HostIt really challenges a lot of the assumptions we've held about how to best build and interact with these AI agents. So, for our listeners, the question becomes: how much of your current AI agent workflow is actually contributing to the "plumbing bill" and potentially making your AI dumber? And are you ready to embrace the modular, local-first philosophy that's gaining so much ground?