How agentic AI works: LLMs, orchestration, MCP, tools and the enterprise AI stack

Agentic AI is not simply a stronger model. It is an operating architecture that connects models to context, tools, permissions and controls so they can pursue defined goals and take permitted actions.

Decision brief

In brief

A business-focused explanation of how agentic AI works. KOR separates the model from the wider enterprise stack of context, tools, orchestration, state, runtime, permissions, controls and observability, and shows why autonomy should be governed at the action boundary.

Signal
Leaders are being offered agents, copilots and autonomous workflows, but the buying conversation often collapses model capability, integration, orchestration and authority into one label.
Implication
An organisation can deploy a capable model and still create an unreliable or unsafe agentic system if tools, permissions, state, approvals, observability and workflow boundaries are weak.
Decision
Assess the whole operating architecture — objective, model, context, tools, orchestration, state, runtime, identity, action authority and controls — before deciding where agentic behaviour is useful and what level of autonomy is justified.

A procurement leader asks an AI system to review the next quarter’s supplier renewals.

The instruction sounds simple. The underlying work is not.

To complete the task, the system may need to identify which suppliers are approaching renewal, retrieve contracts from a repository, interpret termination and notice provisions, inspect spend and performance data, compare policy requirements, identify commercial or operational risks, prepare a recommended action and create work in another system.

A language model on its own cannot do that reliably. It can reason over information placed in its context and generate a response. It cannot automatically know which contracts are current, which systems it may access, which account it should use, which actions it is allowed to take, when approval is required or how to recover when a downstream system fails.

Those capabilities come from the architecture around the model.

That distinction matters because agentic AI is increasingly being sold as though it were a model feature. It is not. An enterprise agent is a system: a model operating inside a set of instructions, data connections, tools, permissions, orchestration rules, state, runtime infrastructure and controls.

NIST describes agentic AI as systems that operate as autonomous agents capable of making decisions and interacting dynamically with users and systems. The UK Government’s August 2026 AI Insights guidance similarly describes agentic AI as systems composed of agents that can behave and interact autonomously to achieve objectives. These definitions are useful, but for enterprise design the practical question is more specific: what can the system perceive, decide and do, and under whose authority?

KOR’s central argument is:

Agentic AI is an operating architecture, not a model category. The enterprise risk and value sit in the connection between reasoning and action.

A stronger model may improve planning, classification or judgement. It does not by itself define the data the agent may see, the systems it may change, the amount it may commit, the people it may contact or the evidence it must retain.

That is why enterprise leaders need to understand the stack rather than the label.

In brief

Signal: AI is moving from answering and drafting towards systems that can select tools, coordinate steps and take actions across business applications.

Implication: Model quality is only one component of the operating system. Identity, permissions, orchestration, data quality, human approval and observability become material design decisions.

Decision: Define the objective and action boundary first, then select the architecture and level of agentic behaviour required to deliver it.

What agentic AI actually means

There is no single universal line at which software becomes “agentic”. Vendors use the term differently, and systems exist on a spectrum.

For enterprise purposes, KOR uses a practical definition:

Agentic AI is an AI system in which a model can choose among permitted actions, tools or workflow paths in pursuit of a defined objective, using feedback from the environment to determine what to do next.

Three conditions matter.

First, the system has an objective rather than a single isolated prompt. The objective may still be narrow: investigate an invoice discrepancy, prepare a sourcing event, reconcile a data exception or resolve a service request.

Second, the system has options. It can choose which source to inspect, which tool to invoke, whether more information is needed or which next step is appropriate within the allowed boundary.

Third, the system can act on the environment. That may be as limited as retrieving a document or as consequential as updating a record, sending a message, triggering a payment workflow or creating a contractual commitment for human approval.

This is different from saying the system is fully autonomous. Most useful enterprise agents should not be.

Autonomy is a design variable. It can be narrowed by the tools exposed, data available, permission scope, monetary thresholds, workflow state, human approvals, time limits and exception rules.

The relevant question is therefore not “Is this autonomous?” but “What authority has been delegated, for which objective, under which controls?”

