Beyond AI pilots to operational profit

Why your AI strategy is stalling

Most large organisations now have AI agent pilots. Very few have agents doing real operational work at scale, autonomously, day after day, in production. The common assumption is that the technology is not developed enough, and that the next model releases will close the intelligence gap for more effective, more reliable agentic work. The published research, and our own client work, say otherwise.  

Agents stall because the business knowledge that makes data usable lives in people's heads rather than in the systems an agent reads: what a figure really means, whether it is up to date, and who is allowed to act on it. That gap was always there and people quietly filled it, but agents cannot. The good news is that it can be closed in a deliberate order, on top of the systems you already run, and here are 6 points that matter most:  

The problem is missing business knowledge, not weak AI

‍When AI is given a short written explanation of the business rules behind each question, its accuracy improves by more than it does from moving to a newer, more expensive model. Experienced people benefit from the same notes. The limiting factor is how well your data is explained, not how clever the AI is, so waiting for better models will not fix it.   ‍

Value is moving to agents faster than organisations are getting ready

‍Almost half of companies now report value from AI, and agents are a fast-growing share of it. Yet only around one in twenty has the controls in place to let agents act on their own. Most AI use today is still people drafting and summarising with a chat tool, where a person checks every result before it goes anywhere.  

Poorly explained data is a bigger problem the larger you are

‍Among UK businesses already using AI, data complexity is a recognised barrier, and large organisations cite it far more often: 39%, against 23% across all firms. Skills, cost, and regulation matter too, but an agent built by a skilled team on data nobody has explained will still give unreliable answers.   ‍

Dashboards hid the problem. Agents expose it

‍A report works because the person reading it knows which numbers are provisional, which system finance trusts, and what an odd spike usually means, and importantly how to verify it. That knowledge was never written down; an agent reads the same data without it, then acts on what it finds, and nobody is positioned to notice when it gets it wrong. The person understood the meaning behind the numbers and knew how to act on the numbers with incomplete information about everything else

A successful pilot is not proof that an agent is ready for production

‍Pilots show what an agent can do on a good day, with tidy data and an expert watching. Production needs it to be right every time, unattended. In one customer-service test, a leading model completed 61% of tasks on a single try but fewer than 25% when it had to succeed on all eight tries. A successful agentic deployment relies on consistent capability in varied data conditions, rather than peak capability in excellent data conditions.  

Readiness can be judged, and built, in four steps, without replatforming

‍We assess each workflow against four layers, in order: can the agent reach the data; does the data explain itself; can it be trusted; and may the agent act, leaving a record. Most failed pilots skipped the first two. Each layer sits on top of existing systems. One client that built this foundation earned £6.22m–£7.54m of incremental profit from an agentic capability in two quarters.  

What this means for IT and Data teams

Treat the data foundation as the first deliverable of any agent programme; it is likely to be the biggest deliverable of the programme, but it sets the foundation for all future work.  

Start with a short list of workflows that matter commercially, find the first layer each one fails, and fund that work with its own measurable milestones. The organisations running agents in production in 2027 will be the ones that wrote down what their data means in 2026.  

The rest of this paper explains why legacy data blocks agents, sets out the four layers in more detail, and shows how three clients built them. A companion paper, Part 2: The evidence, contains the full research tables and the technical reasoning should you wish to explore it.  

Next step

You can book an Agentic AI Readiness and Opportunity Assessment. We score your estate against the four layers and return a ranked list of the workflows that are ready now, the ones with gaps, and the data work that stands between each workflow and production.  

The value is moving to agents but the data is not ready

Enterprise AI is starting to pay off: in 2024, 74% of companies had yet to show tangible value from AI; by 2026, almost half report value. Agents are a growing share of it: BCG puts agentic AI at 22% of total AI value this year, up from 17%, and close to 40% by 2030. Yet while 42% of companies expect agents to act independently by 2030, only 5% have the controls in place to let them.  

• ~50% of companies now generate value from AI, up from about a quarter in 2024 (BCG, 2024 and 2026).  
• 22% of AI value now comes from agents, projected to reach close to 40% by 2030 (BCG, 2026).  
• 5% of companies have the full set of controls agents need (BCG, 2026).  
• 85% vs 7% of UK firms using AI use text generation, against agentic AI (DSIT, Fieldwork 2025).  
• 32% vs 18% report significant barriers implementing agentic AI, against text generation (DSIT, Fieldwork 2025).  
• 39% of large UK firms using AI say data complexity holds back wider use (DSIT, Fieldwork 2025).  

Individual vs. enterprise productivity

