SWITCHED ON
The daily technology series nobody asked for but everyone needed
The Thinking Machine Next Door: Agentic AI and the End of the Chat Window
For three years, AI meant typing into a box and reading what came back. That era is ending. The new generation of AI systems can browse the web, use software, write and execute code, and complete multi-step tasks with minimal supervision. This changes what "using AI" actually means.
A chatbot answers the question you ask it. An agent decides what questions need answering to accomplish the goal you gave it, then goes and does the work — searching, clicking, typing, executing, checking its own output — largely without you watching each step. The shift from the first to the second is not an incremental product update. It is a change in what kind of thing you are actually interacting with.
Season Two closed with grid batteries and a long look back at thirty episodes of scarcity, storage, and the gap between the visible and hidden halves of hard problems. Season Three opens somewhere that has been quietly transforming underneath every AI-related episode across both previous seasons: the shift from AI as a conversational tool you actively operate to AI as an agent that operates tools on your behalf. Agentic AI. Autonomous task completion. Computer use. Whatever term ends up sticking, the underlying shift is significant enough to deserve its own dedicated treatment, and Season Three is going to open with it.
01 — What Actually Changed
The large language models that defined the 2022-to-2024 AI boom — the ChatGPT era, broadly speaking — were fundamentally conversational: you provided a text prompt, the model generated a text response, and any action beyond generating text required a human to read that response and manually execute whatever it recommended. This is a genuinely useful capability, and it remains the primary way most people interact with AI. But it places a hard ceiling on what the AI can accomplish, because every step that touches the world outside the chat window requires human mediation.
Agentic AI systems remove that mediation for a defined and expanding set of tasks. Rather than telling you how to book a flight, an agentic system can navigate to a booking website, fill in the search fields, compare options, and complete the booking, checking in with you only at decision points that genuinely require your judgment or payment authorisation. Rather than writing code for you to copy and run, a coding agent can write the code, execute it, read the error messages, fix the bugs, and iterate until the code actually works — the same debugging loop a human developer performs, executed by the model itself. This is the qualitative shift: from a system that produces recommendations to a system that produces outcomes.
The technical capability underlying this shift is not a single breakthrough. It is the convergence of several improvements — better reasoning over multi-step plans, more reliable tool use, longer effective context windows, and crucially, models that have become good enough at self-correction that they can recover from their own mistakes mid-task rather than requiring a human to catch every error immediately.
02 — Computer Use and the Browser as Battleground
The most consequential specific capability driving the agentic shift is what the industry calls "computer use" — AI models that can view a screen, interpret what they see, and control a mouse and keyboard to interact with software the same way a human would, rather than requiring purpose-built integrations with each individual application. Anthropic's Claude, OpenAI's Operator, and Google's Project Mariner all represent variations on this capability, each taking a somewhat different approach to the underlying problem of letting an AI model operate general-purpose software autonomously.
This matters enormously because it means an AI agent does not need a custom-built integration with every website and application it might need to use — it can, in principle, use the same web browser and desktop applications a human uses, navigating unfamiliar interfaces by interpreting what it sees on screen rather than relying on a pre-built API connection. The practical reliability of this approach as of 2026 is genuinely impressive for well-structured, common tasks — filling out forms, navigating standard e-commerce checkouts, extracting data from web pages — and meaningfully less reliable for tasks involving ambiguous instructions, unusual interface designs, or multi-step reasoning where an early misstep compounds through subsequent steps.
03 — Coding Agents and the Changing Shape of Software Development
Autonomous coding agents represent the most mature and most widely adopted category of agentic AI, because software development is a domain where the AI's output (code) can be automatically tested against objective criteria (does it run, does it pass the tests), giving the agent a clear signal for self-correction that many other domains lack. Tools including Claude Code, GitHub Copilot's agentic modes, and Cursor's agent capabilities have moved beyond autocomplete-style code suggestion into genuinely autonomous task completion: given a description of a bug or feature, these systems can explore a codebase, identify relevant files, write the necessary code changes across multiple files, run the test suite, interpret failures, and iterate until the tests pass.
Software engineering organisations that have adopted agentic coding tools at scale report significant productivity gains on well-defined, well-specified tasks — bug fixes, test writing, boilerplate generation, and refactoring — with more mixed results on tasks requiring deep architectural judgment or ambiguous requirements, where human oversight and iterative clarification remain essential. This mirrors the pattern we identified in Season Two's future-of-work discussion in Season One: the tasks most amenable to AI automation are the well-specified, well-bounded ones, while the tasks requiring genuine judgment under ambiguity remain more resistant, at least for now.
04 — The Trust and Verification Problem
The central challenge that agentic AI introduces, distinct from the challenges posed by conversational AI, is verification: when a chatbot gives you a wrong answer, you read it and can (in principle) catch the error before acting on it. When an agent takes twenty autonomous actions to complete a task, you have twenty opportunities for something to go wrong, potentially compounding, and you may not review each individual action before it is taken. This creates a genuinely new category of risk that did not exist in the same form with purely conversational systems.
The industry response has centred on a few key mechanisms. Permission scoping — requiring explicit user approval before an agent takes consequential or irreversible actions, like making a purchase, sending an email, or deleting a file, while allowing lower-stakes actions like reading and searching to proceed autonomously — has become the standard design pattern across most agentic products. Sandboxing — running agentic actions in contained environments where mistakes cannot cause damage beyond the sandbox, particularly for coding agents operating on copies of code rather than production systems directly — provides a technical safety net. And audit logging — maintaining a complete, reviewable record of every action an agent took, so that when something does go wrong, the specific point of failure can be identified and understood — has become standard practice for any serious agentic deployment, though it shifts the verification burden to after the fact rather than preventing errors in real time.
The genuinely hard unsolved problem is not preventing agents from making mistakes — mistakes are inevitable in any sufficiently complex autonomous system, human or artificial. It is calibrating how much autonomy to grant for a given task, given the cost of a mistake versus the cost of requiring constant human checkpoints that erode the efficiency gains the automation was supposed to provide in the first place.
05 — What This Means for How People Actually Work
The practical implication of the agentic shift, for anyone using these tools rather than building them, is a change in the nature of the skill required to get value from AI. The conversational AI era rewarded prompt engineering — crafting the right question to get the right answer. The agentic era increasingly rewards task specification and oversight design — defining a goal clearly enough that an autonomous system can pursue it correctly, setting appropriate checkpoints and permission boundaries, and developing the judgment to know which tasks are appropriate to delegate fully versus which require close supervision or should not be delegated at all.
This is a genuinely different skill from prompt writing, closer to the skill of delegating effectively to a competent but literal-minded junior colleague than to the skill of searching effectively or asking a good question. Organisations and individuals who are developing this skill are reporting the productivity gains that agentic AI's advocates have promised. Those treating agentic tools as simply a faster chatbot, without adjusting their working patterns to account for the different nature of delegation versus conversation, are reporting more mixed results — a pattern that echoes almost every previous general-purpose technology this series has covered, from the personal computer to the smartphone: the tool's value is realised only when the way people work adapts to what the tool actually is, rather than treating it as a faster version of what came before.
Tomorrow we are staying with AI but shifting focus entirely — to the physical world, and specifically to humanoid robotics. Figure, Tesla's Optimus, and the increasingly serious race to build general-purpose robots that can work in spaces designed for humans. See you then.
Switched On is a daily technology series covering the ideas, systems, and arguments shaping the digital world. Opinionated. Witty. Occasionally wrong. Always worth the argument.
