Redistributed

For most of its history, AI has been reactive. You type a prompt, you get a response. You click a button, the model classifies an image. The human acts; the machine answers.

That model is breaking down. A new generation of AI systems — called agents — don't wait for instructions on each step. They plan. They use tools. They browse the web, write and execute code, send emails, fill out forms, and interact with other software systems on your behalf. Sometimes they do this well. Sometimes they book the wrong hotel room, hallucinate a customer service policy, or execute code that breaks a production server. Understanding what agents actually are — and what they are not — is essential context for the broader questions explored across this publication, from The Shape of AI Displacement to AI and Democracy.

The shift from AI-as-tool to AI-as-agent is not merely a technical upgrade. It's a redistribution of autonomy — from humans who perform tasks to systems that perform them, and critically, to the companies that control how those systems behave. Understanding the mechanism matters, because the design choices being made right now will determine who benefits from autonomous AI and who bears the cost when it goes wrong.

What Agents Actually Are

An AI agent is a language model connected to tools and wrapped in a loop.

The language model provides the reasoning — deciding what to do next based on a goal and the current state of the world. The tools provide the capabilities — web browsing, code execution, file manipulation, API calls, database queries. The loop provides persistence — instead of responding once and stopping, the system executes a step, observes the result, and decides what to do next.

The technical mechanism, called function calling or tool use, works like this: the model receives a prompt along with descriptions of available tools (their names, parameters, and purposes). Rather than generating text, it generates a structured request to invoke a specific tool. The system executes that tool, returns the result to the model, and the model decides what to do next. Repeat until the task is done or the system hits a limit.

Add a planning step at the front — where the model breaks a goal into sub-tasks — and a memory system that persists information across steps, and you have the basic architecture of every agent system shipping today. (For the foundation underneath, see How Language Models Actually Work and How Reasoning Models Actually Work.)

This is less exotic than it sounds. It's a language model playing the role of a dispatcher in a call centre: receiving a request, deciding which department to route it to, reading the response, and deciding whether the issue is resolved or needs another step. The difference is that the "departments" are software tools, and the dispatcher works at machine speed.

The Current Landscape

The agent paradigm has moved from research demos to commercial products in roughly eighteen months. The major players:

OpenAI launched Operator in January 2025 — a system that can navigate websites, fill out forms, and complete multi-step tasks in a browser. Their GPT-4 and successor models support tool use natively, and the Assistants API provides the scaffolding for developers to build custom agents with persistent memory and file handling.

Anthropic ships Claude with computer use capability — the model can see a screen, move a cursor, type, and interact with desktop applications. Claude Code, their developer tool, writes, tests, and deploys code semi-autonomously, navigating codebases, running test suites, and fixing errors in a loop.

Google developed Project Mariner for web-based agent tasks and has integrated agentic capabilities into Gemini. Their agents can navigate Chrome, interact with web applications, and perform research across multiple sites.

Microsoft embedded Copilot agents throughout the Office suite — AI that can draft documents, analyse spreadsheets, create presentations, and manage email workflows. In enterprise, these agents coordinate across applications, pulling data from one system to take action in another.

Enterprise vendors followed quickly. Salesforce launched Agentforce, deploying autonomous agents for customer service, sales workflows, and case management. ServiceNow built AI agents into IT service management. These aren't experimental — they're handling real customer interactions and operational decisions at scale.

Open-source projects — AutoGPT, CrewAI, LangChain agents, and others — provide frameworks for anyone to build agent systems. They're rougher around the edges but demonstrate that the architecture is not proprietary. Anyone with API access to a capable model can build an agent. This openness matters — it means agent capability is not locked behind a single vendor, even if the underlying models often are (see Open Weights Are Not Open Source for why this distinction matters).

What Agents Can and Cannot Do

The gap between agent demos and agent reliability is the most important thing to understand about this technology right now.

What works reasonably well: Booking travel with clear parameters. Filling out forms with known information. Writing, testing, and deploying code in well-defined contexts. Summarising research across multiple sources. Managing routine email responses. Handling tier-one customer service queries with scripted resolution paths. Data entry, format conversion, and document processing.

What fails frequently: Tasks requiring more than 10-15 sequential steps — error rates compound at each stage. Anything involving ambiguous judgment calls ("Should I escalate this customer complaint?"). Tasks with irreversible consequences where a mistake can't be undone. Situations requiring genuine understanding of social context, organisational politics, or unstated norms. Novel problems that don't resemble training data.

