.avif)
Everyone's buying a smarter model. The bottleneck is one floor down.
Every company is being told to buy a smarter model. But AI agents are capped by something no model upgrade touches: whether a company's reasoning and decisions live anywhere a machine can read them. That work, making company context legible to agents, is what the field now calls context engineering, and it matters more than model choice. Engineering leaders would do well to treat it as the project, not the tool sitting on top of it.
Slack's product chief just told everyone the quiet part. The thing standing between your agents and real usefulness isn't the model. It's how your company talks to itself when the AI isn't in the room. That reframes the next year of AI budgets, and most teams are about to spend against the wrong line item.
In a recent essay, Slack’s Chief Product Officer Jaime DeLanghe argued that “the work is the conversation”. Her case is that the document is just the receipt. The real work, the thinking that produced it, happens in the messy back-and-forth around it: the call that blew up an assumption, the pushback that changed the timeline, the hallway argument that became the actual strategy. And that unstructured layer, she says, is exactly what agents need to be useful.
Read past the framing and there is a harder claim underneath. An agent can only learn from what it can see. A decision made in a DM is invisible to it, and stays lost to the whole organization. The reasoning behind a technical tradeoff, argued out in a private thread, never becomes something a future agent can retrieve. DeLanghe is blunt that this is a decades-old problem. The promise that workplace conversation would compound into institutional knowledge never materialized, because it just hangs there while people repeat themselves.
That is the sentence worth sitting with. The industry has been selling proprietary data as the moat. The scarce asset is proprietary context, the messy reasoning behind why a company does what it does, and almost nobody has it in a form a machine can use. The technical crowd already has a name for closing that gap. They call it context engineering: the work of making a company's decisions, reasoning, and operating knowledge available to an AI agent so it can act on them. Gartner has it as the breakout AI capability of the year. I want to argue it is not really an engineering problem at all. It is a management one wearing an engineer's title.
The demo proves it can work. Production is a different question.
I have watched a version of this problem for more than a decade, placing engineers onto other companies' teams.
It shows up the same way every time. A senior hire can be technically excellent and still useless for two months, because everything that makes the work go is undocumented. Who actually owns deploys. Which service breaks in a way the runbook doesn't mention. Why the team abandoned the obvious architecture three years ago after it cost them a weekend. None of that is in the codebase. It is in people's heads and in the Slack threads where the real decisions got made.
An agent walks into the exact same wall, only faster and more confidently. If you want the short version of why AI agents fail in production after sailing through the demo, that's it: the demo runs on a clean, self-contained task, and production runs on everything the company never wrote down.
Here is the mechanism, because “agents need context” is a slogan until you can say why. An agent takes the situation in front of it, pulls in whatever it can retrieve, and reasons forward from there. When the reasoning behind past decisions is missing, the agent doesn't stop and ask. It fills the gap with the most plausible-sounding answer and treats it as fact. A missing “why” doesn't read to the agent as a blank. It reads as permission to invent one. So the failure isn't that the agent knows less. It's that it confidently reconstructs a history that never happened, and every later step builds on that invention.
A smarter model does not fix this. It makes the invented history more fluent.
We have run this exact experiment before, and it failed
Before anyone budgets for a “make our knowledge legible to agents” initiative, it's worth remembering the industry already tried the human version of this and mostly lost.
The knowledge management wave of the late 1990s and 2000s was exactly this promise. Capture what employees know, put it in a system, let the organization reuse it. A synthesis of the research on why those projects failed puts the failure rate at around half, and higher if you count every initiative that never lived up to what it promised. Not because the software was bad. Because people wouldn’t feed it. Documenting your reasoning is work with no immediate payoff to the person doing it, so it doesn’t happen, and the repository fills with stale half-truths that people learn not to trust.
That precedent proves something the current excitement obscures: the barrier was never technical, and a better retrieval engine sitting on top of the same empty channels inherits the same emptiness.
What is actually different this time is the incentive. In the old model, you documented for a hypothetical future colleague, and the reward was abstract. Now the consumer of your context is an agent working your own tasks this week, and the reward is immediate and personal. That's a real shift. But it only pays off if the context exists to be read, which means that failure rate is a warning, not an all-clear.
I have watched this decide which teams survive a departure
In more than a decade of placing engineers, I have watched one thing predict who survives a key departure and who spends six months in the dark. It isn't talent. It's whether the reasoning was ever anywhere but in the person who left.
Engineering teams have a number they rarely say out loud called the bus factor: how many people would have to leave before a system becomes unmaintainable because the knowledge left with them. A JetBrains research study treats it as a first-class risk precisely because so much of what runs a system is tacit, undocumented, and lost the moment its holder walks out. A bus factor of one means one resignation from a crisis.
Agents change what that number is measuring. A team that already works in the open, where decisions and their reasoning live in shared channels, effectively has a high bus factor. The context survives any individual leaving, and now it also feeds every agent the team runs. A team that operates in DMs and side conversations has a bus factor of one at the organizational level, and its agents will be as thin as its documentation.
Here's what that means in practice. Two companies buy the identical model. The one with legible operating context gets a materially smarter agent than the one without, and no amount of the competitor's spending on a better model closes that gap, because the gap isn't in the model. This is the part that should reorder a budget. The differentiator has quietly moved from the thing you buy to the thing only you can produce.
Treat the context as the project
If I ran an engineering org right now, I would stop treating the next agent framework as the project and treat context as the project.
Concretely. Move real work into channels a machine can read, and mean it, which means leaders modeling rough drafts and half-formed decisions in the open, not just announcements. When a nontrivial call gets made, write the one thing no system captures on its own: not what was decided, but why, and what it beat. Connect the systems where reasoning actually lives, the docs and calendars and threads, before spending on anything exotic. And put an owner on the loop that keeps that context from rotting, because a repository nobody prunes becomes a repository nobody trusts, and I've watched that kill the last version of this idea.
None of that is glamorous. All of it beats a model upgrade.
The honest objection
The strongest pushback I hear is that this is just more overhead. That asking people to work in the open and narrate their reasoning is a tax on the exact senior people whose time is most expensive, and that it will quietly not happen no matter what the plan says.
The first half is true. The second half is a bet, and it's the one thing that has changed. Every prior push to document failed because the payoff went to someone else, later. This time the person who writes down why a decision was made is the person whose agent is smarter tomorrow because of it. That is a genuinely different incentive, and I think it's enough to flip the outcome. But I'd be lying if I called it certain. It's a bet that self-interest finally points the right way, and if I'm wrong, it's because the tax turned out to be heavier than the reward felt. Worth watching honestly rather than assuming.
There’s also a convergent read on this from well outside my lane, which is what makes me trust it. MIT’s NANDA project studied the state of enterprise AI and found that 95 percent of organizations are getting zero return on their generative AI spending, and their conclusion was explicit that the divide is not driven by model quality. It’s driven by whether the system has memory, learns the organization’s context, and fits how the work actually happens. They arrive at that from surveying hundreds of deployments. I arrive at it from placing engineers. Neither of us borrowed the other’s frame. That convergence is the tell that the thing is structural.
Your agents will be exactly as smart as your company's memory is legible. Everything else is a model upgrade you're overpaying for.
Gino Ferrand is the founder and CEO of Tecla, which builds and operates AI systems for U.S. companies and staffs the senior engineering teams behind them, across the U.S. and Latin America. He writes Founder's View, a weekly operator's take on the AI news that actually changes how technology companies build. Talent is everywhere; opportunity is not.
.avif)