Many of today's AI gains are individual: a person pastes an email chain into a chat window, with attachments, gets a draft, checks it, edits it, and sends it on. What took them half a day now takes one or two hours. The person chooses the input and judges the output, so the tool only has to write well, take in a limited amount of context, and output something reasonable enough for the person to judge and edit, saving keystrokes and some planning time. The individual takes the responsibility for distilling meaning, providing instructions, editing, and so on.  

An enterprise workflow is different: several steps, several systems, often several people if not several teams. An agent running it has to find the right data, interpret it correctly, know whether it is current, and act on it without a person checking each step. Pasting content into a chat window does not scale to this level, because the judgement the person supplied is exactly what the agent lacks, and it is missing.  

BCG notes that AI produces visible results quickly, creating an impression of progress while the harder work is missed. The pilot looks finished because someone is still quietly supplying the context, or the context for the pilot is limited enough to maintain a high level of performance within a narrow bound of tasks.  

What is holding it back

In DSIT’s study, data complexity is not the most cited barrier; skills and tooling come first. Skills and tooling matter more than the ranking may suggest, as it scales with the organisation: it rises from 23% to 39% among large businesses (those with 250 or more employees, a subset of the AI users above), and 84% of large businesses that cite it rate it significant. Second, it compounds: a skilled team building on undocumented data still produces an agent that fails, albeit with a different failure mode.  

The survey cannot say which barrier causes which, but in our experience they travel together: teams without data skills cannot document the estate, and an undocumented estate makes every project look like a skills problem. This paper concentrates on the data.  

When respondents describe data complexity, they describe systems that do not link together and definitions nobody wrote down. The standard response is a semantic layer: a governed description of what the data means, held on top of the systems that store it. Google Cloud's Knowledge Catalog, the evolution of Dataplex Universal Catalog, brings Looker's semantic model and BigQuery business measures into one governed context that agents query before acting. The Meaning layer below is the same idea.  

Context beats a better model

The “BIg Bench for LaRge-scale Database Grounded Text-to-SQL Evaluation” benchmark, or BIRD for short (a NeurIPS 2023 benchmark), ran the same business questions against the same databases twice: with and without an expert-written note giving the business rule, formula, or code mapping each question needs. That note is what an experienced analyst carries in their head.  

• Upgrade the model (GPT-3.5 → GPT-4, no documentation): +8.1 pts accuracy gain  
• Add business documentation (same GPT-3.5 model): +12.5 pts accuracy gain  
• Human experts given the same documentation: +20.6 pts accuracy gain  

Documentation beat the model upgrade, and helped human experts most of all: better readers get more from it, not less. This is a property of the estate, not of machines, and it was costing your analysts long before anyone mentioned agents. One of the differences is that for analysts it was an internalised set of processes that they followed that were largely unobservable, whereas with agents, the same symptoms are visible for all to see.  

Picture two analysts with equally good SQL skill, one with five years at the company and one with three months. They query identical data, but one sees a schema and the other sees a business and all the ways the business operates: what the question is really asking, what usually goes wrong, which teams will be impacted by this output, and what to check first. A knowledge layer writes that difference down.  

On Spider 2.0, built from real enterprise databases that often exceed 1,000 columns, leading models first solved 10–17% of tasks. The best systems now score above 90%, mostly by checking the context they are given more carefully rather than switching to a more expensive model. Better models raise the ceiling. The data layer raises the floor, and production runs on the floor.  

More context is not the answer: a model handed the right document buried among 20 others did worse than with none at all.  

Why dashboards succeed where agents fail

A dashboard still works, but not for the reason people assume. It works because a human supplies the meaning the schema does not contain. Before trusting a figure, the reader knows which system finance signs off, that 'revenue' here excludes returns, that anything after Wednesday is provisional, and that a sudden drop in one region usually means a feed failed rather than customers left. None of this is in the schema. It sits in the reader's head, built up over years, and is applied each time the dashboard is opened.  

An agent has none of it. It reads the same table, with the same ambiguous column names, and then does something the dashboard never required: it acts on the result. A dashboard that misleads a person is usually caught by that person's judgement before it matters. An agent that misreads the same column makes a decision, and nothing else in the workflow is positioned to notice. The cost of an undocumented estate was always there; people absorbed it through checking, rechecking, and rework. Agents make it visible.  

"Legacy architecture is built to produce a report for a human, who injects the meaning into the numbers — not a decision for a machine. Remove the human and the meaning often leaves with them."

The four layers in the next section name what the human reader supplied:

1. Reach: Knowing where to look.  
2. Meaning: Knowing what the numbers mean.  
3. Trust: Knowing whether they are current, and whether two records describe the same customer.  
4. Authority: Knowing what may be done with the result.  