As Arvind Narayanan and Sayash Kapoor argue in AI Snake Oil, the gap between "works in a demo" and "works reliably in deployment" is precisely where AI hype lives. Agent systems are particularly susceptible because they compound errors: a small mistake in step three propagates through steps four through twelve, and the system often lacks the judgment to recognise it has gone off track.

This is not a temporary problem that will vanish with the next model. It's structural. Autonomous multi-step execution in open-ended environments is genuinely hard, and language models — however capable — are still pattern-matching systems operating without causal understanding of the world they're acting in. That said, the rate of improvement is real. The gap between agent demos and agent reliability is narrowing, even if it remains wide. Reasoning models that think before they act are one path toward more reliable multi-step execution. The question is whether reliability improves fast enough to justify the autonomy being granted.

The Autonomy Spectrum

Not all agent deployments are the same. They fall along a spectrum that matters for understanding both capability and risk:

Level 1 — AI suggests, human approves. The agent drafts an email, proposes a purchase, or generates a plan. A human reviews and clicks "send" or "confirm." The human retains full control. Most consumer-facing agent products operate here today.

Level 2 — AI acts, human reviews. The agent executes tasks autonomously but logs everything for human review. A customer service agent resolves tickets on its own; a supervisor audits a sample. This is where many enterprise deployments sit — Salesforce's Agentforce, for instance, handles customer cases autonomously with escalation rules and audit trails.

Level 3 — AI acts independently. The agent operates without routine human oversight. It makes purchasing decisions, manages workflows, interacts with external systems, and handles exceptions on its own. Very few systems operate here today, and for good reason.

The direction of travel is clear: from Level 1 toward Level 3. Every AI company's roadmap points toward greater autonomy. The economic incentive is obvious — a Level 1 agent that requires human approval on every action saves less labour than a Level 3 agent that runs unsupervised. But each step up the autonomy spectrum transfers more decision-making power from humans to systems, and from the humans who used to make those decisions to the companies that design the agents.

The Control Problem, Made Concrete

As agents become more autonomous, a set of practical questions become urgent. Not the existential "AI alignment" questions about superintelligence — the mundane, immediate ones.

Liability. An agent books a non-refundable flight to the wrong city. Who pays? The user who delegated the task? The company whose agent made the mistake? The airline that processed the booking? Current consumer protection law was not built for transactions initiated by autonomous software acting on behalf of a human.

Authorisation. An agent with access to your email sends a reply you wouldn't have sent. An agent with access to your company's CRM changes a customer's pricing tier. The agent was authorised to "manage email" or "handle customer accounts" — but the specific action wasn't what anyone intended. Broad permissions combined with autonomous execution create a gap between what was authorised in principle and what happens in practice.

Transparency. When you call customer service and an agent handles your case, should you know it's not human? When an agent negotiates a price on your behalf, should the seller know they're dealing with a machine? Current disclosure requirements vary by jurisdiction and are largely unenforced for AI systems.

These aren't hypothetical edge cases. They're the predictable consequences of deploying autonomous systems in environments built for human decision-making. Langdon Winner's foundational question — do artifacts have politics? — applies directly. The design choices about what agents can do without asking, what they can spend without approval, and what they can say without review are political decisions embedded in technical architecture. A system designed to "minimise user friction" by acting without confirmation is making a political choice about the relative value of speed and control.

The Redistribution Angle

Agentic AI threatens to redistribute work, value, and power in ways that go beyond the familiar automation debate.

A new category of displacement. Previous waves of AI automation targeted specific cognitive tasks — document classification, image recognition, translation. Agents target workflows — the entire sequence of steps that constitutes someone's job. Administrative assistants who manage calendars, book travel, process expenses, and coordinate meetings. Customer service representatives who answer queries, look up accounts, process returns, and escalate issues. Data entry workers who move information between systems. Travel agents who research options and make bookings.

These are not hypothetical. They are the explicit use cases in every agent platform's marketing materials. Salesforce's Agentforce promotional material describes agents that "resolve cases autonomously." Microsoft's Copilot documentation shows agents that "handle end-to-end business processes." The augmentation narrative — that AI will enhance human workers rather than replace them — faces its hardest test with agents, because agents are designed to perform complete tasks, not assist with sub-steps.

Daron Acemoglu's distinction between beneficial automation and "so-so automation" is instructive here (explored in depth in The Productivity Paradox). Beneficial automation creates new tasks and roles for human workers alongside the technology. So-so automation merely replaces workers without meaningful productivity gains — the same work gets done, the labour cost disappears, and the value flows to the deploying company. Many agent deployments look like so-so automation: a chatbot replacing a customer service representative doesn't create new tasks for that representative. It eliminates the role. But this is not inevitable — well-designed agent systems can genuinely augment workers, handling routine cases so that humans focus on complex ones. The design choice matters, and so does whether workers have a voice in making it (see Collective Bargaining in the Age of AI).

