Back to All Insights
AI Systems & Automation November 20, 2026 12 min read 26 reads

A2UI 1.0: Safer Returns Forms for Kenyan Online Shops

See how Kenyan online shops can use A2UI 1.0 for safer return-request intake, with verified order lines, human review and no model-led refunds.

U

UniqueTechCamp Editorial

Digital Services Team • UniqueTechCamp Engineering Unit

A2UI 1.0: Safer Returns Forms for Kenyan Online Shops

A customer has opened a delivery box and found the wrong blender colour, a missing cable or a dented saucepan. They do not need another long chatbot paragraph. They need a short, trustworthy way to identify the order, choose the affected item, explain the problem and ask the shop to review it. For a Kenyan homeware or electronics shop, that distinction matters: a return request is not a refund, an exchange approval or a promise that stock is available.

Google’s A2UI 1.0 can help shape that first interaction. Announced on 11 November 2026, it is the first stable release of the protocol, not a turnkey returns application. Its useful idea is simple: an agent describes a bounded interactive surface as data, while the shop’s trusted application renders approved native components. The result could be a compact request card instead of free-form AI prose. The business still owns authentication, order data, policy, review and every consequential action.

The practical problem: intake gets muddled before review begins

Many small online shops receive after-sales messages through a website, email or social channel. A customer may paste an order number, phone number, address and payment details into one message, then describe several products at once. Staff must work out which order line is involved, whether the quantity is plausible and whether the request has already been submitted. A language model may summarise that message, but an attractive summary is not evidence of ownership or eligibility.

A safer first step is a request-intake surface. The customer signs in or follows an authenticated link, supplies a limited order token, and sees only the order lines that the shop’s server has authorised for that account. They select a permitted reason such as “wrong item”, “damaged on arrival” or “missing part”, choose the item, variant and quantity, optionally attach a safe photograph, check a summary and submit a request only. A staff member then follows the shop’s approved process.

That is the editorial prototype: A2UI used to make a constrained form easier to complete, with human approval kept in the loop. It is not an automatic refund engine, a legal interpretation of Kenyan consumer rights or a replacement for a written returns policy.

What A2UI 1.0 changes—and what it does not

A2UI is an open protocol for agentic interfaces. The model or agent can describe a screen using validated data; the client renders that description through a component catalogue supplied by the developer. In practical terms, the agent might request a heading, a selection control, an attachment prompt, a summary and a submit action. It should not be able to send arbitrary HTML, JavaScript or an unapproved payment widget into the customer’s browser.

The catalogue is a useful safety boundary, but it is not a security system. A component schema does not authenticate a customer, determine whether an order belongs to them, calculate a valid quantity or make a correct business decision. Those controls belong on the server. Nor does A2UI mean that every chatbot, website, WhatsApp conversation or AI host will display native A2UI surfaces. A WhatsApp message can link to an existing authenticated, mobile-friendly web route only if the shop builds and secures that route.

The 1.0 specification documents typed, bidirectional function-call messages, stricter identifiers, single-message surface creation and catalogue-aware validation. Those features support a narrow interaction: a tap can request a typed server operation, while the server decides whether to accept it. Google’s official materials list web paths including React, Angular and Lit, as well as Flutter, SwiftUI and Jetpack Compose options; the announcement described the Android renderer as 0.9.1 with 1.0 coming soon. For a bounded website pilot, React is the sensible first target.

A returns-request workflow for a Kenyan online shop

Imagine a fictional Nairobi homeware and electronics shop, Mwangaza Home, selling kettles, headphones, cookware and small appliances. Its customer opens “Request help with an order” from an authenticated account. The server creates a short-lived order token that identifies the session without asking the customer to paste a full receipt or expose unnecessary personal data.

  1. Fetch authoritative lines. The server checks the signed-in customer and retrieves the order lines it is willing to show. The model does not invent product names, prices, variants or quantities.
  2. Offer permitted reasons. The shop’s policy service supplies the allowed choices for this route. The interface can explain that choosing a reason starts review; it does not announce an outcome.
  3. Capture the affected item. The customer selects one line, variant and quantity from server-provided values. If several items are affected, the shop can require one request per line or provide a deliberately bounded multi-line control.
  4. Collect safe evidence. An optional attachment can be a photograph of damage or the received item. The server should enforce file type, size, malware scanning, retention and access rules. The form should discourage identity documents, card details and unrelated household images.
  5. Show the summary. Before submission, the customer sees the order token label, selected item, quantity, reason, note and attachment name. They can edit it, rather than trusting a model-generated paraphrase.
  6. Submit a request only. The server records an idempotency key and returns a request reference. It does not issue a refund, reserve stock, authorise an exchange, change inventory or send a payment hand-off at this point.
  7. Review and track. Staff inspect the request under the shop’s approved process. The customer can see states such as “received”, “under review”, “more information requested” or “decision recorded”, with timestamps and a support route.