Moving from a dashboard to an agent means writing each of these down in a form a machine can read.  

Key insight

‍Teams skip the Meaning layer because it produces no demo, so nobody sees its cost until it exists. Production rewards consistent capability over peak performance capability, just like an athlete's best-ever lift matters a lot less than what they can repeat on competition day, no matter what day it is, and no matter how many negative factors are stacked up against them. The data layer is where consistency is bought first.  

The four layers of an agentic data foundation

We assess readiness in four layers, each a prerequisite for the next. In our delivery experience, most failed pilots trace back to building at layer three or four on a layer one or two that was not quite finished. Meaning is the layer the benchmarks measure most directly.  

1. Reach - can an agent find and get to the data, on demand?

• What the layer asks: Can an agent find and get to the data, on demand?  
• What a human analyst used to supply: Knowing where to look.  

Reach covers access and search. Access asks whether the data exists digitally, in a complete record, and whether an agent can request it at the moment of decision without a person in the loop. Nightly batch jobs, CSV drops, and systems with no API fail here. Search asks whether the agent can work out which of dozens of systems holds the answer and what each field is called there. The failure is measurable: in an analysis of 500 failures on BIRD, picking the wrong table or column accounted for 41.6%.  

2. Meaning - does the data explain itself?‍

• What the layer asks: Does the data explain itself?  
• What a human analyst used to supply: Knowing what the numbers mean.

Documented schemas, one agreed definition per business metric, and written business rules. Does 'active customer' mean the same thing to the team that owns the data and the team that uses it, or is there only the appearance of agreement because nobody has compared notes? This is the layer the benchmarks price, and the one most often skipped. Consolidating storage fixes fragmentation, which is a Reach problem. It does not fix meaning. Agreeing a definition can be done without moving a single table.  

3. Trust - is it current, resolved, and traceable?

• What the layer asks: Is it current, resolved, and traceable?  
• What a human analyst used to supply: Knowing whether to believe it.  

One customer should be one record across systems. Every figure should trace to a source, and every table should carry a known freshness. Without this, an agent's output cannot be checked, which is worse than a wrong answer a person can spot. A slow pipeline that is documented is a constraint you can design around; one nobody recorded is an error delivered with confidence.  

A single source of truth helps, but it is not sufficient. It settles which record is authoritative; it does not tell an agent what a field means, how fresh it is, or when a definition changed. Organisations with a mature single source of truth still see agents fail when that knowledge lives only with the people who maintain it.  

People also sense when a figure feels wrong and pause to check. Agents do not do this unaided: models tuned on human feedback are often poorly calibrated, so a stated confidence of 0.9 is not a 90% chance of being right. That signal has to be built around the model, from documented freshness, lineage, and measured accuracy on the organisation's own questions.  

4. Authority - can the agent act within scope, leaving a trail?

• What the layer asks: Can the agent act within scope, leaving a trail?  
• What a human analyst used to supply: Knowing what may be done with it.  

This is where data governance meets agent governance, and where most organisations are least prepared. Three things matter:  

1. Permissions must travel with the data. When documents are copied from source systems into a vector index for retrieval, the access controls on the originals are often left behind. Anyone who can query the agent can then reach content they could not open directly. The fix is to carry each document's access metadata into the index and check it against the person asking, at query time.  
2. Every agent needs its own identity and a usable trail. If five agents and a batch job share one credential, there is no per-actor audit trail and no way to revoke one actor's access without breaking the others. Logs must be detailed enough to reconstruct, months later, why an action was taken.  
3. Actions should be classified by reversibility. Only reversible actions should run unattended, with a person able to review the rest.  

There is also a regulatory floor. Since 5 February 2026, UK GDPR Article 22C has required organisations making significant decisions solely by automated means to let people obtain human intervention and contest the decision. Contesting a decision needs a record of why it was taken, and that cannot be retrofitted to logs that were never written. Scope matters for security too: content an agent retrieves can act as instructions to it, so the access an agent is granted is also its attack surface.  

What happens when a layer is missing

Layers Built: Reach | Layer Missing: Meaning

• What actually happens: The agent reaches the wrong data faster than anyone can notice. At best the answer is obviously wrong. At worst it is only subtly wrong, and a year of reports or forecasts fails an audit before this error is found.  

Layers Built: Reach, Meaning | Layer Missing: Trust

• What actually happens: Correct queries over stale or duplicated data, reported with confidence and no signal of when they break down.  

Layers Built: Reach, Meaning, Trust | Layer Missing: Authority

• What actually happens: A reliable read-only adviser that cannot act. At this level, for some workflows and approaches this is enough for the agent to start feeling useful.  

