Imagine you need a new washing machine.
Today the process is familiar. You search. You open several retailers. You set filters. You compare specifications and reviews. You check dimensions, energy ratings and delivery dates. You find out whether someone will remove the old machine. Eventually, after moving backwards and forwards between pages and services, you decide what to buy.
None of this is particularly difficult.
It is simply how the internet works: we operate it.
Now imagine saying:
Find me a reliable washing machine under £600 that fits this space, has good energy efficiency, can be delivered this week and includes removal of the old one. Show me the best three before buying anything.
The outcome may be similar. The relationship with the internet is not.
That small behavioural change — from navigating a process to describing an intention — could become one of the more significant shifts in computing since the move from desktop software to the web, and later from the web to mobile apps.
For most of the internet’s history, software has been built around a simple assumption:
a person will operate the interface.
AI agents introduce another possibility.
The person describes what they want. The software works out which services are needed and how to use them.
Some of the examples that follow are still illustrations of where this could lead. Many of the individual capabilities already exist; what is less common is having them joined together into one reliable, continuous experience.
The internet we know was designed for our fingers
Open almost any digital service and its basic structure is familiar.
A retailer gives us search, filters, product pages, a basket and checkout. An airline gives us destinations, dates, seat selection and payment. A bank gives us balances, transactions and transfers.
Businesses spend enormous amounts of time designing these interfaces because, historically, the interface has been where the customer meets the service.
But underneath the screens are the actual capabilities.
A retailer can search its catalogue, check stock, calculate delivery and create an order. An airline can query schedules, reserve a seat and alter a booking. A restaurant system can check availability and reserve a table.
A person usually reaches those capabilities by navigating the interface.
An AI agent does not necessarily need to.
It does not need to find the beautifully positioned Check availability button if the same underlying capability can be requested safely and directly.
A conventional website effectively tells a person:
Here are the screens you can operate.
An increasingly agentic service can also tell software:
Here are the things I can do.
That sounds like a technical change. Its effect is broader.
It changes who has to understand the interface.
The user stops learning every system
At the moment, we become temporary experts in dozens of systems.
We learn where an airline hides baggage options. We work out which filters a retailer has chosen to expose. We remember which menu contains a bank transfer. We type the same preferences into different booking forms.
None of these jobs is individually difficult. Together they make up a surprising amount of digital life.
Agentic software can reverse some of that burden.
Instead of learning how every service expects us to express a request, we describe the request in our own terms and let the software translate it into the actions each service requires.
That does not mean screens disappear.
People enjoy browsing. We want to see photographs of a hotel, look at clothes, compare cars and explore possibilities. Sometimes using the interface is part of the experience.
But the screen may stop being the only useful entrance to a service.
Search begins to turn into action
Go back to the washing machine.
The useful result is not necessarily a longer page of search results. An agent can potentially check dimensions, price, stock, delivery, energy efficiency and removal of the old machine, discard the options that do not fit and return the few that do.
Then you might say:
The second one looks good. Check the retailer and reviews, then show me the final price before ordering.
At that point, finding something on the internet and using the internet to get something done start to merge.
There is an important difference between matching keywords and making a useful choice.
Suppose instead you need a coat:
I need a lightweight waterproof coat for walking the dog. It needs to be breathable because I don’t want to get sweaty in it, with a proper hood, no heavy insulation, and under £100. I don’t care about the brand.
That request does not fit especially neatly into a traditional set of filters.
A suitable coat might normally cost £130 but currently be reduced to £89. A useful agent could notice the sale, check that the retailer is established, look for a credible body of reviews rather than a handful of suspicious ratings, check the returns policy, and confirm that the claimed waterproofing and breathability are actually supported by the specification.
The result might be:
This one fits what you asked for. It is currently £89 in a sale, the retailer is well established, returns are straightforward and the product has enough independent reviews to make the rating meaningful. There are two similar alternatives if you want to compare them.
The interesting part is not that AI found a coat.
It is that some of the work of deciding whether the result deserves trust has moved as well.
What happens when the agent does not stop at checkout?
Back to the washing machine.
The agent has found one for £549, checked that it fits, confirmed the delivery and removal service, and asked for permission to buy it.
You say yes.
Most online transactions would end there with a confirmation screen.
After that, responsibility returns to us.
We notice the delivery email. We realise the time has changed. We check the diary. We contact the retailer. We rearrange it.
An agent could remain attached to the purpose of the task.
If the delivery company changes the window, it might notice that the new time conflicts with your calendar:
The delivery has moved to between 10am and 2pm. It looks as though nobody will be home until 11.30. I can ask for an afternoon slot, or use the neighbour you have already authorised for deliveries. Which would you prefer?
The agent is no longer simply answering a question or completing a checkout.
It is keeping track of what the task was meant to achieve.
This is not entirely hypothetical. ChatGPT Work’s cloud browser, for example, can continue a delegated web task after the user leaves the conversation and pause when it needs information, sign-in or confirmation.
What is still less common is carrying responsibility for an ordinary real-world outcome across several services and over a longer period.
Instead of:
Open this. Check that. Now do this.
we begin to say:
Keep an eye on this delivery and tell me if something changes.
Or:
Look for a better electricity tariff, but don’t switch supplier without asking me.
The user specifies the intention, the boundaries and the point at which control should come back to them.
The software handles the smaller steps in between.
Permissions therefore become part of the interface.
Voice makes the change easier to see
Take away the keyboard and it becomes more obvious.
Imagine driving and saying:
Reply to Sarah and say I’ll look at the proposal tonight. Find somewhere suitable near tomorrow’s meeting if I still need a hotel. And keep an eye on my delayed parcel — tell me if the delivery date changes again.
Then you carry on driving.
Those are different kinds of work. One may finish immediately. Another may require an external service. One may stay active for the rest of the day.
You are not navigating three applications.
You are establishing jobs.
The applications underneath still matter, but you no longer have to operate each one yourself.
The assistant starts to become a layer between the person and their digital environment.
A restaurant is a good test
Now consider something less planned.
You bump into an old friend and decide to get something to eat.
Today that can mean opening maps, looking at restaurants, checking menus, reading reviews, working out the walking distance, finding availability, making a reservation and then navigating there.
Instead, you might say:
Find somewhere I would actually like within a twenty-minute walk. We want to eat as soon as possible. Check whether there’s a table for two, book it if there is, and then take us there.
There is a surprising amount packed into that request.
The system needs your current location and the current time. It needs to know how far you are willing to walk. It needs restaurant information and live availability. It may need dietary preferences. It needs a booking mechanism and then directions.
But the interesting phrase is:
somewhere I would actually like.
You have not supplied cuisine, price band, atmosphere, noise level and a dozen other filters.
The request assumes that the system already knows something useful about you.
Not everything.
Just enough relevant context to make a better choice.
Many of the individual pieces already exist: location, maps, availability, reservations, personal preferences and conversational interfaces.
The interesting gap is increasingly not whether the pieces exist.
It is whether they can be joined into one experience without requiring the person to manage every connection.
The agent may eventually speak first
The larger change comes when we no longer initiate every interaction.
Suppose your train is cancelled.
A persistent agent might notice and say:
Your train has been cancelled. There is another service twenty minutes earlier and you can still reach it. I haven’t changed anything. Would you like me to move you onto it?
The same principle could apply when a delivery moves to a day when nobody will be home, or a flight change causes another part of a journey to stop working.
The software notices because it has been entrusted with an ongoing concern.
Instead of waiting for us to open an app and discover the problem, it can bring us in when a decision is actually needed.
But a surprising amount of digital administration exists because software currently waits for us to notice something, find the right service and deal with it.
Some of that can plausibly disappear.
The website develops a second audience
If people begin delegating more of this work, businesses have to think differently about their own software.
A shop will still need to work well for humans. Photography, editorial content, product information and a good checkout remain useful.
But behind that interface there may increasingly be another surface: one that makes the service’s actual capabilities understandable to authorised software.
Search the catalogue. Check stock. Calculate delivery. Reserve something. Create an order. Amend a booking.
A person sees the shop.
An agent also needs to understand what the shop can do.
The existing app, database and booking infrastructure do not disappear. In many cases they become more important. What changes is that the customer may no longer operate every interface personally.
That is a useful way of thinking about an agentic website.
It is not primarily a new visual design trend.
It is a service that software acting for a customer can meaningfully and safely use.
For years web designers have asked:
Does this work properly on a smaller screen?
A new question is appearing alongside it:
Can an authorised AI understand and use this service without pretending to be a human clicking through the interface?
APIs, MCP and agents are less mysterious than they sound
The terminology around this can make the change sound more exotic than it is.
An API — an Application Programming Interface — is a structured way for one piece of software to request information or an action from another. APIs have been part of the internet’s plumbing for decades.
MCP — Model Context Protocol — serves a related purpose for AI systems. It provides a more consistent way for applications to expose tools and information that a model can understand how to use.
The MCP layer does not need to contain the intelligence. It can simply provide a clear doorway into an existing system.
The agent is the part deciding which capability it needs and when.
For the coat request, that might mean searching once the constraints are known, removing unsuitable products, checking the seller and stopping before money is spent because purchase requires approval.
The software underneath each step may be completely ordinary.
What has changed is who chooses the sequence.
Delegation creates a more serious security problem
All of this becomes more consequential once the agent can act.
Reading a restaurant menu is one thing.
Sending an email, cancelling a flight, exposing personal information or spending money is another.
“Be careful” is not a security model.
The systems underneath have to enforce the boundaries.
Two old ideas become even more important:
Authentication: who is making the request?
Authorisation: what are they allowed to do?
An agent might be allowed to compare washing machines but not buy one.
It might be able to make a restaurant reservation but not accept a large non-refundable deposit.
It might be allowed to reorder the same £18 household item you buy every month, while anything unusual requires approval.
The usefulness of an agent comes partly from not asking permission for every trivial step.
If every action produces another dialogue box, we have simply rebuilt the old interface with more words.
The aim is controlled delegation: enough authority to be genuinely useful, with clear boundaries around the decisions that still need us.
More autonomy makes those boundaries more important, not less.
What businesses should prepare for
None of this means adding “AI” to every website.
It does not mean rebuilding everything around whichever protocol happens to be fashionable this year.
The useful questions are more ordinary.
Can another system reliably understand what you offer?
Are your products, services, prices and availability represented clearly enough to use?
Can important actions be requested programmatically where that would actually help?
Are permissions explicit?
Can a customer authorise an agent to do something useful without handing over unrestricted control?
Can the result be checked afterwards?
These are product questions as much as technical ones.
The early web required a business to be online.
The search era made discoverability increasingly important.
Mobile required services to work well on the device in somebody’s hand.
An agentic internet adds another requirement: some services may also need to become understandable and operable by software acting for their customers.
And that changes what it means for a customer to arrive.
They may never visit the homepage.
Their agent may discover the service, compare it with alternatives, check that it satisfies their constraints, establish whether the company and offer appear trustworthy, complete an authorised transaction and keep track of what happens next.
That is a different relationship between a business and the internet.
From somewhere we visit to something that works around us
The early web was largely about navigating information.
Search engines made that information easier to find.
Mobile reorganised much of the experience around applications.
Generative AI made asking directly much more useful.
Agents add another possibility: delegation.
Sometimes we will still want to browse the shop, choose the restaurant ourselves, plan the holiday or simply enjoy using a good piece of software.
But increasingly we may have another option.
Do it ourselves.
Or describe what matters, set the limits, and let software deal with the parts we do not particularly want to operate.
The websites, applications, APIs and databases remain underneath.
What changes is our relationship with them.
We spend less time telling computers which buttons to press and more time deciding what we actually want, what matters enough to check ourselves, and what we are comfortable delegating.
The next phase of the internet may therefore be defined less by a new kind of screen than by a shift in agency itself.
The internet stops being only somewhere we go to get things done, and starts becoming an environment in which trusted software can keep getting things done for us.