An agent is not an LLM

A large language model provides reasoning and generation capability. It can interpret instructions, analyse text, classify information, propose plans and decide which available function appears appropriate.

An enterprise agent requires more.

OpenAI’s current agent tooling separates the model from instructions, tools, handoffs, guardrails, tracing and the execution environment. Microsoft describes agents as specialised AI assistants that combine models with knowledge, skills and actions. Google similarly separates models, grounding, tools, data architecture, orchestration and runtime.

These implementations differ, but the architectural lesson is consistent: the model is one layer of the agent system.

A useful procurement analogy is a category manager.

Intelligence matters, but a category manager does not operate through intelligence alone. They work within a role, have access to particular systems, use templates and data, follow approval rules, exercise delegated authority, record actions and escalate exceptions.

An agent needs the software equivalent of those boundaries.

The KOR enterprise agentic AI stack

KOR proposes ten components for understanding an enterprise agentic system. The purpose is not to prescribe one technical platform. It is to make the operating dependencies visible.

1. Objective and instructions

The system needs a defined outcome and operating rules.

“Help with procurement” is not an objective. “Identify renewals due within 120 days, assess commercial and contractual exposure, and prepare an action pack for category-owner approval” is closer to one.

Instructions define what success looks like, what the agent should prioritise, what it must not do and when it should stop or escalate.

Weak objectives create weak agents. If people cannot describe the process and decision boundary clearly, giving a model more freedom rarely fixes the problem.

2. Model

The model provides language understanding, reasoning, planning and generation.

Different tasks may justify different models. A low-cost classification step may not need the same model as a complex contractual analysis. Some architectures use more than one model, routing work according to cost, latency, modality or required reasoning depth.

Model selection therefore belongs inside the design rather than defining it.

3. Context and grounding

The agent needs relevant information about the task and environment.

That can include policies, contracts, supplier records, taxonomy, spend data, historic decisions, user context, workflow state or externally retrieved information.

Context can be supplied directly, retrieved dynamically or accessed through tools. Retrieval-augmented generation is one pattern for grounding a model in external information; it is not the only one.

The operating question is whether the information is current, authoritative, permitted and sufficient for the decision being made.

4. Tools

Tools are the actions the model is allowed to invoke.

A tool may search a repository, query an ERP system, create a purchase request, calculate a value, update a supplier record, send an email or call another service.

Tool design is where abstract reasoning becomes operational capability.

That makes tool exposure a governance decision. Giving an agent a read-only contract search tool creates a very different risk profile from giving it a supplier-master update function or payment authority.

5. Orchestration

Orchestration determines how the work moves between models, tools, deterministic logic, approvals and other agents.

A simple architecture may have one agent deciding which tool to call next. A more structured workflow may use fixed steps for high-confidence process stages and agentic reasoning only where judgement or variability justifies it.

OpenAI’s agent frameworks support patterns such as handoffs and agent-as-tool delegation. Microsoft distinguishes between built-in orchestration and custom engine approaches. The implementation choices vary, but the enterprise decision is the same: where should the path be fixed, and where should the model be allowed to choose?

KOR’s default position is to use deterministic workflow where the process is stable and rules are known, and to introduce agentic choice where variability, ambiguity or unstructured information creates genuine value.

Agentic does not mean better. It means less of the path is predetermined.

6. State and memory

Agents often need to know what has already happened.

Short-term state can include the current task, actions taken, tool outputs, pending approvals and unresolved exceptions. Longer-term memory may store preferences, prior outcomes or learned context.

These concepts are frequently collapsed into “memory”, but they create different requirements.

State supports continuity of execution. Long-term memory creates questions about retention, provenance, correction, access and whether historic information should influence future decisions.

An enterprise should decide explicitly what the system may remember rather than treating persistence as a convenience feature.

7. Runtime and execution environment

The agent needs somewhere to run.

Longer-horizon systems may require environments where they can work with files, execute code, maintain task state and resume after interruption. OpenAI’s September 2026 Agents API announcement reflects this shift towards managed infrastructure for agents that may operate for extended periods.

