What is Agentic AI? The new era of AI agents

Agentic AI is the approach of running an LLM not as a single 'response generator' but as an 'action-taking subject' — receiving a goal, making a plan, using tools, observing results, and deciding the next move. 2023 was the chatbot era: 'ask a question, get an answer.' 2024 was the copilot era: 'helps while you work.' 2025-2026 starts the agentic era: 'you set a goal, the agent finishes the work end-to-end.' Example: ask a chatbot 'what are the risks in this contract?' and it lists them. Ask an agent and it says 'I'll analyse this contract, post risks to Slack, raise a legal review ticket if needed, then draft revisions for the supplier' — and does all of it. Key difference: the agent uses tools, observes outcomes and chooses what to do next.

1) Goal understanding: handle ambiguity at the level of 'get this done,' not 'do step X.' Given 'refund this customer,' the agent must derive the steps (check refund eligibility, fetch order, confirm with customer, initiate refund). 2) Planning: turn the goal into a task list. Good agents first produce a plan, then execute step by step; for complex tasks they break into sub-tasks. 3) Tool use: function calling, MCP — DB queries, API calls, file ops, web search, calculators. 4) Self-evaluation: after each step ask 'did this move me toward the goal?' — reflection. Without all four, you don't have an agent; you have a function-calling chatbot. Real agentic behaviour shows up in the reflection loop.

ReAct, introduced in the 2022 Princeton + Google paper, is the most useful agentic pattern. The loop: Thought (the model reasons) → Action (which tool, which args) → Observation (the result) → Thought → Action → ... → Final Answer. Example: goal 'sum the last three quarters of Acme's profit.' Thought: 'I need 2024 Q4 first' → Action: search('Acme 2024 Q4 net income') → Observation: '$3.2M' → Thought: 'Now Q3' → Action: search('Acme 2024 Q3 net income') → Observation: '$2.8M' → Thought: 'Now Q2' → Action: search → ... → Thought: 'Sum them' → Action: calculator(3.2+2.8+2.5) → Observation: 8.5 → Final Answer: '$8.5M'. ReAct's strength: because the model writes out its thoughts, you can debug it and back out of wrong paths. Claude, GPT-4 and Gemini all support a full ReAct loop via tool use.

Beyond ReAct, other production-grade patterns: Plan-and-Execute (popularised by LangChain): a 'planner' agent outputs the full plan (say, 5 steps), then an 'executor' agent runs each step. Pros: the plan is reviewable, parallel execution is possible. Cons: something learned mid-plan can invalidate it. Reflexion (Shinn et al., 2023): the agent runs the task, then in a 'reflection' step answers 'what went wrong, what did I learn?' and uses it on the next attempt. Dramatically reduces error. Self-Critique: after each output a 'critic' role evaluates and may regenerate. A minimum bar for production agents. Practical choice: short tasks → ReAct; long tasks → Plan-and-Execute; high-stakes/production → Reflexion + Self-Critique.

Multiple agents with different roles beat one agent at the same job. Classic example: 'software team' — Product Manager agent (requirements), Engineer agent (writes code), QA agent (tests), DevOps agent (deploys). Each has its own system prompt, tool set, and behaviour. Agents communicate via structured messages (a Message Bus / Inbox). Production patterns that work: (1) Pipeline: linear A → B → C. (2) Hub-and-spoke: a single 'orchestrator' coordinates the others. (3) Debate: two agents argue, a third 'judge' decides. (4) Specialist routing: a 'router' agent sends the request to the right specialist. Common frameworks for multi-agent: AutoGen (Microsoft), CrewAI and LangGraph. Practical rule: teams of 2-4 agents are most stable; 8+ agents start losing more in complexity than they gain in capability.

An agentic system that meets the same user across 50 sessions can't start from scratch each time. Three memory types. (1) Working memory: the last N messages in the current conversation — fits in the model's context window. (2) Short-term memory: across recent sessions / days — summaries of the last 100 interactions in Redis or Postgres. (3) Long-term memory: persistent knowledge — user profile, past agreements, preferences — stored as embeddings in a vector DB and searched on demand. In production, working + long-term is enough; a summariser agent rolls short-term into long-term weekly. Reminder: the model doesn't 'remember' on its own — every session rebuilds context. Agentic system = LLM + a well-designed memory layer.

(1) Autonomous Software Engineer: Devin, Claude Code, Cursor Composer; takes a ticket, plans, writes code, tests, opens a PR. (2) Supplier research agent: 'find me certified European X manufacturers', searches the web, validates, returns a scorecard (see our Procurement page). (3) End-to-end customer support agent with escalation: classifies the message, fetches knowledge from RAG, answers, calls refund if needed, escalates to a human. (4) Lead qualifier agent: researches the new lead, scores, drafts a meeting-request email when hot. (5) Operations agent: 'this metric got worse — why?' scans logs, correlates events, hypothesises. They share a skeleton: agentic loop + RAG + tools + memory + human-approval gates.

Agentic AI is powerful but not mature. Practical limits: (1) Hallucination: the model confidently produces false information — in an agentic system this turns into tool calls that actually happen. Mitigation: structured output + confidence + low-confidence fallback. (2) Compounding error in multi-step tasks: 10 steps at 95% each = 60% total success. Short, narrow tasks are more reliable. (3) Wrong tool choice: agent calls the wrong tool and takes an irreversible action. Mitigation: human approval required for irreversible tools. (4) Prompt injection: user or data source slips a malicious command ('delete all files'). Mitigation: trusted vs untrusted data separation, output filtering, allow-listed tools. (5) Runaway cost: an agent loops and makes 1000 LLM calls. Mitigation: hard caps (max_iterations, max_cost). Control these five and the agent is stable in production.

Picking a framework matters. LangGraph (LangChain team): graph-based state machine for agents; most mature for production. Supports complex flows (multi-agent, cycles, parallel) and ships a Studio for debugging. CrewAI: designed for role-based multi-agent — quick to stand up 3-5 agent teams with a clean API. AutoGen (Microsoft): a 'conversational agents' paradigm — agents message each other, the framework handles transport. Strong for research, a bit too flexible for production. OpenAI Swarm: experimental, very lightweight — only 'handoff' and 'tool' concepts, ideal for small projects. n8n + AI Agent node: a no-code visual way to build them. Anthropic SDK + custom code: full control, no framework overhead — preferred for small production systems. Verdict: start with the Anthropic SDK directly for a prototype; reach for LangGraph or CrewAI when you need multi-agent.

2026 trends already visible: (1) Agent OS: OS-level 'agent runtimes' (Claude Computer Use, OpenAI Operator, Anthropic Sonnet Computer-Use) — agents that can see the screen, click, type. (2) Verifiable agents: every agent action is cryptographically signed and auditable. (3) Agent marketplaces: 'agents for sale' for specific jobs — buy an 'expense report' agent on a sub. (4) Agent-to-agent protocols: a standard for agents to talk to each other (a cousin of MCP). (5) Regulation: the EU AI Act's 'high-risk autonomous systems' category brings agent-specific rules. By 2026, understanding agentic AI will be table stakes for anyone working in AI products — as common as 'know how to write a chatbot' is today.