New intermediaries capture value. The agent economy creates a new layer of rent extraction. Agent platforms charge for orchestration. Tool providers charge for integrations. API providers charge per call. Memory and vector database services charge for persistence. A company deploying agents doesn't just pay for the AI model — it pays for an entire stack of intermediaries that didn't exist two years ago.

This mirrors what Nick Srnicek described in Platform Capitalism: digital platforms insert themselves as essential intermediaries, extracting value from both sides of a transaction. Agent platforms are poised to do the same — sitting between businesses and the AI capabilities they need, taking a cut of every workflow they automate.

Autonomous purchasing concentrates power. When agents make purchasing decisions — booking travel, ordering supplies, selecting vendors — the platforms that control agent behaviour become extraordinarily powerful intermediaries. An agent that consistently recommends one airline over another, or one supplier over another, shapes markets. If those recommendations are influenced by commercial relationships between the agent platform and the vendor, the consumer has no visibility into the conflict of interest.

This isn't speculative. Google's search advertising model already demonstrates how intermediation of decision-making creates enormous commercial power. Agents that execute decisions, not just inform them, amplify this dynamic.

The Governance Gap — And What's Emerging

No comprehensive regulatory framework yet exists for autonomous AI agents. The EU AI Act, the most comprehensive AI regulation enacted to date, categorises AI systems by risk level but does not specifically address the unique challenges of autonomous agents that take actions in the world. It was designed primarily for AI systems that inform human decisions, not systems that make and execute decisions independently.

The gap is significant. Questions that need answers include: What duty of care does an agent deployer owe to people affected by the agent's actions? What disclosure is required when an agent interacts with a human? What liability framework applies when an agent causes financial harm? What audit requirements should apply to agents that make consequential decisions?

Some promising developments are worth noting. The EU AI Act's high-risk category does capture many agent use cases by implication. Several US states are developing agent-specific disclosure requirements. Industry standards for agent audit trails are emerging from enterprise deployments — Salesforce's Agentforce, for instance, logs every autonomous decision for review. And the concept of "graduated autonomy" — where agents earn expanded permissions through demonstrated reliability — provides a practical framework that some deployers are already adopting.

Until these approaches mature into formal regulation, the terms of agent deployment are largely set by the companies building them — in terms of service that users accept without reading, granting broad permissions that enable broad action. But the governance conversation is active, not absent.

What This Means for You

If you're interacting with agent systems — as a user, a worker, or someone on the receiving end of an agent's decisions — a few things are worth knowing.

Check the autonomy level. Before granting an agent broad permissions, understand what it can do without asking. "Manage my email" might mean "draft replies for my approval" or it might mean "send replies on my behalf." The difference matters.

Understand the business model. When an agent recommends a product, books a service, or selects a vendor, ask whether the recommendation is shaped by commercial relationships between the agent platform and the provider. If you can't find the answer, assume it is.

Watch the labour angle. If your employer is deploying agents to "augment" your workflow, pay attention to whether the agent is handling sub-tasks (genuine augmentation) or entire workflows (replacement by stages). The framing matters less than the trajectory.

Demand transparency. When you interact with an agent — as a customer, a citizen, a patient — you have a legitimate interest in knowing it's not a human, what data it has access to, and who is responsible for its decisions. The fact that this information is rarely disclosed is a policy failure, not a technical limitation.

The autonomy question is not really about what agents can do. It's about who decides what they should do — and who bears the consequences when they get it wrong. Right now, those decisions are being made in product roadmaps and terms of service, not in public deliberation. That's a redistribution of power worth paying attention to.

Sources

Narayanan, Arvind, and Sayash Kapoor. AI Snake Oil: What Artificial Intelligence Can Do, What It Can't, and How to Tell the Difference. Princeton University Press, 2024. Princeton
Acemoglu, Daron. "Harms of AI." Cambridge Journal of Economics, 2021. Cambridge
Srnicek, Nick. Platform Capitalism. Polity Press, 2017. Polity
Winner, Langdon. "Do Artifacts Have Politics?" Daedalus 109, no. 1 (1980): 121–136. JSTOR
Franklin, Ursula. The Real World of Technology. House of Anansi Press, 1989. Publisher
European Parliament and Council of the European Union. "Regulation (EU) 2024/1689 (AI Act)." Official Journal of the European Union, 2024. EUR-Lex

General

Agentic AI and the Autonomy Question