Skip to content

Excuse Me, Human. May I Have Your Permission?

We are getting pretty good at connecting AI to all kinds of APIs. But what happens when an AI agent needs something from a human? Apparently, we are now developing protocols for that, too. During WordCamp Netherlands 2026 (https://netherlands.wordcamp.org/2026/), someone asked a question that has stayed with me: “We can connect AI to all kinds...

@
Nov 20, 202611 min read
1

e are getting pretty good at connecting AI to all kinds of APIs. But what happens when an AI agent needs something from a human? Apparently, we are now developing protocols for that, too.

During WordCamp Netherlands 2026 (https://netherlands.wordcamp.org/2026/), someone asked a question that has stayed with me: “We can connect AI to all kinds of APIs. When we want to connect to people, what APIs do we have available?”

It somehow feels like a simple question, but it opens up several interesting directions. One is to look at all the interfaces we humans have developed to connect with each other, from eye contact and greetings to letters, telephones, email and social networks.

But the question also made me think about something else. We are rapidly developing an infrastructure that allows AI agents to communicate with software, databases, websites and other agents. These systems are becoming increasingly capable of working independently. Yet sooner or later, an agent may encounter a situation in which it needs a decision from a human being. Not another API call. Not access to a database. Just a simple answer from a person. How does it ask?

The agent that needs to ask a question

Imagine asking a personal AI agent to organize a weekend trip. It searches for accommodation, compares train connections, checks opening hours and creates a suggested itinerary. All of this can happen through existing APIs and online services. Then it finds a hotel room that costs €145 per night. What should it do? Perhaps you previously told the agent that it can book accommodation costing less than €100 per night without asking. But this particular room exceeds that limit. The agent now needs to contact you, explain the situation and request permission to continue.

That sounds straightforward. But there are quite a few technical questions hiding behind this simple interaction. How does the agent know where to reach you? Should it send a message through Signal, email, SMS or its own application? How can it be certain that the person responding really is you? What happens if you don’t answer? And how does the booking system know that your approval applies to this particular hotel room, at this particular price, rather than to any future reservation?

These are the kinds of problems that a relatively new category of protocols is trying to address.

A2H: Agent-to-Human communication

In February 2026, Twilio introduced an open-source protocol called Agent-to-Human, or A2H. Twilio’s announcement is available here: https://www.twilio.com/en-us/blog/products/introducing-a2h-agent-to-human-communication-protocol. The source code and specification can be found on GitHub: https://github.com/twilio-labs/Agent2Human.

The idea is to give AI agents a standardized way to involve humans when necessary, without requiring every application developer to build a completely different system for doing so. A2H describes five basic types of interactions. An agent can inform someone that something has happened, collect information it needs to continue, request authorization for a particular action, escalate a problem that requires human attention, or report the result of an operation.

These might sound like ordinary software features, but the important difference is that they are described in a common protocol. An agent doesn’t necessarily need to know whether you prefer receiving a notification on your phone or opening a web page. It can send a structured request describing what it needs, and a communication gateway can handle the interaction. The protocol is designed to support different communication channels, which makes it more interesting than yet another confirmation button inside an AI application.

It also introduces the idea that an approval should be identifiable and auditable. In other words, the system should be able to establish what was approved, when it happened and how the authorization was obtained. The published A2H project includes a proof of concept using WebAuthn and passkeys, along with examples involving agent integration and SMS communication.

This is still an emerging protocol. Publishing an open specification doesn’t automatically mean that the rest of the industry will adopt it. But it is a concrete example of developers treating communication between agents and humans as a problem that deserves its own infrastructure.

An experimental attempt to standardize human involvement

Twilio isn’t the only organization exploring this territory. I also came across a much smaller initiative called the Human Interaction Protocol. Its documentation is available on GitHub: https://github.com/gitcommitshow/agenthumaninteraction. The project proposes a structured way for AI agents to describe what they need from humans, including clarification, approval, advice and decisions.

What makes the proposal interesting is that it tries to distinguish between different kinds of human involvement. Sometimes an agent simply needs information. Perhaps it is preparing a document and wants to know which language to use. Sometimes it needs a decision. There may be several acceptable options, and the person has to choose one. In other situations, the agent needs explicit approval before doing something that could have significant consequences.

And then there are situations in which several people must be involved. Imagine an AI agent working in a small organization. It has prepared a purchase order, but company rules require approval from both a project manager and someone responsible for the budget. The agent now needs more than a yes-or-no answer. It needs to know who should be contacted, which decisions are required, whether approvals must be obtained in a particular order and what should happen if the people involved disagree.

The Human Interaction Protocol proposes ways to describe these requirements. Its documentation considers responsibilities, visibility, conflicting responses and requests that become outdated while waiting for human input. If an AI agent asks permission to purchase a train ticket for €42, but the price increases to €87 while it is waiting for an answer, is the original approval request still valid? A human might reasonably say no. The situation has changed. A proper interaction protocol needs to account for that possibility.

There is, however, an important distinction between this initiative and a project such as Twilio’s A2H. The Human Interaction Protocol describes itself as an evolving draft. Its GitHub repository is small, and there is no clear evidence of broad industry adoption. It should therefore be regarded as an early experimental proposal rather than an established standard. I mention it because its design questions are interesting, not because it has already become part of mainstream AI infrastructure.

MCP has started asking humans questions, too

There is another development worth mentioning because it comes from the Model Context Protocol, better known as MCP. MCP is primarily intended to connect AI applications with external tools and information sources. But it also includes a feature called elicitation. The specification can be found here: https://modelcontextprotocol.io/specification/2026-07-28/client/elicitation.

Elicitation allows an MCP server to request additional information from a user through the application they are using. For example, an AI assistant might be creating a calendar appointment. The connected calendar service discovers that the meeting location is missing. Instead of failing or requiring the AI developer to create a custom interface, the service can request that information through a standardized mechanism. The application can then present the user with a question or form.

The specification also supports directing users to an external website when an interaction involves sensitive information or requires a separate authentication process. This means that credentials and other sensitive details do not necessarily have to pass through the AI application itself. Another interesting detail is that MCP distinguishes between accepting a request, explicitly declining it and cancelling the interaction without making a decision.

MCP’s elicitation feature isn’t exactly the same thing as A2H. It is primarily about obtaining information during interactions with MCP tools, rather than providing a general communication gateway to reach people across different channels. But the underlying idea is similar: a machine should have a standardized way to request human involvement instead of inventing a new user interface every time.

And once you start looking, you discover that several developers are approaching this problem from slightly different directions.

The difference between asking and receiving permission

There is a subtle issue here that deserves more attention. An AI agent displaying a question is not necessarily the same as an AI agent obtaining meaningful permission. Suppose an agent wants to delete several hundred files from your computer. A message appears: “May I delete these files?” You click Approve. But what exactly have you approved? Did you see the complete list of files? Did you understand why the agent wanted to remove them? Could the list change between the moment you approved the operation and the moment the agent executed it?

These questions become particularly important as AI agents move beyond providing advice and begin performing actions with real-world consequences. A useful approval system should do more than display a question. It should clearly identify the proposed action, the consequences, the limits of the authorization and, where appropriate, the possibility of withdrawing permission.

There is also the question of how much attention we can reasonably expect people to give these requests. If an AI agent interrupts us twice a day to ask for permission, that may be perfectly manageable. If several agents collectively generate dozens of requests, we could quickly develop the habit of clicking Approve without reading the details. We have already seen similar problems with cookie banners, software permissions and security warnings. Adding a human approval step doesn’t automatically guarantee meaningful human control.

Who is actually asking?

Another aspect is identity. In ordinary human communication, we have developed many ways to establish who we are dealing with. We recognize faces and voices, rely on mutual acquaintances, exchange contact details or use trusted institutions.

When an AI agent contacts us, things become more complicated. Suppose you receive a message saying that your personal AI assistant wants permission to transfer €250. How do you know that the request really came from your assistant? And how does the assistant know that the person approving the transfer is actually you? Simply sending an SMS or email isn’t sufficient proof of identity.

This is one reason why authentication technologies, cryptographic signatures and mechanisms such as passkeys may become important components of agent-to-human communication. The system must be able to distinguish between receiving a message, responding to it and granting authorization. Those are three different things. And as AI agents begin interacting with services that involve money, personal information or physical devices, that distinction becomes increasingly important.

What happens if we don’t answer?

Perhaps the most human question of all is what happens when someone simply ignores an agent. Software developers generally like predictable responses. An API request either succeeds, fails or times out. Humans are considerably less predictable. We might be sleeping, travelling, concentrating on something else or simply not interested in responding. We might read a request and decide to think about it. Or we might forget about it altogether.

A protocol designed to communicate with humans needs to accommodate these possibilities. An unanswered request should not automatically be interpreted as permission. Nor should every request generate an endless stream of reminders. Some decisions can wait indefinitely. Others expire because circumstances change. Still others may need to be referred to another authorized person.

This raises an interesting design challenge: how do we create interfaces that respect human time and attention while still allowing automated systems to function? So perhaps the most important feature of an agent-to-human protocol is not how efficiently it obtains an answer, but how gracefully it handles the absence of one.

A new kind of communication infrastructure

The emergence of these protocols suggests that agent-to-human communication may eventually become a distinct layer of our digital infrastructure. Today, an application typically implements its own notifications, approval windows and user interactions. In the future, it might become possible that we could have personal communication gateways that handle requests from multiple AI agents.

Such a gateway might know which agent is contacting us, what it wants, how urgent the request is and which communication channel we prefer. Routine notifications could be collected for later review. Important decisions might appear on our phones. Financial transactions could require stronger authentication. Requests from unknown agents might be rejected automatically.

Of course, this raises additional questions about privacy and control. Who operates the gateway? Who can inspect the requests? Can users move to another provider? And could such a gateway itself become a new intermediary between people and the software they use? Those questions would need careful consideration, especially if these systems become part of everyday digital life. But the general idea is interesting: instead of allowing every AI application to invent its own method of interrupting us, we could establish common rules for when and how machines may request human attention.

Back to that question at WordCamp

And that brings us back to the question I encountered at WordCamp Netherlands. We can connect AI to all kinds of APIs. But what APIs are available when we want to connect to people? At first, I interpreted that question as an invitation to think about the many ways humans connect with one another. We have biological interfaces, social conventions and technological communication channels. From a smile or a handshake to email and online communities, we have developed a surprisingly rich collection of ways to establish contact.

But there is now another dimension. We are beginning to give machines standardized ways to approach us, ask questions, request decisions and obtain permission. In a sense, we are turning some of our familiar human interactions into interfaces that software can understand. For thousands of years, humans have been learning how to approach one another politely, how to ask for help, how to request permission and how to recognize when someone doesn’t want to be disturbed. Now we are trying to teach AI agents some of those same social conventions, this time in the form of technical protocols.

We already know how to make machines send requests. The difficult part is deciding when they should ask, what they are allowed to assume and how they should respond when a human says no — or says nothing at all.

Did you enjoy this article?

Recommend it — Standard Reader surfaces well-loved writing to more readers across the network.

Across the AtmosphereDiscussions