Layers Built: All four together, built in order | Layer Missing: —

• What actually happens: A workflow that can run largely unattended, be audited, and be reversed or diagnosed when needed.  

Evidence from client work

Three client programmes sit at different points on the same path. Each uses the same four-layer structure, with differences in where the data starts and how far up the stack each has built.  

1. Automotive manufacturer: an agentic capability with a hard return

• Status: Agentic · In Production  
• Source: Lead and customer records, per market  
• Layer 1 (Reach): One alerting and scoring system across markets  
• Layer 2 (Meaning): Scoring, routing, and journey logic written down  
• Layer 3 (Trust): Market records reconciled before scoring  
• Layer 4 (Authority): Agent recommends, people act; actions reversible  
• Consumer: Sales and call-centre teams  

Overview: A major automotive manufacturer held large volumes of lead and customer data across markets, fragmented and unscored, with call-centre planning run on manual triage. We built lead alerting and scoring, then added customer journey modelling, agentic call-centre planning and lead prioritisation, and generated lead reports for sales teams. The second phase generated £6.22m–£7.54m of incremental profit across two quarters: a reported, board-level figure, not a model. It is a multi-year build that began with a strategy workshop in early 2025. The agent recommends and people make customer contact, which keeps every action reversible.  

2. Consumer brands group: fixing the foundation first

• Status: Foundation Only · No Agent  
• Source: Per-brand source systems  
• Layer 1 (Reach): Single BigQuery warehouse  
• Layer 2 (Meaning): dbt layer: cross-brand definitions agreed  
• Layer 3 (Trust): Errors down by close to 99%; changes traceable  
• Layer 4 (Authority): Security Command Center; no agent identity needed yet  
• Consumer: Brand teams, self-serve in Looker  

Overview: A global consumer brands group ran each brand on its own systems. One cross-brand campaign question took most of a week of manual reconciliation. We built a unified BigQuery platform with a governed dbt transformation layer, where cross-brand definitions were agreed and written down, self-serve Looker reporting, and security designed from the start. Reporting time fell by roughly two weeks per cycle, cross-brand analysis ran up to three times faster, and reconciliation errors fell by close to 99%. No agent was involved. This is the foundation an agent needs before it can be trusted to act. With a foundation like this, future agentic workflows and systems can be built on top.  

3. Payments platform: building ahead of agent-led commerce

• Status: Foundation Ahead of Agent-Led Checkout  
• Source: Product and transaction data  
• Layer 1 (Reach): Real-time transaction graph  
• Layer 2 (Meaning): Attribute-rich, agent-legible catalogues  
• Layer 3 (Trust): Freshness addressed; resolution and lineage to follow (Partial)  
• Layer 4 (Authority): Needs identity, scoping, and audit for checkout (Not yet in place)  
• Consumer: Shopping agents (Future)  

Overview: A global payments platform found its product and transaction data was legible to analysts but not to an autonomous shopping agent. Product data was restructured into attribute-rich catalogues written for a machine reader, paired with a real-time transaction graph. There is no financial figure on record and we will not invent one. The return is the option to take part in agent-led checkout as that channel matures. Authority is the work still ahead: a payment is close to the archetype of an irreversible action.  

Read together, the cases make one argument: fix the foundation first, as the consumer brands group did. Make the agentic capability a deliberate design choice, as the payments platform did. Sustain both over a multi-year build, and the return looks like the automotive case.  

Closing the foundation gap

The gap between a documented data estate and an undocumented one is measurable, and it is roughly the same for people as for machines. Three years of model releases have not closed it, because it is not a model problem, even though more intelligent models of course show promise. The leaders on enterprise benchmarks did not wait for better models; they engineered the context around the ones they had, which proved to be effective in addressing these challenges.  

That gap can be closed in order, and closing it rarely requires replatforming in full. It requires treating documentation, entity resolution, and scoped identity as products in their own right, and treating the “problem context” as its own product, which evolves and has its own maintenance schedule. Your agents are not underpowered; your data estate is unreadable to them. The organisations running agents in production in 2027 will be the ones cataloguing their data estate now.

We propose the following questions for your next meeting

• Which three workflows would we most like an agent to run, and which of the four layers does each fail first?
• Who owns the definition of our ten most-used business metrics, and is it written down where a machine can read it? Are those definitions agreed upon through the business, or do different teams treat the same data or inputs differently.
• Which of our agents share credentials, and which of their actions cannot be undone, and how does this impact company operations?

Next step

Book an Agentic AI Readiness and Opportunity Assessment. We score your estate against the four layers and return a ranked list of the workflows that are ready now, the ones with gaps, and the data work that stands between each workflow and production.