Many companies have now built their first AI agents, and many leaders are disappointed with what came out of it. The agent writes the draft in seconds, but the process around it takes as long as before. Employees check every line because they do not trust the output. After a few months, only a handful of people still use the agent, and nobody can show what has improved for the business.

In my work with leadership teams this year, I hear the same explanations for this. The model was too weak, the prompts were not good enough, or the tool was the wrong choice. In almost every case, the cause lies somewhere else. These companies put agents into work that they designed for people and never changed. This newsletter explains the five causes and shows five building blocks that solve them, with practical steps for each.

The problem: the work around the agent stays the same

Take an offer process as an example. Sales collects the customer requirements by email, copies them into a template, sends the draft to product management, waits for pricing approval, and corrects the document twice. The company now builds an agent that writes the first draft. Writing becomes faster, but the handovers, waiting times and corrections stay the same. The offer still takes more than a week.

At the same time, the agent fails on things every experienced employee knows. Which price list is current? Do certain customers have special conditions? What wording has the legal team already rejected? This knowledge sits in old folders, in three different systems, and in the heads of two colleagues who have been with the company for fifteen years.

The result is an agent that produces output nobody trusts enough to use without checking every line. The team loses the time it saved in writing when it reviews the output.

 

 

Why this happens

 

I see five causes again and again.

Teams take the process as given: When teams start an AI project, they usually ask where AI can help in the current process. They look for single steps that an agent could take over, such as writing a draft or filling in a form. Hardly anyone asks whether the process still makes sense. All the handovers, approvals and waiting times from years ago stay in place, and the agent only speeds up a small part of the work.

Company knowledge sits in too many places: An agent needs the same information an experienced employee uses every day. In many companies, this information is hard to reach. Documents are out of date, the systems that hold the data do not connect, and nobody ever wrote down the important rules because the people who apply them simply know them. The agent then works with whatever it finds, and the results are unreliable.

The business waits for IT: The people who know the process best rarely build the solution. They write requirements, hand them over and wait for delivery. Many details and exceptions disappear on the way, because they are difficult to put into a requirements document. What comes back often fits the description but does not fit the work.

Every team starts from zero: Sales, HR and finance all need agents that summarise, draft and check. Each department builds its own instructions for these similar tasks, and no one shares what already works. The company pays several times for the same learning, and the quality of the results depends on the team.

Companies decide on trust all at once: Many companies treat autonomy as a yes or no decision. Some allow the agent to do everything, which leads to mistakes nobody notices in time. Others block it completely after the first error. In both cases, the agent never gets the chance to show step by step that it can work reliably.

Each building block answers one of these causes. They work best together, but you can start with one process and build from there.

 

 

1. Redesign the work before you automate it

 

Ask one question before anyone builds an agent: how would we design this workflow if AI had been available from day one? The answer usually has fewer steps, fewer handovers and a different split between people and technology.

• Start with the result the process should deliver and who needs it.
• Go through every existing step and ask why it exists. Many approvals and handovers exist because information was missing earlier in the process.
• Decide which steps the agent takes over, which stay with people, and where a person makes the decision.
• Test the new design as a prototype within days, before you invest in integration.

 

 

2. Give agents company context instead of better prompts

 

An agent can only work with the knowledge it can reach. If that knowledge is out of date, sits in separate systems or exists only in people’s heads, no prompt will fix the result. Companies that scale AI build a central intelligence layer: one place that brings together structured data, documents and business rules as a single source of truth.

• Begin with the knowledge one process needs. Cleaning up the whole company at once will stall.
• Name an owner for every knowledge source who keeps it current.
• Write down the rules that so far exist only in people’s heads, such as exceptions, thresholds and who decides what.
• Archive old versions. An agent cannot tell which of three price lists is the valid one.

 

 

3. Put domain experts in the driver’s seat

 

The people closest to a process usually understand the problem best. They do not need to become software engineers. What they need is enablement, so they can turn their expertise and requirements into a first working solution with AI. I recommend creating a clear role for this: the prototyper.

• Select one or two prototypers per business unit who know the process in detail and enjoy trying things out.
• Give them fixed time each week. Prototyping on top of a full schedule does not happen.
• Provide approved tools and a safe environment with test data.
• Agree on a clear handover with IT, who take care of security, integration and scaling once a prototype has proven its value.

 

 

4. Share reusable AI skills across the company

 

When an agent has learned how to do a task well in one team, other teams should be able to use the same instructions. In practice, these are simple text files with names such as SKILL.md or AGENTS.md. They describe step by step how to do a task, which tools the agent may use, and which quality checks the result has to pass. The files keep a history of every change, so everyone works with the latest version.

• Start with three to five tasks that many teams share, such as meeting summaries, offer drafts or report checks.
• Store the skills in one shared place with a named owner for each.
• Include tool access and quality checks in every skill, so results are consistent across teams.
• Review skills regularly and remove those nobody uses.

This also saves money. Agents no longer spend time and tokens working out the same process again and again.

 

 

5. Increase autonomy step by step

 

A new employee does not sign contracts on day one, and an agent should not act alone on day one either. I work with three stages:

• Observe and suggest. The agent watches the process and proposes actions. People do the work and compare.
• Act with approval. The agent prepares the action, and a person releases it.
• Act within clear boundaries. The agent works on its own inside clear limits, such as amounts, customer groups or data types.

Define in advance what an agent has to show before it moves to the next stage, for example a low correction rate over several weeks. Give every agent a named human owner. And agree that an agent can also move back a stage if quality drops.

 

 

What corporate leaders can do now

 

• Choose one process that matters for the business and ask how you would design it if AI had been there from the start.
• Check the knowledge behind this process. Find out where it sits, whether it is current, and who owns it.
• Name your first prototypers in the business units and give them time, tools and a direct contact in IT.
• Collect the instructions that already work in your teams and store them in one shared place with clear owners.
• Set an autonomy stage for every agent in use today, with boundaries, a human owner and criteria for the next stage.
• Measure the full process, including waiting and review time. Speed in one step tells you little about the result.

AI agents deliver results when the work around them is ready: a process that makes sense, knowledge they can rely on, experts who shape the solution, shared skills, and trust that grows with proven performance. None of this requires a large programme. You need one process, a small team and a few weeks of focused work.

What is your view? Which of the five building blocks is the biggest gap in your organisation today? Leave a comment and let’s learn together.