Lead with events. The Agent Control Plane (ACP) lets an AI act the same way a human does — by emitting the very events your UI already speaks — while an orchestrator coordinates safe, consistent outcomes.
The Idea
The ACP is an events‑first model for AI control. The orchestrator listens for product events — the same ones your UI emits — and coordinates the steps: navigation, side‑effects, and follow‑ups. The AI doesn’t need a special backdoor; it uses the same event stream as people do, with parity and guardrails.
Humans interact through the UI — buttons, forms, menus. The AI interacts through events — navigate, create, rename, delete, refresh. The orchestrator ensures those events produce the same, reliable outcomes regardless of who issued them. That’s what enables “agent control mode” on user request.
Why It Matters for AI Control
AI can only act safely if the system makes its possible actions explicit. An event catalog does exactly that: a stable list of intents with their inputs and expected outcomes. The orchestrator executes those intents consistently, adds permission checks and confirmations when needed, and emits follow‑ups that keep views in sync. Because everything routes through a single control plane, you get auditability, replay, and optional dry‑run.
When to Use ACP
Use the ACP when your agent needs to operate the product — create things, move data, or trigger workflows — with the same parity and guardrails as the UI. For read‑only insights, you can still speak in events without side effects; we’ll cover query‑only AI events in a future article.
A Small Example
Imagine a file upload. The view or the AI emits an asset:upload intent with metadata. The orchestrator receives it and calls the app’s storage capability to store the file. On success, it emits content:refresh so views re‑query and re‑render. No view reaches into storage directly, and the AI never calls secret internals. Everything passes through the same event stream.
Getting Started
Write down the 10–20 events your product already speaks — navigation, create, rename, delete, refresh. Give each a clear name and payload shape. Keep your public operations small and safe. Then write one small orchestrator that subscribes to a few events and emits follow‑ups. Ship it. You’ll have a control plane your team, your tests, and your AI can all agree on.
From there, you can add permissions, confirmations, metrics, and versioned event schemas. But the core never changes: intents in, safe capabilities out, consistent follow‑ups every time.
Terms, Quickly
Events: the public language of your product. Give them stable names and payloads so both UI and agent can speak them.
Orchestrator: the controller that listens for intents (events) and coordinates the steps — calling app capabilities and emitting follow‑up events to keep the system in sync.
Agent Control Plane (ACP): the orchestrator plus your event catalog, enabling AI and humans to drive the same flows with parity and guardrails.