Topic — Agentic AI

What Agentic AI Actually Is

An agent is fundamentally a software loop: assemble context, reason about goals, execute actions, observe outcomes, repeat. Understanding this architecture separates true agents from chatbots, automation, and vendor marketing.

Get in touch

Where we support our customers

Strategy

Data & AI Strategy Operating Model Design Product & Vendor Selection

Decide the direction, before budget is committed.

Implementation

Operating Model Implementation AI Implementation & Scaling

Build it, then scale by composition.

Literacy & Adoption

Business leaders Technical teams End users

A continuous thread, matched to each group.

The Challenge

Agents everywhere. No architecture. Nothing compounds.

Most enterprises now have a dozen things called agents: vendor assistants inside the tools they already run, automation rebadged for the moment, and a few genuine pilots. But agentic has become a label, not an architecture. Without a shared line between an agent that decides its own next step and a flow that was scripted in advance, you cannot tell which is which, and you cannot govern what you have not defined.

Where real agents do exist, they are built one at a time, on whatever information happens to be there, with no operating model to hold them. Memory, tools, and feedback are rebuilt for each pilot. Knowledge stays ungoverned, so the loop reasons over noise. Nothing carries from one project to the next, and the capability never compounds.

Agentic in name only

Vendor assistants, rebadged automation, and real pilots all carry the same word. With no shared definition, an agent and a scripted flow look identical on a slide.

Reasoning on unmanaged knowledge

The platform surfaces information, but no controlled vocabulary, taxonomy, or ontology sits beneath it. The loop runs cleanly toward the wrong answer.

Pilots that don't compound

Memory, tools, and feedback rebuilt per project, with no governance or orchestration to hold them. Each agent starts from zero.

No engineering discipline

Prompts, configs, and model versions live in documents, untested and unversioned. A silent vendor update shifts behaviour, and capability accretes risk.

The Architecture

Agentic AI is not a new model, vendor category, or software framework. It is an architecture: a control loop built around an LLM. The loop is fixed code. The path through it is not. The user hands over a goal rather than a question. The system assembles context, the model reasons about the next action, executes it through tools, observes the outcome, and repeats, until the goal is met, an error occurs, or a step limit is reached.

The anatomy of an AI agent

An AI agent is fundamentally a software loop built around an LLM call. The loop is deterministic. The decision inside it is not.

Trigger User prompt • API call • Schedule • Event

Repeat until terminal

1 Assemble context Role and instructions, conversation history, available tools, trigger input, and the trajectory so far, built into a single string.

2 LLM call • reason and decide The context goes to the model. It reasons about the situation and outputs a single next action.

3 Execute action Map the output to a software function. Run it with the given parameters, then observe and collect the result.

4 Append to trajectory Add the action and its outcome to the trajectory. This becomes part of the context for the next iteration.

Terminal conditions Goal reached • Max steps • Error. Otherwise, loop back to step 1.

Actions the agent can call

Selected by the model at step 2, run at step 3.

Search the web
Find information online

Query a database
Retrieve structured data

Read or write files
Access or update files

Call an API
Integrate external services

Ask a question
Request clarification

Call another agent
Delegate to other agents

The only non-deterministic part

The LLM decision

Reasoning is non-deterministic. The model chooses the next action.

Everything else is deterministic

Software execution

Tool calls, data retrieval, and state updates all run deterministically.

The test

Does the system decide its own next step toward a goal it was handed, or follow a path it was given?

The distinction that matters is where the decisions are made. The user hands over a goal rather than a question, and the model chooses each action at runtime and decides when the goal is reached. In automation, those decisions were made in advance by whoever wrote the sequence. Both can be wrapped in a loop. Only one reasons inside it.

This is where most products carrying the label fall down. They keep the loop and script the decisions: predefined branches, fixed tool calls, the model reduced to filling slots in a flow someone already designed. The same confusion rebrands two further patterns as agentic: the chatbot (single turn, stateless, no goal to pursue) and retrieval (one search, then a stop).

So the test is not whether the system loops, calls tools, or uses an LLM. Many things do all three. The test is whether it decides its own next step in pursuit of a goal it was handed, rather than following a path it was given. Remove that, and you have a tool, not an agent.

Foundation

The Five Foundational Building Blocks

These are not optional features or vendor add-ons. Without all five, you have a tool, not an agent.

Memory

Persistent state across iterations

The agent maintains a trajectory—a running record of all actions, outcomes, and decisions. This becomes part of context for the next iteration, enabling learning and replanning. Without memory, each loop starts blind.

Tools

Controlled actions on real systems

The agent has access to take real actions: call APIs, update databases, query systems, send messages. Tools must be bounded with clear parameters and permissions. Without tools, the agent can only generate text.

Knowledge

Organized, accurate, stewarded context

The agent reasons over organizational knowledge: data schemas, business rules, entity definitions. This knowledge must be governed—steward-owned, quality-gated, versioned. Ad-hoc or stale knowledge breaks reasoning.

Feedback

Observation and course correction

The agent must evaluate whether its actions succeeded. Feedback mechanisms—evaluation, error detection, success criteria—let the agent learn and replan. Without feedback, it has no way to know if it's progressing toward the goal.

Orchestration

Coordination across multiple agents

The platform ships the tooling substrate. Your organization builds the ontology—the controlled vocabulary and structures that encode your domain. That second half decides whether the agent reasons or merely retrieves.

The half your platform ships

Tooling • the substrate

A store, schema, and binding layer that surfaces information from your data. You select it.

The half it cannot

Organisation • the structure

The taxonomy and ontology that encode your domain. Extraction surfaces salience; curation imposes intent. You build and steward it.

Complex goals require multiple agents coordinating: a planner decides the sequence, specialists execute tasks, results flow back for evaluation. Single agents handle simple goals; orchestration enables organizational workflows.

The operating model

The Agentic Operating Model

Agentic capability is built, not bought. The path is sequential: foundation first, architecture second, knowledge third, orchestration fourth, observability throughout.

The dial · everything below inherits from it

Leadership sets the dial

Intent Risk appetite Cost ceilings

The threads and the operating cadence inherit their settings from here, not from any single project.

The spine Frame → Govern → Found → Build → Operate

Frame & locate

Agree what agentic is, and what it is not, against automation and assistive AI. Inventory what already exists, and name the structural gaps.

You cannot route what you have not defined. Output: a shared language and an honest baseline.

Govern before you build

Stand up the decision function: one intake, score on value × complexity, route, sequence, and the step everyone skips — stop.

It comes first because it sets what everything downstream must serve. A list of use cases becomes a portfolio.

Lay the foundation

Three essentials, none optional: integration patterns that connect systems, identity covering both humans and agents, and the knowledge layer the agent reasons against.

Owned once and conformed to, not rebuilt per case.

Build through blocks

Separate features (what the business wants) from blocks (how they are delivered). Route each case to the cheapest block that fits, deterministic to agentic.

Put cost in the architecture, not everything to an LLM.

Operate & compound

Run the funnel on a cadence. Bring cost observability in at routing, not at the bill. Steer run-cost.

Stop what does not compound, so each cycle builds on the last.

The order Sequenced by dependency, not date. A block opens when the ones before it hold.

The continuous threads Started day one, never done, running across all five blocks

Literacy

Both conceptual and tactical. Matched to sponsors, function leaders, and builders — and paired with adoption mechanics for end-users.

Engineering practice

The discipline software already has (version control, testing, CI/CD, change review), applied to the AI artifacts that usually escape it: prompts, agent configs, tool definitions, and model versions.

Vendor sensing

Continuously redraw the buy versus build line as the market moves underneath it.

The spine + the threads = the operating model

Steered by leadership. Sequenced by dependency. Never finished. Run as one system, the convergence is the model itself.

Who It's For

Who Should Care About Agentic AI

Data & Engineering Leaders

You own system integration and governance. Agentic systems only work when your data layer is clean and your integrations are reliable.

Product & Strategy Leaders

You decide what to build and prioritize. Agentic systems enable new capabilities, but require 6-24 months of foundational work before ROI appears.

AI & Research Teams

You evaluate models and techniques. Agentic systems shift focus from model selection to architecture, feedback loops, and observability.

OPS

Ops & Governance Teams

You ensure safety, compliance, and risk management. Agentic systems require explicit boundaries, auditability, and cost controls that don't exist in basic LLM setups.

Questions

Frequently Asked

What's the difference between "AI agents" and "agentic AI"?

"AI agents" refers to autonomous software entities. "Agentic AI" describes the architectural pattern—a loop of context assembly, reasoning, action, observation, and feedback. A well-built agent implements the agentic architecture. A poorly-built one might skip key pieces (memory, feedback, governance) and fall back to being a sophisticated tool.

If a chatbot can call APIs, isn't that agentic?

No. A chatbot with API access is still fundamentally a chatbot: it waits for input, generates a response, and stops. It has no trajectory of outcomes, no ability to reason about goal progress, no loop. An agentic system calls APIs, observes results, updates its understanding, and decides what to do next—across multiple iterations toward a goal.

How long does it take to build agentic capability?

Organizations with existing data governance and clean integration typically take 6–12 months. Organizations starting from scratch should plan for 12–24 months. The biggest time sink is not the agent code—it's the foundation: data governance, knowledge stewardship, system integration, and organizational alignment.

Can we just buy agentic AI from a vendor?

No vendor sells a complete agentic system. They sell components: LLMs, frameworks, platforms, integration tools. You must architect and build the loop. This is inherent to the domain—every organization's goals, tools, data, and governance are different.

What causes agentic AI projects to fail?

Gartner predicts 40% cancellation by 2027. Failures are rarely about the LLM. They happen because: (1) No governance—agents reason over stale data. (2) No clear loop design—undefined goals or success criteria. (3) Siloed systems—the agent can't integrate needed data. (4) No observability—teams can't see what the agent decided. (5) Misaligned expectations—executives expect a product, teams need an architecture.

Discuss your agentic ambitions

Calling it agentic is easy.
The architecture is the work.

Tell us about your agentic ambitions. Sander or Pieter will reach out within one business day to scope a 30-minute review, tailored to your industry.

Independent advisory. No software to sell.
A prioritised portfolio. A business case for each.
Confidential. We don't share your information.

Our partners previously led Data & AI at