AG-UI: the agent that streams an interface, not a transcript

Agents that stop at the chat box

Most “AI agents” in production today are chat interfaces with a system prompt. The interface is a text stream. The user sees tokens. The agent sees tokens back. Nothing else exists in that world: no state, no structure, no notion of where in a process you are.

But real work isn’t a conversation. It’s a process with UI, approvals, and tools. A wealth onboarding flow isn’t “tell me about yourself.” It’s identity verification, then risk assessment, then DMN routing, then advisor review, then account opening. Each step has state, produces an output, and ends in a decision. Flattening that into a chat transcript throws away exactly the structure that makes the work auditable.

AG-UI is a protocol built for this gap. Instead of streaming text, the backend streams typed UI events to the frontend: generative cards, tool call states, human-in-the-loop tasks. The agent renders a living interface, not a transcript. Episode 2 of Agents, Orchestrated is what happens when you point that protocol at a process engine instead of a chat framework.

What I built: AURUM Private Bank

The demo is a fictional private bank onboarding concierge, AURUM Private Bank. A client applies. The agent orchestrates the whole flow, from identity verification to account opening, while the operator watches the same run as a live process instance in Camunda Operate.

Three layers, and each one earns its place.

The experience. The client doesn’t watch a chatbot type. Cards stream into the interface one by one as the process advances: identity verified, risk assessed, portfolio recommended, advisor review flagged. Each card is a typed AG-UI event rendered by the React frontend. It reads as a living UI, not a transcript, because it is one. The frontend has no business logic; it renders what the backend emits.

The backend. The flow is a BPMN process executing on Camunda 8.9, and you can watch the token move: Intake, then Identity, then Risk, then DMN routing, then Advisor Review, then the AI Agent, then account opened. The Advisor Review step is a USER_TASK, and this is the detail I care most about. When the token reaches it, the process pauses and waits for a human. Not a polling hack, not a webhook trampoline. The engine’s native wait state. Every step of the run is visible in Camunda Operate as it happens.

The agent. The reasoning layer is multi-model. Claude models on Amazon Bedrock and Gemini reason over the client’s data, fire one of 13 tools, and emit AG-UI events natively as they work. Different models sit behind different parts of the same process, and the process engine keeps them honest: a model can propose, but the token only advances when the step completes.

One implementation note that matters: there is no CopilotKit and no ChatKit in this build. AG-UI is implemented directly against the Camunda 8 backend using the AG-UI EventSource protocol, plain SSE from a Node.js backend-for-frontend to the React app. The protocol is simple enough that going direct was less code than adopting a framework, and it proves the pattern isn’t coupled to any particular frontend kit.

Why the process engine is the point

The key insight, and the reason this episode exists: when a process engine is the orchestrator, agentic UX gets properties that chat-native architectures can’t have. Not “doesn’t have yet.” Can’t have, structurally, because chat architectures keep state in the model’s context window.

Reliable. If the agent crashes mid-flow, the BPMN process resumes from where the token stopped. State lives in Camunda, not in the LLM’s context window. A dropped connection or a failed model call is a retry, not a lost onboarding.

Pausable. A User Task can pause the flow and wait for a human decision, for a minute or a week. The agent doesn’t spin, doesn’t poll, doesn’t hold a context window open. The process waits, at zero cost, and resumes when the advisor acts.

Auditable. Every state transition, every tool call, every decision is logged in Camunda Operate. The audit trail exists without a single line of custom logging code. When someone asks “why did this client get routed to advisor review,” the answer is a process instance you can open, not a log query you hope was instrumented.

The pattern here is orchestration-first, and it’s engine-agnostic. Camunda is what I ship with, but the argument holds for Temporal or any engine with durable state and native wait states. What you cannot get away with is making the LLM the orchestrator.

That’s what the thesis compresses to: one process, three models, zero glue code. The BPMN process is the only coordination layer. The models plug into it. Nothing bespoke holds it together.

What didn’t make the LinkedIn post

The honest notes, because the polished demo video hides real decisions.

The bank is fictional and the client data is synthetic. The identity and risk steps call tools that return plausible results, not real KYC providers. What’s real is the architecture: a live Camunda 8.9 cluster, the AI Agent Connector v6, real model calls to Bedrock and Gemini, and a real USER_TASK that genuinely blocks the process until a human completes it in the demo’s approval desk.

Going direct on AG-UI instead of using CopilotKit cost me a day of reading the event protocol and building the SSE bridge in the BFF. It was worth it, but I’d only recommend it if you want to understand the protocol; if you just want the UI, the frameworks are fine.

The 13 tools are the number the demo needed, not a benchmark. Multi-model routing worked, but I chose the model per step at design time. Nothing in this build selects models dynamically at runtime, and I’d want an eval harness in place before letting anything do that in front of a client.

And the “zero glue code” claim deserves precision: zero orchestration glue. There is still a BFF translating engine events into AG-UI events. What’s absent is any custom code deciding what happens next. That decision lives in the BPMN, where an auditor can read it.

Ship log

• Engine: Camunda 8.9 (SaaS cluster), AI Agent Connector v6
• Models: Claude on Amazon Bedrock, Gemini
• Tools: 13, fired by the agent layer
• Protocol: AG-UI over SSE (EventSource), implemented directly, no CopilotKit or ChatKit
• Frontend: React, rendering typed AG-UI events as generative cards
• Backend: Node.js BFF bridging Camunda to AG-UI
• Human gate: BPMN USER_TASK (Advisor Review), visible live in Camunda Operate
• Repo: letmereviewyourcode/camunda-agui-wealth-demo