The reference site for the agent-interface layer
What is an agent interface?
An agent interface is the layer where an AI agent meets everything outside the model. It has two sides: the surface a human uses to direct, supervise, and correct the agent — and the protocols the agent uses to operate software, tools, and other agents. Chat panels, approval gates, MCP connections, and computer-use screen control are all parts of it.
Disambiguation: "agent interface" also has an older meaning — the screen a human support agent uses in contact-center software. This site covers the AI sense of the term.
01The short version
- The term covers two layers: human ↔ agent (supervision UX) and agent ↔ software (protocols). Most confusion comes from mixing them.
- The agent-software layer is standardizing fast — a handful of open protocols now define how agents reach tools, each other, frontends, and payments. The tracker holds the current map.
- The human-agent layer is converging on repeatable patterns — approval gates, permission modes, streaming progress, handoffs — ahead of any formal standard. The guides cover them one at a time.
- An agent interface is judged by one question: can a human predict, bound, and audit what the agent will do? Everything on this site serves that question.
02What does an agent interface do?
An agent interface turns a capable model into a system people can actually delegate to. Downward, it gives the agent structured access to the world: tools it can call, data it can read, software it can operate, other agents it can hand work to. Upward, it gives the human command: what the agent may touch, when it must ask, what it is doing right now, and what it did last Tuesday.
The two directions are one design problem. Every new capability granted below creates a supervision question above — an agent that can spend money needs a spending gate; an agent that can act across apps needs an audit trail that spans them. Products that treat the protocol side and the UX side as separate projects ship the gap between them.
03Agent interface vs. chatbot UI vs. copilot
| Chatbot UI | Copilot | Agent interface | |
|---|---|---|---|
| System can | Answer | Suggest inside one app | Act — across tools, over time |
| Human's job | Ask well | Accept or reject inline | Direct, bound, supervise, audit |
| Core widget | Message thread | Inline completion / diff | Approval gate, permission modes, run view, trail |
| Failure mode | Wrong answer | Bad suggestion | Unwanted action — which is why the interface is the safety system |
| Wiring underneath | One model API | App-internal hooks | Protocols: tools, agent-to-agent, frontend, payments |
The boundary that matters is action. A system that only answers needs good conversation design. A system that acts needs an agent interface, and the difference is not cosmetic — it is approval gates, permission modes, interruption, and an audit trail, none of which a chat thread provides.
04The protocol layer, mapped
The agent-software side of the interface is where the standardization is happening. These are the protocols and approaches that matter right now — each links to its tracker entry with a current status call and sources:
The full tracker → is the living version of this map: statuses, stewards, spec links, and what changed, reviewed continuously.
This layer kills fast. We keep the list.
- OpenAI Operator7 monthsabsorbed into ChatGPT agent
- ChatGPT Atlas<10 monthsthe standalone agentic browser, discontinued
- AgentKit Agent Builder8 months to deprecationvisual agent-building lost to code again
- IBM ACP~5 monthsmerged into A2A; its acronym got recycled
05The human layer: the patterns that keep people in command
No standards body owns the human side yet, but shipped products have converged on a recognizable pattern language. The load-bearing ones:
- The approval gate — the agent proposes, the human releases. Done well it shows the consequence, not the raw action. Guide →
- Permission modes — graduated autonomy: read-only → suggest → auto-with-gates → scoped full-auto, set per domain, promoted only by the human. Guide →
- Streaming progress — a long-running agent narrates what it is doing at decision-level, so interruption is possible before the consequence, not after.
- Handoff — the agent escalates with context when it is stuck, instead of guessing expensively.
- The audit trail — append-only history of action, predicted consequence, and approver. The thing that makes widening autonomy survivable.
06Why agent interfaces matter in 2026
Models crossed the capability line before products crossed the trust line. What limits deployment of agents today is rarely whether the model can do the work — it is whether an organization can predict, bound, and audit the work. That is an interface problem, in both directions: protocols make capability legible to software; supervision UX makes it legible to people.
The teams shipping agents successfully are the ones treating the interface as the product. The model is rented; the interface — the permissions, the gates, the trail, the integrations — is what they actually build.
07Frequently asked questions
Is an agent interface the same thing as a chatbot UI?
What is the difference between MCP and an agent interface?
What are the main agent-interface protocols?
What does a good human-agent interface include?
Who maintains this site?
Also on this domain: the Library — an archive of published verdicts from The AI Council, an earlier experiment here in which four frontier models argued real questions and handed down one verdict. It stays up because the deliberations are still worth reading.