Runtime design affects resilience, isolation, credentials, cost, observability and incident response.

8. Identity and permissions

An agent should not inherit unlimited organisational access simply because the person requesting the task has broad access.

NIST’s 2026 work on agent identity and authorisation focuses directly on this problem: agents need identifiable principals, scoped permissions, auditable authority and controls over the data, tools and applications they can access.

This is one of the most important enterprise design questions.

A sourcing agent that can read supplier data is different from one that can issue communications. One that can prepare an approval is different from one that can approve it. One that can create a purchase order is different from one that can release funds.

Permissions should reflect the minimum authority required by the use case.

9. Guardrails and human approval

Guardrails constrain what the system may accept, generate or execute.

They can include deterministic validation, policy checks, content restrictions, risk classification, tool-level limits and explicit approval gates.

Human oversight should be placed where judgement or accountability is genuinely needed. Adding approval to every low-risk action can make the workflow unusable. Removing approval from material commitments can make the system indefensible.

The goal is not “human in the loop” as a slogan. It is human judgement at the decisions where it adds control or decision quality.

10. Observability and evaluation

A conventional application can often be tested around expected inputs and outputs. Agentic systems create variable paths.

Organisations therefore need to see what the agent attempted, which tools it used, what data it accessed, where it received approvals, how long tasks took, where failures occurred and whether outcomes met the intended objective.

Tracing and evaluation are part of the operating model, not developer conveniences.

Without them, a team may know that an agent completed a task without understanding the path it took to get there.

How agentic AI worksA business-focused explanation of how agentic AI works. KOR separates the model from the wider enterprise stack of context, tools, orchestration, state, runtime, permissions, controls and observability, and shows why autonomy should be governed at the action boundary.A KOR proposed framework for diagnosis and implementation; use it as a decision aid rather than a universal standard.

The KOR agent operating loop

Agentic systems are often described through a generic perceive–reason–act loop. KOR uses the brand’s established decision cycle because it makes the business logic clearer:

observe → orient → decide → adapt

Observe — gather signal

The agent receives the objective and gathers the information available to it.

That may involve reading the user request, retrieving documents, querying systems or inspecting workflow state.

The control question is whether the information source is permitted and authoritative.

Orient — frame the context

The model interprets the evidence, constraints and current state.

It may identify missing information, compare policy, determine which branch of a workflow applies or build a plan.

The control question is whether the system has enough context to proceed and whether uncertainty has been recognised.

Decide — choose a path

The agent selects the next action from the tools and options available to it.

This is where delegated authority becomes visible. Choosing to search another repository is materially different from choosing to submit a supplier change or execute a transaction.

The control question is whether the chosen action sits inside the permitted authority boundary and whether approval is required.

Adapt — realise the value

The system observes the result of the action and adjusts.

A tool may fail. New information may contradict the plan. A user may reject an approval. The environment may have changed.

The agent uses that feedback to continue, re-plan, escalate or stop.

The control question is whether the system can recognise failure and whether the organisation can recover safely.

Where MCP fits into the stack

Model Context Protocol is increasingly discussed alongside agents, but it should not be confused with agentic intelligence.

MCP is an open standard for connecting AI applications to external systems where data and tools live. A server can expose capabilities such as tools and resources; compatible hosts can connect to those capabilities through a common protocol.

The current MCP specification, released on 28 July 2026, moved the protocol towards a stateless request/response core, added stronger routing and authorisation mechanisms and formalised an extensions framework. The maintainers describe it as infrastructure for production agentic workflows.

For a business leader, the significance is straightforward: MCP can reduce the need to create a bespoke integration pattern for every combination of AI application and enterprise system.

It does not decide whether a tool should be available, whether the model should invoke it, what authority the user or agent has, whether the underlying data is correct or whether the resulting action is appropriate.

MCP standardises part of the connection. Governance still sits around the connection.

This distinction will be covered separately in KOR’s supporting guide to Model Context Protocol.

Four common architecture patterns

Agentic systems do not all need the same design.

Pattern 1: deterministic workflow with agentic steps

The overall process remains fixed, but AI is used inside selected stages.

For example, a sourcing workflow may have defined gates for intake, approval, event launch and award. AI may classify the request, draft requirements or analyse supplier submissions inside those gates.

This is often the strongest enterprise starting point because the organisation retains a clear process while applying model reasoning where it creates value.

Pattern 2: single agent with tools

One agent receives the objective and chooses among a defined set of tools.

This works well when the domain is coherent and the action space is controlled. A contract-review agent may search the repository, retrieve templates, compare clauses and create an analysis without needing multiple specialised agents.

Pattern 3: routing and delegation

A coordinating agent routes work to specialised capabilities or other agents.

One component may handle supplier research, another contract interpretation and another financial analysis. The orchestrator decides which specialist to invoke.

This can improve modularity, but it creates additional handoff, tracing and authority questions.

Pattern 4: multi-agent workflow

Several agents collaborate over a longer-running task.

This is the architecture most likely to attract attention because it appears sophisticated. It is also the easiest to overuse.

Multi-agent designs introduce additional context transfer, coordination, cost, latency, failure and security surfaces. They should be selected because the task genuinely benefits from separation of roles, not because multiple agents sound more advanced.

Agents, copilots and automation are not the same thing

A deterministic automation follows rules and paths established in advance.

A copilot assists a person with analysis, generation or recommendation while the person remains the primary actor.

An agent can select and execute steps towards an objective within a defined authority boundary.

The distinction matters because these architectures create different control requirements. A system that drafts a supplier email creates a different risk from one that decides to send it. A system that recommends a purchase order creates a different risk from one that releases it.

The supporting KOR article on AI agents, copilots and automation will define these boundaries in more detail.

The control boundary matters more than the autonomy label

Vendors often describe autonomy as a maturity advantage. Enterprise buyers should be more precise.

The relevant dimensions include:

  • information authority — what the system may see;
  • decision authority — what judgements it may make or recommend;
  • action authority — what systems it may change;
  • commercial authority — what commitments it may create;
  • communication authority — who it may contact and in whose name;
  • duration — how long it may continue without renewed instruction;
  • exception authority — whether it can deviate from a normal workflow;
  • escalation — when a human or another system must intervene.

An agent may be highly capable while retaining narrow authority. That is often desirable.

The objective should be appropriate delegation, not maximum autonomy.

What changes for enterprise governance

The NCSC’s May 2026 guidance on careful adoption of agentic AI recommends a cautious but practical approach: understand dependencies, monitor behaviour, threat-model deployments, plan for incidents and start with well-understood, lower-risk tasks.

That advice is important because existing controls do not disappear when the model becomes more capable.

Identity still matters. Access management still matters. Supplier assurance still matters. Data classification still matters. Change control still matters. Incident response still matters.

The difference is that an agent can combine those components dynamically and act across them.

This creates several operating risks.

Tool misuse and prompt injection

If an agent can use tools, malicious or misleading content can potentially influence which tool is selected or how it is used. The more consequential the tool, the more important validation and permission boundaries become.

Excessive permissions

Broad credentials turn model errors into operational errors. Least-privilege access and scoped identities matter more when software can independently choose actions.

Hidden dependencies

An agent may rely on models, APIs, MCP servers, plugins, datasets and subprocessors from several suppliers. That makes AI supplier due diligence part of the architecture rather than a separate procurement exercise.

Variable execution paths

Two apparently similar requests may produce different sequences of actions. Logging the final output alone is not enough.

Long-running state

An agent that operates over hours or days may encounter changed data, revoked permissions, new instructions or failures that did not exist when the task began.

Shadow agentic AI

As AI tools become easier to connect to enterprise applications, the Shadow AI problem can extend from unapproved prompts to unapproved actions. Organisations need visibility over connected tools and agents, not only public chatbots.

Procurement has two roles in the agentic transition

Procurement will use agents inside its own workflows, but it will also buy them for the rest of the organisation.

That creates a dual responsibility.

Inside procurement, agents may support activities such as supplier discovery, intake triage, market research, contract analysis, renewal management, data quality or workflow coordination.

Across the enterprise, procurement will increasingly assess suppliers whose products contain agentic capabilities or whose services are partly delivered through agents.

The buying process therefore needs to establish more than whether a product “has agents”.

Procurement should be able to determine:

  • which models and services support the capability;
  • which enterprise systems the agent can access;
  • how identities and credentials are managed;
  • what tools are exposed and what each can do;
  • whether actions require approval;
  • what the supplier logs and makes visible to administrators;
  • how model, tool or MCP-server changes are controlled;
  • how the system handles failure, rollback and incident investigation;
  • whether customers can restrict or disable agentic functions;
  • how usage and cost are measured;
  • which parts of the architecture are supplied by third parties.

An AI supplier assessment that stops at model security will miss much of the operational risk.

Agentic AI readiness is broader than technical integration

An organisation can connect an agent to several systems and still be poorly prepared to use it.

KOR’s Procurement AI Readiness work separates visible activity from the organisational capability required for controlled scale. The same distinction applies here.

Agentic readiness depends on whether the organisation has usable processes, defined ownership, reliable data, permission design, control evidence, adoption capability and a clear basis for deciding which actions may be delegated.

This also links to the Enterprise AI Adoption Model. People are more likely to work with an agent when its role is clear, its behaviour is understandable and escalation remains credible. Adoption weakens when employees are expected to trust opaque automation simply because it has been deployed.

Technical capability and organisational adoption should therefore be designed together.

A practical decision sequence for leaders

Before selecting an agent platform or approving an agentic use case, leaders should make five decisions.

1. Define the outcome

State the operational problem and the result required.

Do not begin with “where can we use agents?” Begin with the work that needs to improve.

2. Map the current process

Identify the systems, data, decisions, exceptions and approval points already involved.

If the real process is not understood, an agent will automate assumptions rather than reality.

3. Separate reasoning from action

Identify which parts need interpretation or judgement and which parts are deterministic.

Use rules where rules are sufficient. Use agentic reasoning where the work genuinely contains ambiguity or variability.

4. Define the authority boundary

Specify what the system may read, recommend, draft, change, communicate and commit.

Place human approval where material judgement or accountability remains necessary.

5. Design the evidence loop

Decide what will be logged, measured and reviewed after deployment.

The organisation should be able to determine not only whether the agent completed tasks, but whether it produced useful, controlled outcomes.

The architecture should follow the work

The most important agentic AI decision is not which agent platform to buy.

It is deciding where variable machine reasoning should be allowed to influence or execute real work.

That requires a more disciplined view than “assistant versus autonomous agent”. The enterprise stack matters: objectives, models, context, tools, orchestration, state, runtime, identity, permissions, guardrails and observability all determine whether the system is useful and governable.

Model intelligence can improve rapidly while the operating environment remains weak. That is why stronger models do not remove the need for process design, commercial judgement or governance.

The useful path is narrower and more practical: automate deterministically where the process is stable; apply agentic reasoning where variability creates genuine value; keep authority explicit; and maintain evidence about what the system actually does.

KOR approaches agentic AI as an operating-model and decision-intelligence problem. The objective is not to maximise autonomy. It is to apply machine reasoning with enough structure, permission and human judgement to improve the work without losing control of the decision environment.

References

  1. 01AI Insights guidance · Research source · accessed 2026-09-19
  2. 02Agents API announcement · Research source · accessed 2026-09-19
  3. 03careful adoption of agentic AI · Research source · accessed 2026-09-19
  4. 04NIST — AI Agent Standards Initiative · Research source · accessed 2026-09-19
  5. 05UK Government — AI Insights: Agentic Workflow · Research source · accessed 2026-09-19
  6. 06OpenAI — Agents SDK · Research source · accessed 2026-09-19
  7. 07Microsoft Learn — Agents hub · Research source · accessed 2026-09-19
  8. 08Google Cloud — Core concepts of AI agents · Research source · accessed 2026-09-19
  9. 09Model Context Protocol — 2026-07-28 specification release · Research source · accessed 2026-09-19