One Chat, Three Clouds: An A2UI 1.0 Agent Mesh Over A2A on Google Cloud, AWS and Azure A step-by-step guide demonstrates a cross-cloud agent mesh in which three A2UI 1.0 currency agents run simultaneously on Google Cloud, AWS and Azure, with an AG-UI coordinator routing each chat question over A2A to one or all of them and returning answers as A2UI cards and charts labelled by cloud, framework and model. In a ten-prompt routing suite run ten times through the chat UI, 100 of 100 turns reached the right clouds with the right job, and every agent call that should return A2UI did, per the author's published results. The mesh runs Google ADK with gemini-3.8-flash on Cloud Run, Strands Agents with us.amazon.nova-2-lite-v1:0 on Bedrock AgentCore Runtime, and Microsoft Agent Framework with gpt-5.4-mini on Azure OpenAI Container Apps, each agent joining the shared A2A server with two added lines. One Chat, Three Clouds: An A2UI 1.0 Agent Mesh Over A2A on Google Cloud, AWS and Azure This article provides a step by step guide to a cross-cloud generative UI mesh. Three A2UI 1.0 currency agents run at once, one each on Google Cloud, AWS and Azure, and an AG-UI coordinator sends every chat question over A2A to one of them or to all three. Every answer comes back as A2UI cards and c harts, labelled with the cloud, framework and model that built it. https://github.com/xbill9/currency-mesh-agui-a2ui1 The three agents joined the mesh with two added lines each. Each agent is the one from its single-cloud repository. One shared A2A server runs all three frameworks, and each agent's UI tool hands its validated A2UI to that server with one record wire call. The coordinator model names a job and a table in code picks the cloud. In a ten-prompt routing suite run ten times through the chat UI, 100 of 100 turns reached the right clouds with the right job, and every agent call that should return A2UI did. Demo video: https://www.youtube.com/watch?v=PtLc5apk8AU Role Cloud Framework Model Hosting Rate cards Google Cloud Google ADK gemini-3.8-flash Cloud Run History charts AWS Strands Agents us.amazon.nova-2-lite-v1:0 on Bedrock AgentCore Runtime, protocol A2A Comparisons Azure Microsoft Agent Framework gpt-5.4-mini on Azure OpenAI Container Apps Coordinator Google Cloud Google ADK gemini-3.8-flash Cloud Run Chat UI Google Cloud Next.js, CopilotKit, @a2ui/react Cloud Run A question travels in four hops: The browser sends the question to the UI over AG-UI, and the UI forwards it to the coordinator. The coordinator model calls one of two tools. route to cloud job, question names a job: rate, history or comparison. ask all clouds question sends the question to all three agents. Each agent answers with one A2A message: its reply text as a TextPart, and every A2UI message its UI tool validated as a DataPart with MIME type application/a2ui+json. The message metadata names the cloud, framework and model. The coordinator gives each surface a per-cloud id and returns the A2UI as its tool result. The UI renders one labelled block per cloud. The three single-cloud agents this mesh is built from: Google Cloud: https://github.com/xbill9/currency-claude-agui-a2ui1 AWS: https://github.com/xbill9/currency-strands-agui-a2ui1 Azure: https://github.com/xbill9/currency-maf-agui-a2ui1 At This Point You Should Have… Python 3.14 and Node.js 24 A Gemini API key, for the Google Cloud agent and the coordinator An AWS account with Amazon Nova 2 Lite enabled in Bedrock, signed in with aws login An Azure subscription with a gpt-5.4-mini deployment in Azure OpenAI, signed in with az login The library versions, read from the machine that ran the tests evidence/versions.txt : Component Version a2a-sdk 0.3.26 a2ui-agent-sdk / a2ui-a2a 0.11.0 / 0.3.0 google-adk / strands-agents / agent-framework-core 2.14.1 / 1.64.0 / 1.25.0 @a2ui/react / @copilotkit/react-core / next 0.15.0 / 1.56.4 / 16.1.1 mesh/server.py serves every agent. It takes one function from each, run prompt - reply text, and wraps it in an a2a-sdk AgentExecutor: async def execute self, context: RequestContext, event queue: EventQueue - None: prompt = context.get user input with capture as wire: text = await self. run prompt parts = Part root=TextPart text=text.strip if text.strip else parts.extend create a2ui parts wire message = new agent parts message parts, context id=context.context id, task id=context.task id message.metadata = { self. provenance, "a2ui messages": len wire } await event queue.enqueue event message create a2ui parts comes from a2ui-a2a, the A2UI SDK's A2A package, and turns each validated A2UI message into a DataPart. The agent card advertises the A2UI 1.0 extension with the two catalogs the agents use: the Basic catalog and the currency charts catalog. Each agent's main.py is the run function plus its card. On Azure, run streams, because the agent's reply-text rescue middleware rewrites streamed responses only: async def run prompt: str - str: text = "" async for update in agent.run prompt, stream=True : text += update.text or "" return text On AWS, one Strands Agent keeps its conversation in agent.messages, so requests take turns and each starts from an empty conversation: async def run prompt: str - str: async with lock: agent.messages.clear result = await agent.invoke async prompt return str result The A2UI an agent sends is already validated inside its UI tool, send a2ui json to client: the tool compiles the model's A2UI, expands the server-side macros and validates the result against the catalogs. The mesh needs that validated list in the A2A response. mesh/sink.py carries it there with a ContextVar, so concurrent requests stay apart and every task the framework starts sees the same list: def record wire: list dict - None: sink = sink.get if sink is not None: sink.extend wire tools/compare siblings.py diffs each agent's currency agent/ package against its single-cloud repository at git HEAD: python3 tools/compare siblings.py == aws: agents/aws/currency agent vs currency-strands-agui-a2ui1@802cb1c app/agent/currency agent/a2ui rescue.py: 122 lines, 0 changed app/agent/currency agent/agent.py: 165 lines, 2 changed +from mesh.sink import record + record wire mesh: hand the validated A2UI to the A2A executor app/agent/currency agent/custom catalog.json: 95 lines, 0 changed app/agent/currency agent/macros.py: 181 lines, 0 changed total changed lines: 2 == azure: agents/azure/currency agent vs currency-maf-agui-a2ui1@fd2268b app/agent/currency agent/a2ui rescue.py: 122 lines, 0 changed app/agent/currency agent/agent.py: 204 lines, 2 changed +from mesh.sink import record + record wire mesh: hand the validated A2UI to the A2A executor app/agent/currency agent/custom catalog.json: 95 lines, 0 changed app/agent/currency agent/macros.py: 181 lines, 0 changed total changed lines: 2 == gcp: agents/gcp/currency agent vs currency-claude-agui-a2ui1@294caee currency agent/a2ui rescue.py: 118 lines, 0 changed currency agent/agent.py: 176 lines, 65 changed currency agent/custom catalog.json: 95 lines, 0 changed currency agent/macros.py: 181 lines, 0 changed currency agent/test client.py: 154 lines, 154 changed absent here total changed lines: 219 The AWS and Azure agents changed by the two record lines. The Google Cloud agent changed by 65 lines in agent.py: its single-cloud repository served A2A from inside that file with ADK's to a2a and a streaming patch on the card builder, and reached its MCP server over HTTP. The mesh removes that server in favour of the shared one and starts the MCP server as a stdio child, as the AWS and Azure agents do. The catalog, the macros and the reply-text rescue are unchanged in all three. The coordinator is an ADK LlmAgent on gemini-3.8-flash with two tools. The model chooses a job; a dictionary chooses the cloud: JOB OWNER = {"rate": "gcp", "history": "aws", "comparison": "azure"} async def route to cloud job: str, question: str, tool context: ToolContext - dict: cloud = JOB OWNER.get job.strip .lower if cloud is None: return {"error": f"unknown job {job r}; use one of {sorted JOB OWNER }"} return result await ask cloud, question , tool context, job async def ask all clouds question: str, tool context: ToolContext - dict: pairs = await asyncio.gather ask c, question for c in CLOUDS return result list pairs , tool context, None Moving a job to another cloud is a one-word change in JOB OWNER, with no prompt to retune. The model's instruction describes the three jobs in terms of the question: a rate or a conversion, a trend over time, several currencies against one. When an agent returns A2UI, result sets skip summarization, so the cards end the turn. When an agent returns text only, the text goes back to the coordinator model, which relays it in a sentence or two. Each agent names its surface main. Three main surfaces in one turn would collide in the renderer, so the coordinator prefixes every surface id with the cloud and a short random tag: def rename surfaces messages: list dict , cloud: str - list dict : tag = f"{cloud}-{uuid.uuid4 .hex :6 }" out = for m in messages: m = dict m for key, body in m.items : if isinstance body, dict and "surfaceId" in body: m key = { body, "surfaceId": f"{tag}-{body 'surfaceId' }"} out.append m return out The tool result carries one sources entry per cloud, with its framework, model, seconds and A2UI. In the browser, MeshSources.tsx renders each entry under a label such as AWS · Strands Agents · us.amazon.nova-2-lite-v1:0 · 2.0 s, read from the agent's own A2A metadata. Five processes, each in its own terminal: cd agents/gcp && GOOGLE API KEY=$ cat ~/gemini.key PORT=10110 python3 main.py cd agents/aws && PORT=10120 python3 main.py cd agents/azure && AZURE OPENAI ENDPOINT=https://