Primer on Agentic AI Platforms

April 10, 2026

A strategic overview for leaders navigating the shift from chatbots to autonomous AI agents.

Executive Summary

Agentic AI represents a fundamental shift from AI that answers questions to AI that takes action. By combining large language models with tools, persistent memory, and autonomous behavior, agents can browse the web, write code, manage infrastructure, and transact on behalf of humans. This shift is already reshaping the internet itself: services are pivoting from fighting bot traffic to courting agent customers, and a new micro-economy of agent-to-agent transactions is emerging. Understanding the architecture of agentic platforms, and the trust, security, and cost dynamics they introduce, is essential for every strategic technology decision maker.

1. The Internet is Bifurcating

Something remarkable happened in early 2026. The internet split.

February: Bots were blocked everywhere

Google, Yahoo Finance, and most "free" web services were actively fighting bot traffic. CAPTCHAs intensified. Rate limits tightened. The assumption: bots are bad actors scraping content.

March: Bots are welcome

By mid-March, the same services were rushing to offer APIs, MCP endpoints, and CLI access. The realization: agents aren't just scraping; they're customers. When an agent books a flight, orders groceries, or researches a purchase, it drives real economic activity. JSON and Markdown became the primary formats for machine consumption, while MCP (Model Context Protocol) emerged as the discovery and negotiation layer letting agents find and use services programmatically.

The agent economy

📊 By the Numbers

Leading agentic services providers have completed approximately 75 million microtransactions worth $24.2 million USD in the 30 days ending April 9, 2026 - an average of $0.32 per transaction (x402.org). Agents can now apply for and use credit lines (claw.credit), enabling autonomous purchasing decisions within human-defined guardrails.

This isn't a future prediction. This is happening now.

2. From Chatbot to Agent: What Changed?

Chatbots and agents both run on Large Language Models (LLMs), the same foundational AI technology. The difference is what happens with the LLM's output.

How chatbots work

