What exactly stops an AI agent from grasping how your business actually runs — is it the model, or how your data is organized?
What data architecture obstacles prevent agents from understanding business context?
This explores why AI agents struggle to grasp the business context they work in (how a company's data, rules and tacit knowledge are organized) and whether the barrier is the way that information is stored and delivered to agents.
This explores why agents struggle to grasp business context, and whether the problem lies in how information is stored and fed to them. First, a gap: the corpus doesn't directly cover enterprise data plumbing like data silos, semantic layers or knowledge graphs of business entities. What it does have is a set of findings that, taken together, show where context gets lost between the data and the agent. Most of them point away from the model and toward the structure around it.
The clearest thread is that reliable agents don't carry context in their heads. Reliability comes from moving three burdens out of the model and into a surrounding harness: memory (what has happened and what is true), skills (how things get done), and protocols (how pieces talk to each other) Where does agent reliability actually come from?. Seen that way, "the agent doesn't understand our business" often means business context was never put into a form the harness can hold. One answer is to make code the place where state lives, because code can be run, inspected and remembered in a way prose instructions can't Can code serve as the operational substrate for agent reasoning?.
The second obstacle is retrieval. The usual pattern is to fetch some documents and then reason over them, which assumes you know in advance what's relevant. Business context rarely works that way, because the meaning of a number depends on a chain of related facts. Agents that reason while they walk a memory graph, choosing the next link based on what they've found so far, beat the fetch-then-think approach by up to 23% Can agents reconstruct memory on demand instead of retrieving it?. A related surprise: there's no single right amount of context. Stronger agents do better with detailed context, while weaker ones need it heavily compressed Can an external manager handle context for frozen agents?. So a context pipeline built for one model can quietly fail another.
The third obstacle is that much business context isn't in any database. Agents trained on curated expert examples can only learn what the curators thought to include Can agents learn beyond what their training data shows?. Evans makes a parallel point about organizations: workers often don't see their own tasks as automatable, and adoption depends on decisions that span departments Does easier tool-building actually solve enterprise adoption problems?. The knowledge an agent most needs is tacit, spread across teams, and never written down. The history of agent deployments shows the same pattern: failures usually come from missing conditions like standardization, personalization and trust, not from a lack of capability Why do capable AI agents still fail in real deployments?.
The takeaway you might not expect: adding agents can make context fragmentation worse. Single agents hit organizational limits that more capability or a bigger context window can't fix Do single agents always hit organizational limits?. But once context is split across many agents, they tend to accept a neighbor's information without checking it, so one agent's misunderstanding spreads through the network Why do multi-agent systems fail to coordinate at scale?. The deeper architecture problem isn't just getting business data to an agent. It's deciding which part of the system holds the authoritative version of that context, and who checks it.
Sources 9 notes
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Research shows code uniquely enables agent reasoning, action, and verification by being simultaneously executable, inspectable, and stateful. This unified code-centered loop improves reasoning and verification together compared to natural-language or prose-based approaches.
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
AdaCoM trains an external RL-based manager to prune and preserve context for frozen agents. The key finding: stronger agents benefit from high-fidelity preservation, while weaker agents need aggressive compression—optimal context management is agent-specific, not task-universal.
Agents trained on static expert datasets cannot learn from their own failures or generalize beyond demonstrated scenarios because they never interact with environments during training. Competence is capped by what curators imagined, not by agent capacity.
Show all 9 sources
Evans argues that reducing coding friction masks two structural barriers: most workers don't see their own tasks as automatable, and enterprise adoption requires organizational decisions that span departments and timelines—not just technical capability.
Historical analysis from GPS to modern AI shows agent failures consistently result from absent ecosystem conditions—value generation, personalization, trustworthiness, social acceptability, and standardization—rather than capability gaps. Even highly capable systems stall without these five conditions.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Towards a Science of AI Agent Reliability
- Bilevel Coordinated Reflection: A Game-Theoretic Approach to Multi-Agent LLM Systems
- Towards a Science of Scaling Agent Systems
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Worse Together: How Performance Breaks Down in Multi-User Multi-Agent Teams
- LiveMCP-101: Stress Testing and Diagnosing MCP-enabled Agents on Challenging Queries
- LatentSkill: From In-Context Textual Skills to In-Weight Latent Skills for LLM Agents
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses