The Infrastructure Tax
Two years ago, building a production-grade required infrastructure: state persistence, sandbox isolation, observability across disconnected systems. A small team could dedicate 3 months just on that.
Such tax is now largely gone. Cloud providers and frameworks have absorbed the complexity. Today, defining an agent comes down to: which model to use, what instructions to give it, which tools to make available, and where to run it. A production-ready agent is a weekend project for one person. This has happened fast.
The New Failure Mode
So agents are easy to deploy. The problem is that they are still easy to break — and they break in a specific, patterned way.
A concrete case: an agent is tasked with enriching a support ticket about slow latency in an automated pipeline. It fetches the ticket, searches the codebase, and produces an action plan. Its recommendation: re-enable async dispatch.
That recommendation would have caused an outage. Async dispatch had been deliberately disabled days earlier, after causing exactly that kind of failure. The fix was documented in a Slack thread and a postmortem ticket. The agent had access to neither.
This is not a hallucination in the usual sense — the model reasoned correctly given what it knew. The failure was narrow context. The agent had the ticket and the code, but no organizational knowledge a human collaborator would carry, i.e. what broke, why the current state is the way it is, what was decided and why.
A human engineer on that team would not have made this mistake. Not because they are smarter, but because they remember.
A Human as the Context Layer
When a human is in the loop, this gap rarely presents. In effect the human is the context engine — synthesizing organizational memory on the fly, noticing when a suggestion conflicts with recent history, and course-correcting before anything breaks.
As agents move into more autonomous roles — acting without a human babysitter in the background — this safety net disappears. An agent can misinform a teammate, act on stale reasoning, or undo a deliberate decision with complete confidence. The failure is silent until something breaks in production.
The gap is not intelligence but context.
What a Context Engine Actually Does
Connecting a Slack integration, a Linear integration, and a GitHub integration to an agent can look like a solution. But it is not: raw access is not the same as understanding.
Plugging in multiple data sources floods the context window with irrelevant documents, raises processing costs, and leaves the agent to arbitrate conflicts between sources on its own — which is exactly the kind of reasoning that goes wrong. An agent with full Slack access but no filtering layer would still need to sift through thousands of threads to find the one that matters.
A Layer that pre-processes all of that, something that understands how the organization’s systems relate to each other, knows what the agent is trying to do, and hands it a ranked, reconciled, permission-scoped summary is needed. Not raw documents — synthesized institutional memory. The question stops being “what data sources can the agent reach?” and becomes “what does the agent need to know, right now, for this specific task?”
In the case of the latency ticket, adding a context engine to the same agent retrieved the postmortem ticket and the relevant Slack thread, synthesized them into a summary, and passed that to the agent. The updated recommendation: prevent the outage rather than cause another one.
Implications
Not just pipeline debugging, but code review agents that can assess a pull request the way a domain expert on the team would. Customer-facing agents that answer with organization pecific accuracy rather than generic plausibility. Any agent task where the “why” behind current decisions determines whether the output is useful or harmful.
In a few years context engineering is going to look a lot like how we now think about prompt engineering: obvious in retrospect, underestimated at first, eventually standardized. But right now it is still mostly ad hoc.
The encouraging thing is that solving the infrastructure problem means teams can finally focus here. When building the agent took 3 months there was no budget left to think carefully about what the agent knew. That constraint is lifting.
Text summarized and optimized using Anthropic’s models and reviewed by a human.