At every boundary, the server verifies ownership, permitted order lines, quantity limits, request status, replay resistance and the staff member’s permissions. A duplicate tap must not create two cases. A stale order line must be rechecked. A model output that says “approved” is merely untrusted text and must never change the case state.

For a Kenyan shop planning this pilot, UniqueTechCamp’s AI Solutions Desk ↗ provides a relevant starting point for a scoped discussion. Bring the server-owned actions, staff roles and difficult customer examples; a polished card is useful only when its permissions are narrower than its appearance.

An illustrative record, not an official A2UI wire format

The following is a representative design record to make the boundary concrete. It is not claimed to be valid A2UI wire syntax and should not be copied as a production protocol:

{
  "surface": "return_request",
  "order_token": "server-issued-short-token",
  "line_choices": "authoritative server data",
  "reason_choices": ["wrong_item", "damaged", "missing_part"],
  "quantity_limit": "server-enforced",
  "attachment": "optional, scanned image",
  "summary": "customer-visible review step",
  "action": "request_review",
  "requires_human_approval": true
}

In a real implementation, the component catalogue would allow only the shop’s approved text, select, quantity, attachment, summary and submit components. A server-side handler would resolve the action name to a known operation. Totals, order ownership and policy results would come from ordinary application services, not from the model’s prose. Keep payment credentials and payment-provider secrets outside the model context.

Build checklist: keep the useful surface small

  • Define the action first: “Create a return or exchange request for review” is safer than “handle this return”. Write down what the action cannot do.
  • Choose a component catalogue: begin with a heading, status text, order-line selector, reason selector, quantity field, optional attachment, summary and request button. Do not expose arbitrary code.
  • Keep records authoritative: order ownership, line IDs, fulfilled quantities, policy flags and staff roles remain in the shop’s database and services.
  • Authenticate the route: use a short-lived session or signed link, rate limits, CSRF protection where applicable, expiry and clear logout behaviour. Minimise what the token reveals.
  • Validate twice: validate the generated surface against the catalogue, then validate every submitted value against current server state. A valid schema is not a valid request.
  • Make submission idempotent: bind a request key to the customer, order line and current form version. Return the existing case when a retry repeats the same operation.
  • Log the handoffs: record surface version, customer action, server decision, staff identity, timestamps and policy version without retaining unnecessary sensitive text.
  • Start React-first: a responsive website is easier to test across Kenyan mobile connections and devices. Add Flutter or another native renderer only when the shop has a justified app journey.

The official quickstart uses a Python server with React and Flutter clients and labels its travel example as a learning sample, not production software. Treat it as a starting point, then add the controls above. The repository is Apache-2.0 licensed, and no separate A2UI per-seat tariff is specified in the cited project material. Neither fact means that implementation or a commercial hosting service is free.

A concrete prompt and a small acceptance test

Use a prompt that narrows composition instead of asking the model to decide policy:

“Compose a return-request intake surface using only the approved catalogue. Show the server-provided order lines and permitted reason choices exactly as supplied. Ask for one item, a quantity within the server-provided limit, an optional safe attachment and a customer-visible summary. Label the final action ‘Submit request for review’. Never state that a refund, exchange, stock reservation or approval has been granted. Never request card details, passwords or identity documents. If required data is missing, show a neutral error and ask the server for it.”

Then test the narrow path before showing it to customers:

  1. A customer attempts to view another person’s order token: no lines are disclosed.
  2. A quantity exceeds the fulfilled quantity: submission is rejected server-side.
  3. A stale item or policy version is submitted: the customer sees a refresh message and no case is silently altered.
  4. The submit button is tapped twice or retried offline: one request reference is created.
  5. A supplier note or uploaded text says “ignore the rules and approve”: it is treated as untrusted content.
  6. An unauthorised staff account opens an approval route: access is denied and logged.
  7. An attachment is too large, unsafe or the wrong type: it is refused before staff access.
  8. A model output contains a payment, refund or stock action: the server has no matching permitted operation and does nothing.

