Skip to main content
InsightsThe Knowledge Layer

The “Too Much Information” Problem: Lessons from Real-World AI Agents

Your AI isn’t broken it’s smart and “lazy” by nature, always seeking the path of least resistance. Instead of fighting it, learn how to harness it with formal context management so the right path is also the easiest path.

Why more context isn’t always better, and how to guide your AI to make smarter, more reliable decisions.

Executive Summary

  • A common assumption is that bigger context windows lead to smarter AI. Our experience shows this is false: adding more unfiltered information paradoxically degrades performance by creating “context noise.”
  • Context noise occurs when too many schema elements share the same conceptual foundation but differ in business rules (e.g., “Active Customer” in CRM vs. Billing vs. Support). When the linguistically “most similar” match is not the semantically “most applicable” one, retrieval crowds out the right definition and the agent answers with silent errors.
  • Skills (domain playbooks and instructions) and Tools (executable actions and queries) must be clearly differentiated and concisely routed. As even Anthropic’s official skill-authoring guidelines warn, overly verbose descriptions cause the model to short-circuit execution and guess from the description alone.
  • The most effective AI systems shift from “giving the agent a static summary” to “giving the agent a curated semantic map and the tools to explore it.”
  • True scalability is not proven in clean, simple benchmarks of a dozen tables, but across the hundreds of curated data products or thousands of raw source tables that make up a real enterprise landscape.

Introduction

There’s a pervasive myth in the current AI landscape: to make an agent smarter, give it more data. The bigger the context window, the more documents and schemas you can stuff into it, the better the reasoning. While intuitive, our practical experience building enterprise AI agents has revealed a counterintuitive truth: more information is often not just unhelpful, it can be actively harmful.

Performance doesn’t scale linearly with the volume of information. In fact, it can crater. This article shares key lessons we’ve learned from the front lines insights that challenge common assumptions about how to build effective, reliable, and scalable AI systems.

The “Context Noise” Problem: When “Most Similar” Isn’t “Most Applicable”

The primary issue isn’t the raw size of the context window, but the density of ambiguity within it. In a real enterprise, tables and metrics aren’t all named identically if they were, the collision would be obvious. Instead, dozens of attributes and metrics share the same conceptual foundation while encoding subtly different business conventions.

Take a seemingly simple question about “active customers,” “revenue,” or “churn.” Across your landscape, you might have crm_account_status in Sales, subscription_state in Billing (where a 14-day grace period applies and temporary freezes are excluded), and contract_termination_flag in Controlling. Or you have “Net Order Value” in the webshop alongside “Recognized Revenue” in ERP, one gross after discounts, the other net before returns. None of these carry the exact same name, yet all of them describe the same underlying business domain.

This is what creates “context noise.” When an agent relies on text or vector similarity to assemble its context, it retrieves what is linguistically most similar to the user’s phrasing. But when too many concepts are similar, the most similar option is often not the most applicable one. Worse, because top-k retrieval is finite, a flood of near-matches crowds out the exact convention or structural bridge the query actually needs, so the truly applicable definition never even makes it into the context window. The agent doesn’t crash or throw an error; it simply computes a plausible-sounding answer on the wrong basis. The problem isn’t a lack of information; it’s a lack of explicit semantic clarity.

The Skill and Tool Paradox: Why Agents Ignore What They’re Given

A second surprising behavior emerges when equipping agents with capabilities. First, we need a crisp distinction between two terms that are often conflated: Skills and Tools. A Skill is a modular package of domain instructions, workflow patterns, and reference material that an agent loads on demand to learn how to approach a class of problems. A Tool is an executable function or API endpoint (for example, running a SPARQL query or fetching live records from a system) that the agent invokes to retrieve facts or trigger an action.

The logical impulse is to write a detailed, helpful description in the system prompt for every skill and tool, explaining everything it does and what knowledge it contains. This can backfire completely. When a skill’s routing description is too verbose and summarizes its own content, the agent often extracts a plausible answer from the description itself and skips loading the actual skill instructions. Notably, this isn’t just our observation: Anthropic explicitly documents this exact failure mode in its own official skill-authoring guidelines (the Skill Creator specification), warning that when descriptions summarize workflows or domain content, the model will follow the summary shortcut instead of reading the full skill. The same dynamic applies to tools: if a tool description summarizes the data or logic it exposes rather than defining its trigger conditions, the agent may synthesize an answer from the metadata alone without ever executing the call.

The lesson is sharp and specific: skill and tool descriptions must be concise routing triggers. A skill description should tell the agent when to load the domain instructions, and a tool description should specify when and how to execute the action, never a summary of what the underlying playbook or data contains. The purpose of the description is to trigger progressive disclosure or execution, not to replace it.

The Illusion of Scale: Why “13 Tables” Proves Nothing

Many emerging AI architectures are benchmarked in sterile, controlled environments. They demonstrate impressive results on a dozen well-structured database tables. This proves very little.

Enterprise reality is not a dozen tables. Even if an organization has invested heavily in a modern data platform with curated “Gold” data products, an agent must still navigate hundreds of data products across domains and at the underlying system level, thousands of physical tables spread across dozens of applications, each with its own domain conventions and legacy logic. Whether you are dealing with hundreds of data products or thousands of source tables, you are orders of magnitude beyond a 13-table demo. The true challenge of scale isn’t the number of rows, but the combinatorial explosion of cross-domain relationships, implicit conventions, and potential misinterpretations. An approach that works in a sterile benchmark will fail when it collides with a real-world enterprise knowledge landscape.

The Solution: Smart and “Lazy”—Harnessing Least Resistance with Context Management

The surprising behaviors of AI agents, skipping skills or tools, getting derailed by similar terms, taking shortcuts, are not bugs to be fixed. They are fundamental properties of how large language models work. Modern LLMs are remarkably smart AND “lazy” at the same time: like any efficient physical or cognitive system, they are optimized to follow the path of least resistance the highest-probability, lowest-effort trajectory to an answer. Fighting this nature is a losing battle. The solution is to harness it.

This is the discipline of Context Management. Instead of flooding the agent with noisy, ambiguous options and hoping it works harder to disambiguate them, we must architect the context so that the easiest path is also the correct path. The goal is to build an environment where the agent’s preference for least resistance works in our favor.

A formal knowledge graph (built on explicit ontologies in RDF/OWL and Schema-RAG) is the ultimate foundation for this. Rather than relying on linguistic similarity alone, it resolves concepts and their structural neighborhood before a query is ever written. When an agent asks about customer churn or active accounts, the ontology doesn’t leave it to guess among dozens of near-matches; it provides the explicit, machine-interpretable convention and relation path that applies to that domain. By pre-resolving identity, meaning, and relationships, we give a smart-and-lazy agent a clean, unambiguous map, making the right answer the most obvious one.

Conclusion: If you remember one thing…

Stop fighting the nature of your AI. Large language models are both smart and “lazy”, they will always take the path of least resistance. Your job is not to make them work harder, but to make the right path the easiest path. This is the essence of context management: create such clarity in your knowledge representation that even the laziest shortcut leads straight to the correct answer.