Agentic AI

01 What it is

Software that decides its own next step

Two contrasts make it concrete. A plain LLM call answers once; an agent decides which actions to take, observes the results, and iterates toward an objective. RPA follows brittle, hard-coded scripts; an agent reasons over unstructured inputs and adapts. Put simply, generative AI creates content on request; agentic AI acts to accomplish tasks. The defining traits are autonomy, goal-directedness, tool use, memory and planning.

02 Core concepts

The anatomy of an agent

• LLM as reasoning engine — the model orchestrates; it decides what to do, not just what to say.
• Tools / function calling — structured functions the agent invokes to act and fetch data.
• Memory — short-term (the context window) plus long-term (vector stores, databases, summaries).
• Planning — ReAct, plan-and-execute and reflection/self-critique strategies.
• RAG — retrieval-augmented generation grounds answers in fetched, trusted data.
• Orchestration & multi-agent — coordinating steps, and multiple specialised agents collaborating.
• Guardrails & human-in-the-loop — enforced constraints and human approval at key steps.
• Context engineering — deliberately curating what enters the context window — the core new discipline.

03 Architectures

Patterns from simple to autonomous

Anthropic's guidance is worth internalising: prefer workflows (predefined code paths) over fully autonomous agents until autonomy demonstrably earns its keep. Start simple.

04 Protocols

How agents connect in 2026

A simple rule of thumb: MCP connects an agent to tools and data; A2A connects an agent to other agents.

• Model Context Protocol (MCP) — Anthropic's open standard for connecting agents to tools and data — the "USB-C for AI". Rapidly adopted across the industry.
• Agent2Agent (A2A) — Google's protocol for cross-vendor agent-to-agent communication, donated to the Linux Foundation with 150+ organisations backing it.
• AGNTCY — an "Internet of Agents" infrastructure effort (Cisco, LangChain and others) under the Linux Foundation, interoperable with A2A and MCP.
• Function-calling schemas — JSON-schema tool definitions are the de-facto standard for how agents describe and invoke tools.

05 Key personas

Who builds agents

06 Methodology

Build an enterprise agent

The guiding principle across the field: start simple; add complexity — autonomy, more agents — only when it demonstrably helps.

07 Best practices

What good looks like

08 2026 trends

The agentic frontier

↻ Refreshed 2026-07-16 by the AI desk

09 In practice

From demo to business value

Agentic AI is the most hyped — and most scrutinised — category in enterprise tech. Here's where it delivers, what the analysts and platforms are actually seeing, and how SCIKIQ keeps agents grounded and safe.

What the leaders are doing

The forecasts are enormous and the cautions are blunt — the winners will be those who ground agents in trusted data and prove ROI.

10 Developer lab

Hands-on: build a grounded agent

# A minimal tool-calling loop (pseudo-Python)
while not done:
    step = llm(messages, tools=TOOLS)     # reason + choose tool
    if step.tool_call:
        result = run_tool(step.tool_call)  # act
        messages.append(observe(result))   # observe, then loop
    else:
        done = True

# A ReAct agent with a governed tool and persistent memory
from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic

def search_orders(customer: str) -> str:
    """Look up a customer's recent orders."""
    return db.query(customer)          # your governed data

agent = create_react_agent(
    ChatAnthropic(model="claude-sonnet-5"),
    tools=[search_orders],
    checkpointer=MemorySaver(),        # remembers across turns
)

resp = agent.invoke(
    {"messages": [("user", "What did Acme order last week?")]},
    config={"configurable": {"thread_id": "acme-1"}},
)

# Expose a governed metric as a tool over the Model Context Protocol
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("sales")

@mcp.tool()
def revenue_at_risk(product_line: str) -> float:
    """Revenue exposed to a delayed product line."""
    return warehouse.scalar(
        "select sum(net_amount) from fct_sales "
        "join dim_product using (product_sk) where line = %s",
        product_line,
    )

if __name__ == "__main__":
    mcp.run()          # any MCP client can now call this tool

# Least-privilege allow-list, plus trace-and-score every run
from langfuse import observe

ALLOWED = {"search_orders", "revenue_at_risk"}

def guard(tool_call):
    if tool_call.name not in ALLOWED:      # block anything off-list
        raise PermissionError(tool_call.name)

@observe()                             # full trace in Langfuse
def answer(question):
    result = agent.invoke(question)
    score = judge(question, result)        # LLM-as-judge eval, 0..1
    return result, score

The pattern the whole track builds toward: an agent reasons and calls tools, those tools are governed and exposed over MCP, and every action is permission-checked, traced and scored before anyone trusts it in production.

11 Analyst lab

Hands-on: scope agents that pay off

12 Career path

The fastest-moving, best-paid track

Agent engineering is among the hottest specialisms in tech. Bands are indicative US figures for a fast-moving market and vary widely by company and location.

13 Skill matrix

Rate yourself, then level up

Find your current row and aim one column right.

14 Glossary

Terms worth knowing

15 Test yourself

Check your understanding

16 Keep learning

Where to go next

Agents are only as good as the data and meaning beneath them. Revisit the foundations: