AWP gives one website two first-class interfaces: a human interface for people and a structured agent interface for AI agents. Behind both, the website can understand intent, coordinate specialist agents, use tools, remember context, act within policy, and continue approved work beyond the original visit.
The idea in one minute
The web now has a second kind of customer: AI assistants acting for people. Thales reports that automated systems represented 53% of observed web traffic in 2025, Bain finds that roughly 60% of searches end without a visit to another website, and McKinsey estimates AI-assisted shopping could influence $900 billion to $1 trillion of US retail revenue by 2030. Most websites still speak only to people, so an AI assistant must read pages, click around, and guess what the business allows. That creates missed customers, incorrect answers, and lost opportunities.
AWP gives your website a second front door designed for AI assistants. People continue to see the website, explanations, conversations, and choices they already understand. An AI assistant receives a clear guide to what your business offers, which information is current, what it can help a customer do, what details it needs, and when it must ask for permission. The assistant can work with your business proactively.
ADK-Rust provides the engine that makes this practical. Start by letting AI assistants read approved information and complete one useful task. As your needs grow, the website can coordinate specialist AI helpers, remember ongoing work, complete bookings or purchases, send requested updates, and ask a person to approve sensitive actions. You keep control of your website, your business rules, your data, and the customer relationship.
One website · two interfaces · one agent system
Human visitor
A clear website, conversation, forms, adaptive content, and approvals designed for a person.
Accept: text/htmlAWP boundary
AI agent
Structured discovery, typed capabilities, machine-readable resources, A2A calls, and asynchronous events.
Accept: application/ld+jsonBoth interfaces read the same published business facts, policies, products, and session state.
Trust, consent, owner policy, and approval determine what each requester may do.
Events, schedules, and approved channels let work continue after the browser tab closes.
What changes
Publishing machine-readable content is the beginning. AWP becomes powerful when the website can turn a request into governed work, keep the context of that work, and communicate the result through the right interface or channel.
Understand
AWP distinguishes a person from an agent, carries session and business context, and gives the runtime enough structure to route the request well.
For example: A buyer sees delivery guidance; their purchasing agent reads price, availability, and purchase capabilities.
Act
Declared inputs, outputs, trust requirements, and side effects let an agent use the website without reverse-engineering forms or guessing which endpoint is safe.
For example: Look up an order, request a quote, reserve inventory, or call a specialist agent through a typed contract.
Continue
Sessions, durable workflows, schedules, and event subscriptions let a website continue a task and report later progress to an approved destination.
For example: Notify an agent when a payment settles, a delivery changes, or a requested report is ready.
Stay accountable
Trust levels, consent, rate limits, owner policy, approvals, health, and audit evidence determine what can happen and who remains responsible.
For example: Anonymous agents may read; known partners may act; consequential steps can wait for explicit approval.
From visit to ongoing work
A conventional website waits for another page load. An AWP system can continue a durable task, react to a business event, or reach an approved channel later. Consent, purpose, timing, owner policy, and an audit trail travel with that action.
The agent finds /.well-known/awp.json.
It reads the manifest, schemas, trust rules, and limits.
It calls a declared capability or sends a typed A2A message.
AWP checks identity, trust, consent, policy, and rate limits.
ADK-Rust agents use tools and workflows to complete the job.
Signed events or approved channels carry later updates.
A person or agent asks for something and receives a response now.
The runtime coordinates agents, tools, and workflows within declared permissions and completion rules.
A schedule or event resumes the work and sends an update through a consented channel.
AWP system architecture
The complete architecture connects inbound channels to the AWP Gateway, separates the human and agent interfaces, then brings both into the same ADK-Rust orchestrator, specialist agents, tools, memory, business context, payments, and events. A control plane applies trust, consent, approval, rate limits, health, and audit across the entire system.
AWP reference architecture
Inbound request → governed work → response or approved follow-up
Where a person, agent, schedule, or business event enters the system.
One channel-independent boundary for inbound and outbound communication.
A website experience designed for a person.
A stable, typed interface designed for another agent.
The execution system that understands intent, routes work, streams progress, and preserves state.
Orchestrator
Classify intent · choose workflow · route specialists · combine results
The services every agent can use through explicit contracts.
The human control surface for the operating system.
Control plane
Applied across every layer
Return HTML, JSON-LD, an A2A result, progress events, or an approval request.
A durable workflow waits for settlement, delivery, review, or another system event.
With consent and policy, send a signed event or message through an approved channel.
Protocol architecture
AWP is progressively adoptable. A site can begin with discovery and a machine-readable interface, then add agent calls, events, channels, payments, memory, and orchestration as the product needs them.
AWP Gateway
What it is
Normalizes browser, agent, messaging, email, and other channel traffic into a common request envelope while maintaining session continuity.
Why it matters
Business logic should not be rewritten for every place a person or agent starts a conversation.
How it works
Channel adapters identify the requester, recover the session, attach metadata, and forward one typed request to the runtime.
When to use it
Add it when the same business must work across the website, A2A clients, WhatsApp, Slack, email, or future channels.
AWP UI
What it is
Returns a human interface for browsers and a structured resource or capability manifest for agents.
Why it matters
People need explanation and interaction design. Agents need stable data, schemas, endpoints, and constraints.
How it works
Content negotiation and explicit AWP headers select HTML, JSON-LD, or an agent-oriented response without creating a separate shadow website.
When to use it
Start here when agents currently scrape pages or depend on brittle DOM interpretation.
A2A communication
What it is
Carries typed requests, responses, notifications, and errors between the website's agent system and other independently deployed agents.
Why it matters
A capability becomes much more useful when another agent can request work and receive a structured result.
How it works
AWP publishes an A2A endpoint, validates the message envelope and replay window, applies trust policy, then routes the task to an agent or workflow.
When to use it
Use it for delegated research, booking, support, procurement, quoting, and other multi-system tasks.
AWP Payments
What it is
Models payment intent, approval, execution, settlement, rejection, and cancellation as explicit states.
Why it matters
An agent should be able to transact without bypassing consent, spending policy, or human accountability.
How it works
Signed intents and policy thresholds decide which requests can proceed and which require owner confirmation before a payment provider is called.
When to use it
Add it when agents can buy, sell, reserve, subscribe, refund, or move money on behalf of someone.
AWP Runtime
What it is
Runs the orchestrator and specialist agents, manages shared context, streams events, invokes tools, and records the execution trail.
Why it matters
The two interfaces need one dependable system behind them or the human and agent experiences will drift apart.
How it works
ADK-Rust supplies typed agents, workflows, sessions, tools, RAG, artifacts, protocols, telemetry, and operating controls in one async runtime.
When to use it
Use the full runtime when the website must reason, coordinate, remember, act, and operate as a production agent system.
Events cross every layer
AWP event subscriptions carry changes such as task completion, payment settlement, delivery status, review activity, and health transitions. ADK-Rust signs webhook payloads with HMAC-SHA256 and expects subscribers to handle at-least-once delivery idempotently.
Trust before action
AWP treats trust as part of the request rather than an assumption hidden inside application code. The runtime can combine requester identity, consent records, capability policy, rate limits, owner approval, and signed events before work crosses a meaningful boundary.
Public discovery and explicitly published read capabilities.
No credentialAuthenticated capabilities scoped to a recognized caller or session.
Bearer token or API keyApproved business-to-business actions with an allowlist and stronger policy.
Verified partner identityAgent-mesh communication and owner-authorized operational work.
Inside the trusted runtimeBusiness policy defines what can happen automatically, what needs consent, and what must wait for approval. Operational digests, proposal queues, health signals, and redacted audit records give the owner a practical interface for supervising the system.
Consent can be captured, checked, and revoked by purpose.
Rate limits rise with the trust relationship.
Consequential actions can stop at an approval state.
Degraded services keep a useful non-LLM path available.
Live proof
Ask a real ADK-Rust language-model agent about AWP, how it could help your website, or what the current implementation can do. The answer is generated from your question and streamed live—the conversation is not scripted.
Answers come from a live ADK-Rust agent.
Ask a question above. The answer will appear here as the agent writes it.
Inspect the interface behind the conversation
The language-model guide explains AWP conversationally. These live requests show the underlying website interface: how another AI agent finds the site, understands what it offers, reads approved information, calls the Website Guide, and checks service health.
Request
GET /.well-known/awp.json
Accept
application/awp+json
Status
Example response
{
"version": { "major": 1, "minor": 0 },
"siteName": "ADK-Rust",
"capabilityManifestUrl": "https://adk-rust.com/awp/manifest",
"a2aEndpointUrl": "https://adk-rust.com/awp/a2a",
"supportedTrustLevels": ["anonymous", "known"],
"disabledCapabilities": ["events", "payments", "external_channels"]
}/.well-known/awp.jsonPublishes AWP version 1.0 and the site's canonical endpoints.
/awp/manifestDescribes inputs, outputs, trust, limits, evidence, and side effects.
/en/frameworkReturns HTML to a browser and JSON-LD to an explicit agent request.
/awp/catalogExposes the reviewed catalog used by the human website.
/awp/a2aExecutes validated framework, documentation, and catalog lookups. Full remote-agent tasks use the separate A2A interface.
/awp/healthReports protocol version, component health, and degraded behavior.
Published boundary
This site exposes anonymous and known trust levels, read-only catalog capabilities, strict version and message validation, rate limiting, health, and redacted audit. Its discovery document explicitly marks events, payments, and external channels as disabled. Those capabilities exist in the wider AWP model and supporting ADK-Rust crates, but this public demonstration does not pretend to enable them.
Open by design
AWP does not need to replace the protocols an agent already uses. It gives the website a stable discovery, experience, trust, and lifecycle boundary, then composes with specialized protocols behind or across that boundary.
MCP
MCP connects an agent to external tools, data, prompts, and resources. AWP describes and operates the website as an agent-facing system; its agents may use MCP behind that boundary.
A2A
A2A carries a task from one agent to another. AWP uses an A2A endpoint as one way an external agent can call the website's declared capabilities.
ACP / AP2 / UCP
Commerce protocols focus on products, checkout, mandates, and payment authorization. AWP places those capabilities inside the wider website relationship, trust model, and event lifecycle.
HTML + Schema.org
HTML remains the human surface and JSON-LD describes public resources. AWP adds discovery, callable capabilities, trust, agent communication, events, and operational health.
ADK-Rust reference implementation
The awp-types crate supplies dependency-light wire contracts. The adk-awp crate adds business-context loading, discovery and manifest generation, Axum routes, version negotiation, requester detection, trust assignment, per-trust rate limiting, consent services, signed event subscriptions, and health monitoring.
site_name = "My Business"
site_description = "Human service with an AWP agent interface"
domain = "example.com"
[[capabilities]]
name = "get_quote"
description = "Create a quote from published pricing"
endpoint = "/awp/a2a"
method = "POST"
access_level = "known"use adk_awp::{AwpState, BusinessContextLoader, awp_routes};
let loader = BusinessContextLoader::from_file("business.toml".as_ref())?;
let state = AwpState::builder(loader.context_ref()).build();
let app = axum::Router::new()
.merge(awp_routes(state))
.merge(your_human_site);Publish the well-known document and a capability manifest before adding actions.
Connect capabilities to real agents, workflows, tools, state, and authorization.
Add consent, events, health, telemetry, owner approval, and channels as required.
Build for both users of the web
Begin with a truthful discovery document and one useful read capability. Connect it to the same business context as the human page, then add actions, workflows, consent, events, channels, and owner controls as the website grows into a proactive agent system.