A chatbot takes your prompt, sends it to an LLM, and returns written text. Each API call is a single turn. To create the illusion of a continuous conversation, the system packs previous turns (your messages and the AI's responses) into the next request's context window. The LLM doesn't actually "remember" - it re-reads the conversation every time.

What makes an agent different

An agent adds tools to this loop. Instead of just producing text, the LLM can request actions: read a file, search the web, call an API, execute code, send a message. The agent runtime executes these tool calls and feeds the results back to the LLM, which decides what to do next.

Agent = LLM + Tools + Runtime

This creates a fundamental capability shift.

The heartbeat: reactive vs. proactive

A critical but often overlooked distinction: a truly agentic system doesn't just wait for you to talk to it. Through heartbeats (periodic wake-up cycles) an agent can check email, monitor systems, review calendars, and take action on its own. This is the line between a tool-augmented chatbot (reactive, waits for input) and a genuine agent (proactive, initiates action). If your AI only speaks when spoken to, it's still a chatbot with better tools.

3. Where You Experience Agents: Surfaces

A surface is how humans interact with an agent. The same underlying agent can appear through multiple surfaces. Getting the surface right is critical because users learn to trust or dismiss an agent quickly, much like a banner ad. In a world weary of "AI slop," losing trust is easy; earning it is an uphill battle.

Embedded Chat Agents

Every web service wants to chat with you now. Every application is expected to have a conversational interface. These brand-facing agents live on home pages and support portals.

What makes them hard:

They have the shortest interaction window of any surface. Users decide in seconds whether to engage or bail
They must be fast, focused, and almost always right
They require surprising depth of infrastructure behind a shallow interface: security (public-facing attack surface), context management (what does this agent actually know?), and responsive error handling
Every failed interaction erodes trust; every good one barely registers

IDE / Coding Agents

The "classic" agentic experience, and the most mature surface today. Tools like Kiro, VS Code with Copilot, Codex by OpenAI, and Claude Code share key characteristics:

Shared workspace: you and your agent edit the same files
Shared terminal: you can observe and control terminal sessions together
Tool-augmented chat: the conversation can read files, run commands, search code, and make edits as part of the dialogue

This surface works well because the context is naturally constrained (a codebase) and the feedback loop is tight (run the code, see if it works).

Messaging / Multi-Channel

Agents that live in the communication tools you already use: Slack, Discord, Zulip, Telegram, WhatsApp, iMessage. Rather than going to the agent, the agent comes to you, in the conversation flow you're already in.

Why this matters:

Zero adoption friction, no new app to install or learn
Natural language is the native interface
Agents can participate in group conversations alongside humans
Multiple agents can collaborate in the same channel

4. The Agentic Platform: Where Agents Live

The surfaces above are how you experience agents. The platform (or harness) is the architecture where agents actually live and work. It's not a surface; it's the infrastructure that makes surfaces possible.

Why platforms matter

Without a platform, each agent is a one-off integration: custom code connecting an LLM to specific tools for a specific surface. A platform provides the common infrastructure that makes agents portable, secure, and extensible.

The agentic platform concept was first popularized by open-source projects like OpenClaw (November 2025), and is now being built across the industry: Anthropic (project "Conway"), OpenAI (CoWork), Perplexity (Computer), and others. Implementations range from fully open-source to closed-source turn-key offerings. The architectural patterns are converging, and the key strategic question is where you want to sit on the spectrum of control vs. convenience.

Architecture of an Agentic Platform

The diagram below illustrates the key functional areas and data flows of a generalized agentic platform. The colored arrows represent multiple concurrent data flows - messages, tool calls, inference requests, and knowledge queries - all moving through the system simultaneously.

Generalized agentic platform architecture: functional areas and data flows

Any agentic platform, regardless of vendor, needs to address the same core functional areas:

Gateway / Message Router. The central routing layer. Connects communication surfaces (Slack, Discord, Zulip, Telegram, web chat, etc.) to agent runtimes. Handles authentication, rate limiting, and message routing. In multi-agent deployments, the gateway routes different conversations to different agents based on configurable rules.
Inference Layer. Connects to one or more LLM providers (Anthropic, OpenAI, AWS Bedrock, Google, local/self-hosted models). A well-designed platform abstracts this layer so agents aren't locked to a single model provider. You can swap models per agent, per task, or even per conversation. This is critical for cost optimization, capability matching, and avoiding vendor lock-in.
Agent Runtime. Where agent logic executes. Each agent runs in its own context with its own identity, memory, tools, and sandbox. The runtime manages the agent's "turn loop": receive input → call LLM → execute tool requests → return results → repeat until the task is done.
Workspaces - Isolated file environments for each agent (and optionally shared workspaces for collaboration). This is where memory, configuration, and working files live. Think of it as the agent's home directory. Workspace isolation is a security fundamental - one agent shouldn't be able to read another agent's private context unless explicitly shared.
Persistent Knowledge Layer ("Second Brain"). A curated knowledge base, systematically maintained by dedicated agent(s), that grows and evolves as the platform is used. Personal knowledge must be portable and secure; it belongs to the individual, not the platform. Shared knowledge should be accessible to authorized agents and humans while respecting clear boundaries between what's personal and what's communal.
Tools & Extensions. The platform's extensibility layer. Skills (packaged capability bundles), MCP servers (standardized tool interfaces), and plugins (platform-level extensions) enable agents to gain new capabilities without rebuilding the platform.
Observability & Control Plane. Logging, audit trails, health monitoring, and human override capabilities. This is the governance layer. Critical for trust: you need to see what your agents are doing, understand why they made specific decisions, and be able to intervene or stop them at any point.

Key platform properties

Communication: Multi-channel, multi-surface message routing
Observability: Full visibility into agent behavior, decisions, and actions
Security: Sandboxing, tool restrictions, approval workflows for sensitive actions
Extensibility: Skills, plugins, MCP integrations that can be added without core changes
Portability: Not locked to a single LLM provider, cloud, or communication platform

5. Trust, Security, and Control

The central challenge of agentic AI isn't capability; it's trust.

The control problem

An agent proposes tool calls. The runtime executes them. This distinction is architecturally critical: the LLM never has direct access to your systems. Every action goes through the platform's control layer, which can enforce:

Approval workflows: require human sign-off for sensitive operations (sending emails, making purchases, deleting data)
Tool restrictions: limit what each agent can do (read-only agents, no-internet agents, etc.)
Sandboxing: isolate agent execution in containers so a misbehaving agent can't affect the host system
Audit trails: complete logs of every action taken, every tool called, every decision made

6. The Cost Landscape

Understanding the economics of agentic AI is essential for strategic planning.

Inference costs (per million tokens)

A representative selection of models and prices as shown on Amazon Bedrock as of writing.

Model	Input	Output	Best For
NVIDIA Nemotron 3 Super	$0.15	$0.65	Cost-efficient agents
Claude Haiku 4.5	$1.00	$5.00	Fast, capable general agents
Claude Sonnet 4.5	$3.00	$15.00	Complex reasoning tasks
DeepSeek V3.2	$0.62	$1.85	Balanced cost/capability

What drives cost

Context size: longer conversations = more input tokens per turn
Tool use: each tool call adds turns (agent request → tool result → agent response)
Heartbeats: proactive agents consume tokens even when idle
Model choice: 10-50x price range between models; matching model to task is key

The cost trajectory

Model prices have dropped roughly 90% year-over-year since 2024. The economic question is shifting from "can we afford to run agents?" to "can we afford not to?"

What This Means

Agentic AI is not a feature to bolt onto existing products. It's an architectural shift that changes how software is built, how services are delivered, and how the internet itself operates.

For technology leaders:

Evaluate agentic platforms now - the architecture decisions made today determine flexibility tomorrow
Open-source platforms offer portability and avoid vendor lock-in, while closed platforms offer convenience at the cost of control. Understand where your organization needs to be on that spectrum
Security and observability are not optional; they are prerequisites for trust
Start with high-value, well-defined processes and build the internal human skills needed to get them right. You will need these skills to build and maintain valuable agents

For business leaders:

The agent economy is here, and your customers will increasingly interact through agents
Services that aren't agent-accessible will become invisible to a growing segment of the economy
The cost of AI inference is falling fast enough that "too expensive" is a temporary objection
Trust is the moat. Organizations that build reliable, trustworthy agent experiences will win

This document is a living primer. Last updated: April 10, 2026.