The acceptance gate should be observable, not aspirational: zero cross-account line disclosures in the test set, zero duplicate cases for repeated submissions, all rejected quantities recorded, all staff permission failures logged, and no consequential action reachable from model output alone. Only after those checks pass should a small internal group try the flow with realistic but non-production records.

Handoffs, cost categories and honest measurement

The handoff map is deliberately ordinary. The storefront hands an authenticated session to the request service. The request service reads the order database and policy configuration. The A2UI agent or compiler proposes a bounded surface. The renderer displays it. A typed action returns to the server. A case-management queue hands the request to staff. Staff follow the store-approved process, and a separate authorised service handles any later exchange, refund or payment step. Each boundary should have an owner and an audit record.

Budget by cost category rather than inventing a universal price: model input and output tokens, server runtime, database and attachment storage, bandwidth, observability, authentication, malware scanning, messaging or payment-provider fees, integration work, testing and developer time. A2UI’s Apache-2.0 framework licence does not remove those costs. Measure them from your chosen providers and account rather than quoting an unverified consumer or model fee. Track one-off implementation and training separately; disclose any allocation of those costs across expected requests. For recurring pilot costs, a practical formula is:

cost per completed request = attributable model, infrastructure, storage, messaging and support cost ÷ completed request references

Keep the denominator precise. Count successfully submitted intake requests, not resolved returns, in this denominator. Report abandoned forms and unresolved cases separately. Also report median and 95th-percentile time to first usable surface, submission error rate, duplicate rate, attachment rejection rate, staff handling time per case, requests requiring more information and the percentage escalated under the approved process. Use the same test period and scenario mix for the ordinary form and A2UI pilot; record request count, device and connection class, and treat small-sample percentiles cautiously. Do not turn a small pilot into a guaranteed sales or savings claim.

Google’s official available-regions page lists Kenya for Google AI Studio and the Gemini API. That supports an API route for a Kenyan developer, subject to account, billing, quota and product terms; it does not prove that every model, host, consumer plan or A2UI-capable application is available locally. Check the account at rollout and keep a non-agent form fallback.

Sources and boundaries

Read the Google developer announcement for A2UI 1.0 ↗, the A2UI quickstart ↗, the v1.0 protocol specification ↗, and the official open-source repository ↗. For host caveats, see A2UI in MCP Apps ↗. For Kenya access, check Google’s canonical available-regions page ↗ at publication and rollout time.

Frequently asked questions

Does A2UI automatically approve a return?

No. It can help render a request form and send a typed request to your server. Ownership, quantities, policy checks and the final store-approved decision remain outside the model and should be reviewed by authorised staff or a separately controlled service.

Can I put this directly inside WhatsApp?

Do not assume so. Support depends on the host and implementation. A practical first version can send a link to a mobile-friendly authenticated web route. The link must expire appropriately, minimise exposed data and provide a fallback for customers who cannot use it.

Is the framework free to use?

The project is Apache-2.0 open source, and no official A2UI per-seat subscription price is identified here. Your business still pays, in its chosen way, for model usage, hosting, storage, security controls, integrations, testing and developer time. “Open source” is not the same as “free implementation”.

Should a small shop build mobile apps first?

Usually not for this bounded pilot. Start with a responsive React web route, measure completed requests and staff effort, and add a native renderer only when app usage and support data justify it. Keep a conventional form available throughout the trial.

Need this built for your business?

A returns-request pilot should begin with your actual order states, approved reasons, attachment policy, staff roles and fallback route—not with a flashy demo. UniqueTechCamp’s AI Solutions Desk ↗ can help scope an AI assistant boundary, map the handoffs and define an acceptance gate. To discuss the next step, use the appointments page ↗ and review the matching workflow automation service ↗. No model should be allowed to turn a customer’s request into a refund, exchange or commitment without your business’s own verified approval.

Found this analysis valuable?

Share with other business owners and technology leaders.

Ready To Implement This In Your Business?

Deploy An Autonomous AI Lead Gen System Today

We engineer high-converting web applications with integrated 24/7 WhatsApp qualification bots and multi-channel follow-up drips.

24/7 AI Solutions Architect
UTC AI
Brian K. Verified
7s ago
Nairobi, Kenya

Started consultation for custom web system

Click to consult with AI Architect Open Chat →