Agent reliability comes from information architecture, not prompt quality. Scoping context deliberately is the real engineering skill.
The Context Window Is Your Architecture
Most engineers treat agents the way they treat prompts. Write the instructions, run the loop, fix what breaks, repeat. I did this too. I spent weeks tweaking system prompts, adding more specific language, stacking examples, and wondering why my agents kept doing something subtly wrong on step four of a six-step workflow.
The problem was never the words. It was the shape of the information I was handing the model.
The Real Failure Mode
When Claude or GPT-4o misbehaves inside an agentic loop, the reflex is to add more instruction. Be more specific. Add a counter-example. Make the constraint explicit.
I’ve started doing the opposite. I strip things out.
Because the actual failure almost always traces back to the model holding too much at once. Competing instructions. Redundant context. Tool descriptions that half-overlap and create ambiguous decision surfaces. The model doesn’t fail because it’s dumb. It fails because you handed a junior engineer three conflicting memos and asked them to pick one without telling them which matters most.
Andrej Karpathy described something similar while running multi-agent research experiments. He noted that his agents were “very good at implementing any given well-scoped and described idea” but fell apart when the scope was loose. One agent “discovered” that increasing network hidden size improves validation loss, which is a meaningless result if you don’t control for compute. The agents weren’t broken. The information environment they were operating in was.
Progressive Disclosure Is an Engineering Pattern, Not a UI Trick
Anthropic’s recently published guide on building Skills for Claude makes this concrete. The architecture they describe uses a layered loading approach they call progressive disclosure. A lightweight YAML frontmatter tells the model when a skill applies. Full instructions only load when the skill is actually relevant. Supporting files are accessed only if needed.
This isn’t a UX pattern borrowed from product design. It’s information hygiene at the systems level. You are controlling what the model sees at each moment in the workflow, which directly controls what it can reason about without interference.
The analogy in the guide is useful: MCP gives Claude the kitchen. Skills give it the recipe. Without that recipe layer, you have a model with access to powerful tools and no coherent workflow for using them. That’s not an agent. That’s an expensive autocomplete with side effects.
Scoping Context Is the Actual Engineering Work
Here’s the mental model shift that changed how I build: the context window is your architecture diagram.
Every token in there is a variable. Every tool description is a branch condition. Every ambiguous instruction is a potential collision. You wouldn’t let your production database schema grow by appending columns forever with no normalization. The context window deserves the same discipline.
Karpathy framed his multi-agent setup this way: “you are now programming an organization and its individual agents, so the source code is the collection of prompts, skills, tools, and processes that make it up.” That’s exactly right. The org chart is the data flow. The standup is a synchronization protocol. When your “org code” is a mess, your agents produce messy results.
The Anthropic guide tracks four specific metrics worth measuring against this model: trigger accuracy, tool call efficiency, failure rate, and token usage. Those four numbers will tell you more about your agent’s reliability than any amount of prompt iteration.
What This Means in Practice
Stop debugging prompts when agents fail. Start auditing the information architecture.
Ask: what is the model being asked to hold simultaneously? Are there tool descriptions that overlap in scope? Are there instructions that apply to different stages of the workflow but are presented at the same level of priority? Is the model loading context it doesn’t need yet?
The Anthropic Skills pattern is one answer to this. You can build your own version of it without adopting their specific tooling. The principle is the same: load what’s relevant, when it’s relevant, at the granularity the current step actually requires.
Agents that work reliably aren’t the product of better prompt writers. They’re the product of engineers who treat context as a first-class resource and scope it deliberately.
That’s the skill the field is still learning to name.
Sources
#AIEngineering #LLMOps #AgentDesign #MachineLearning #SoftwareArchitecture
