The two legs of every working enterprise agent, knowledge and action

Every working enterprise agent stands on two legs. One leg is action, the multi-agent execution layer that reads from systems, writes to systems, and moves work through the pipeline. The other leg is knowledge, the captured operating expertise of the people who actually know how the work gets done.

The market has spent two years building the action leg. Almost nobody has built the knowledge leg. And that is the single largest reason enterprise AI keeps missing.

MIT's NANDA initiative found that 95% of enterprise AI investments show no measurable business impact. [MIT NANDA, 2025] Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027. [Gartner, 2025] Those numbers do not describe a modeling problem or an integration problem. They describe an anatomy problem. The agent was built on one leg. That is why 95% of enterprise AI pilots fail, and why the failure pattern is so consistent across industries.

Why action alone looks fine, until it doesn't

If you have watched an agentic AI demo in the last twelve months, you have seen the action leg in full bloom. Tools. Function calls. Orchestrators. Planners. A multi-agent graph with retries and fallbacks. Beautiful telemetry. Impressive throughput on synthetic tasks.

None of that is wrong. All of it is necessary. It is also, on its own, not enough.

The action leg is what lets an agent do things. Pull a claim. Draft a response. Update a record. Kick off an approval. It is the visible half, the half every builder starts with because it is the half every framework helps with.

But an agent that can do things is not the same as an agent that knows what to do. The moment a real enterprise case hits, that gap becomes the whole story.

A real case is not "process the next ticket in the queue." A real case is: this claim looks routine, but the customer's account was flagged three months ago for a related pattern, and the field the system relies on is stale, and the standard workflow will produce a technically correct answer that will get reversed on appeal. Only one person in the department knows that. Their name gets called every time a case like this shows up.

If your agent does not know what that person knows, it does not matter how well its action leg is built. It will pick the technically correct path and be wrong on the case that mattered.

What the knowledge leg actually is

The knowledge leg is not a wiki. It is not a document store. It is not a RAG index over your SOPs, expertise mining and RAG solve different problems. It is not chat-over-docs with better search.

The knowledge leg is captured expertise, the real operating logic of your best people, made explicit, structured, and machine-readable, so an agent can reason over it the same way that person would.

That includes the parts nobody writes down. Which field to trust when two systems disagree. Which escalation gets a response and which one dies in a queue. Which supplier's price is real and which is a placeholder. Which cases look routine but are not. Which exceptions are one-offs and which are patterns.

Research suggests that roughly 80% of how work actually gets done is undocumented. [Tallyfy] And 42% of essential expertise lives only in employees' heads. [Panopto] That is not a documentation gap you can close with a wiki refresh. It is a substrate problem: the knowledge your agents need was never expressed in any form your action leg can read. This is what operating knowledge actually is, and why your documents do not have it.

Building the knowledge leg means going to the source and doing structured extraction. Sitting with the person everyone calls, asking the right questions, separating personal habit from operating logic, validating one expert's version against another, and packaging the result as an expert profile that an AI can actually use. This is what we call expertise mining, and it is the missing leg of enterprise AI.

Why almost everyone skips it

If the knowledge leg matters this much, why does almost nobody build it?

Three reasons.

It looks like a documentation problem. Executives see the gap and reach for the tool they know, a knowledge base, a wiki refresh, a "chat with our documents" project. Those tools operate on written content. They are useful. They do not touch the tacit judgment that sits under real work. The gap stays.

Frameworks help with action, not knowledge. LangGraph, CrewAI, Copilot Studio, Agentforce. Every popular agent framework is a scaffolding for action. They assume the knowledge already exists in a form the agent can read. When that assumption fails, the framework has nothing to offer, and the team blames the model.

Extraction is unglamorous work. Building the knowledge leg means putting a skilled interviewer in a room with a senior operator for a few hours, then structuring what they said into a validated expert profile. There is no GPU cluster involved. No new benchmark to beat. It looks like consulting. It is not, but it looks like it. So the industry keeps writing frameworks for the action leg and shrugs at the knowledge leg.

What happens when you only build the action leg

Every agentic pilot that has died in the last two years has died the same way.

The demo works. The synthetic cases work. The pilot cohort works, more or less, because the pilot cohort is filtered to the cases the agent can handle. Leadership signs off. The team scales the agent into the general population of work.

Then the real cases arrive. The exceptions. The judgment calls. The cases where the "right" answer depends on context that lives in one person's head. The agent handles them the only way it can, by treating them like the routine ones. The error rate spikes. Trust collapses. Someone opens a ticket that says "the model is not smart enough." A better model gets swapped in. Nothing changes. The pilot gets quietly shelved.

This is the failure pattern behind the 95% number. It is not a model problem. It is not an integration problem. It is a missing-leg problem. The action leg was there. The knowledge leg was not. The agent fell over the first time it had to reason about something that was never written down.

What happens when you build both

The picture inverts the moment the knowledge leg is in place.

At a large multi-brand insurance group we work with, the renewal workflow used to take six minutes and required a senior operator's judgment to sort the ambiguous cases. With the expert's real logic captured, the exceptions, the trusted sources, the escalation heuristics, and running under governed execution, the same workflow now takes one minute. The senior operator's judgment did not disappear. It got embedded, and their team scaled with it instead of around it.

At a maritime chartering firm, an eight-person team now runs the same work with one, because the expert profile captured what the other seven were re-learning every day.

Both of these are agents doing real work in real systems. Neither would have functioned on the action leg alone. What made them work was the captured expertise underneath, the knowledge leg, combined with an action layer that could actually operate the tools with human approval at every step that matters. That approval layer, governed agent operations, is the second half of the answer. The knowledge leg tells the agent what to do. The action leg does it, under human control, in the company's real systems.

How to tell which leg your agent is missing

If you are a CAIO or VP of AI looking at a stalled pilot, the diagnosis is usually fast.

Ask what the agent is doing well. If it handles the straightforward cases and dies on the interesting ones, the knowledge leg is missing. If it can reason about the interesting cases but cannot actually reach the systems where the work lives, the action leg is missing. If both are broken, you are running a demo, not a pilot.

Ask what your pilot's failure cases look like. If the failures cluster around exceptions, judgment calls, and cases where the "right" answer requires context that is not in any document, that is the knowledge leg. Better prompts will not save it. Better models will not save it. Better retrieval will not save it. The substrate is missing.

Ask who the pilot team calls when a real case breaks the agent. If they call the same one or two experts every time, the ones who "just know", you have found the knowledge that never made it into the system. That is what needs to be mined.

The sequence matters

There is one more thing worth saying. The two legs are not equal in the order you build them.

If you build the action leg first, you end up with an agent that operates confidently on the wrong substrate. It moves fast, produces answers, and is wrong in ways that are hard to detect because the answers look right. Fixing it later means unwinding decisions the agent has already made in production.

If you build the knowledge leg first, capture the real operating logic, validate it, structure it, and then run governed action on top, the agent moves more slowly out of the gate and gets steadily better as the captured expertise accumulates. The knowledge is the thing that compounds. The action layer is what makes the knowledge do work.

That is the order we build in, and it is why our pilots survive the transition from demo to production. Not because our models are better. Because the leg everyone else skipped is the one we build first.

An agent with only the action leg is a fast way to be confidently wrong. An agent with only the knowledge leg is a very expensive document. An agent standing on both legs is the thing that finally works on real cases, the thing that a senior operator will actually hand a case to, the way they would hand it to a trusted junior.

That is the shape of a working enterprise agent. Two legs, both solid, in the right order, with a human in the loop where the stakes are real.

Mine the expertise. Then operate differently.