Pixels → Protocols
A2A turns SaaS into an execution layer. Operability becomes distribution.
The UI era trained us to think software is “used” by humans navigating screens.
The agent era flips the unit of work. Software is operated through callable verbs. Those verbs get assembled into an action graph, executed under constraints, and surfaced to humans only at commitment boundaries.
This article makes one structural claim.
When actions become queryable, agents become the integration plane.
Distribution stops following UI discoverability and starts following completion under bounded downside.
This is not about AGI. It does not depend on “models got smarter.” It falls out of an access mechanism shift. The operator changes. The interface changes. The fitness function changes.
0. The lens
Yahoo organized pages. Google ranked pages.
The next step is ranking actions. Not “what should I read,” but “what should I do next.”
Pages are cheap to get wrong. You click back. Actions are writes. Writes have blast radius.
To make that concrete, two definitions.
Agent is a runtime that can plan, invoke tools, verify results, recover when things fail, and escalate commitments.
A2A (agent-to-agent) is how action graphs cross boundaries. Your agent delegates a subproblem to an observability agent. A deploy agent stages a change. A policy agent blocks unsafe scope. A comms agent drafts customer updates. The job completes because multiple specialized operators hand off work as structured artifacts, not as screenshots.
That is the mental model agents deserve in 2026. Not as a chat bubble. As the system that turns intent into executed change.
1. The action graph becomes the unit of work
Work stops being “clicking through screens” and becomes “generating and validating an action graph” that can survive constraints.
Run a thought experiment.
A core metric drops in a step function at 2 a.m. Signups. Checkout completion. API success rate. Any of those drops suddenly.
In the old mode, people navigate tools to assemble reality. Dashboards. Deploy logs. Traces. Tickets. Someone pings the dependency owner. Someone writes a doc with links so others can catch up. A mitigation shows up after coordination. Even with competent people, the system is slow because the state lives across products and teams.
Now switch mode to A2A.
An incident agent takes a goal and constraints.
Stabilize the metric. Identify the likely change. Propose a mitigation. Do not touch production without approval. Produce receipts I can skim. Prepare an undo path.
What it produces is not an answer. It produces a graph.
Diagnose → isolate → mitigate → verify → communicate → revert if needed.
Each node is a verb. “Pull traces for service X in window Y.” “Diff the last deploy across these services.” “Stage a flag change for this cohort.” “Run a canary.” “Generate a rollback plan.” The edges capture dependencies. The graph carries constraints that have to hold globally.
Scope limitations. Environment boundaries. Approval requirements. Proof requirements.
The new interface is (surprisingly) not a chat log. It’s plan → stage → commit.
That plan becomes the unit of work. You can review it, diff it, rerun it, restrict it, and promote it.
This is the moment the battlefield moves. If the primary artifact becomes an action graph, the products that matter are the ones whose verbs can survive being composed.
2. Operability is the new discoverability
As actions become queryable, “can the operator finish the job end‑to‑end with bounded downside” becomes the selection pressure that reorders SaaS.
In the UI era, distribution followed discoverability.
Humans adopt tools. They learn menus. They build habits. They tolerate friction because switching costs are real and the UI can paper over awkward internals. Screens can compensate for brittle APIs. Training can compensate for weird workflows.
In an agent‑operated world, that stops being the main loop.
When the operator shifts from human to agent, habits stop being the distribution channel. Agents don’t learn your menus. They compile action graphs and route to whatever completes the step with bounded downside.
That is a different ranking function.
What gets preferred is not what is easy to navigate. It is what is easy to execute with bounded downside.
Completion probability matters. Verification cost matters. Undo cost matters. Recovery behavior matters.
If a tool cannot be used as a bounded verb inside an action graph, it becomes a fallback path. A “manual step.” A human exception.
Fallback paths do not compound. They do not get routed into repeatable workflows. They do not become the default.
This is the reason the disruption feels near-term.
You don’t need a new UI paradigm. You don’t need a new killer app. You just need a large fraction of work to be executed through a runtime that can compare paths and prefer the ones that complete cleanly.
When the ranking function changes, products get repriced.
3. The verb surface is the product surface.
In an agent‑operated world, the product is the verb contract—schemas, invariants, error behavior, and receipts—not the screens.
“API-first” is too small. The question is not “do you have endpoints.”
The question is whether your verbs behave like production primitives.
A routable verb has a contract. Not just inputs and outputs. Semantics.
Here is what “verb contract” means in engineering terms.
- Typed I/O. Inputs are structured. Outputs are structured. No hidden meaning in prose.
- Preconditions. What must be true before the verb runs. If not true, fail predictably.
- Invariants. What is guaranteed to be true if it succeeds.
- Side-effect boundaries. Exactly what it can change and what it cannot touch.
- Idempotency and replay semantics. What happens if it is called twice. What happens if the caller retries after a timeout.
- Recoverable error taxonomy. Errors that are actionable by a runtime, not human folklore. “Permission denied.” “Precondition failed.” “Conflict.” “Rate limited.” “Partial completion with receipt.”
- Preview / dry-run. A verb that can show you the diff before it commits is a different class of capability.
- Receipts. Not verbose logs. Receipts. Diffs, scope summaries, blast radius estimates, links to evidence, and a stable audit trail.
This is where “Pixels → Protocols” becomes literal.
The verb surface is the product surface.
There is a non-obvious consequence that many teams underprice.
Tool contracts act like runtime.
An agent plans against your capability descriptions. It composes verbs based on schemas, semantics, invariants, and expected failure modes. If those are ambiguous, it is not a docs problem. It is a performance problem.
Ambiguity lowers completion probability. Lower completion probability lowers preference. Preference becomes distribution.
In the UI era, you could survive with awkward internals if the screens were good. In the agent era, the screens are not where most of the work happens. The verbs are.
4. Pixels become an approval cockpit
Screens stop being where work is performed and become where work is inspected, constrained, and committed.
This is where people get confused and say “chat replaces UI.”
It doesn’t. UI changes jobs.
When the operator is an agent, most interaction becomes execution through protocols. Humans show up at commitment boundaries.
The pattern converges quickly.
The agent proposes a graph.
It stages changes.
It produces proofs.
It asks for commitment.
You can call it propose → prove → commit. The order matters because actions are writes.
The UI that survives is the approval cockpit.
Diffs you can skim. Scopes you can verify. Proof you can audit. Undo paths you can invoke. Audit trails you can reference later when something breaks at the worst possible time.
If you want the minimal cockpit, it collapses to three questions.
- What changes
- Who it touches
- How we undo it
Everything else is detail.
This is also where the predictable failure mode shows up.
When graph generation gets cheap, you get a flood of staged candidates. Proposed mitigations. Proposed migrations. Proposed optimizations. Proposed “quick fixes.” Many are reasonable. Some are wrong. All demand ownership.
Execution becomes cheap. Commitment does not.
Commitment inflation is not a model weakness story. It happens even with very capable agents because it is organizational physics. Approval, accountability, and rollback capacity are finite.
This is why “trust” is not a vibes concept in the action era. It is governance encoded into execution.
Trust catalogs are not a directory for convenience. They are a curated set of verbs whose semantics, receipts, and boundaries are certified enough to be runnable at scale.
5. Users prototype. The org productizes
Users and operators generate ad‑hoc automation first; the product organization’s job shifts to standardize and govern what repeats.
The UI era assumed invention precedes execution.
A PM writes a spec. Engineering ships a feature. Users discover it by browsing pixels.
The agent era inverts this order.
Users express intent. Agents stitch verbs into an action graph. It runs. It gets copied. It repeats. Only then does the organization decide it is “real.”
This is the workflow promotion system.
An ad-hoc graph becomes a product surface when it gets hardened.
It gets an owner. It gets boundaries. It gets monitors. It gets receipts. It gets an undo story. It gets policy constraints that prevent it from turning into a footgun.
That is a different kind of product work.
PM does not disappear. The dominant input channel changes.
You are no longer only deciding what to build top-down. You are deciding what emergent workflows deserve to become canonical, and how to constrain them so they don’t drift.
If you skip promotion, you get predictable damage.
Two teams run “the same” workflow with slightly different scopes. Definitions drift. Rollbacks become asymmetric. Approvals turn implicit. When something breaks, nobody can answer who owns the logic.
The backlog does not vanish. It becomes governance.
6. Defensibility moves to semantics and control
Value concentrates in action‑rich substrates, control planes that allocate risk budgets, and workflow layers that own repeatable outcomes.
Here is the simplest handle for where value moves.
Value accrues to verbs, brakes, and playbooks.
That sounds abstract until you map it to different operators.
Individuals
Verbs mean your agent can actually complete the job across services. Not just advise.
Brakes mean it won’t surprise you. Previews. Limits. Confirmations at the right boundary.
Playbooks mean it remembers how you do things and repeats your routine without you rebuilding it every time.
The intuitive promise is not “automation.” It is less navigation and more decision.
Researchers and engineers
Verbs mean contracts become runtime. Semantics, idempotency, recovery, and receipts decide whether systems compose.
Brakes mean policy and sandboxing move into the execution path. Not compliance theater. Actual guardrails that a runtime can enforce.
Playbooks mean traces become promoted workflows. Evaluation becomes a distribution primitive. You start measuring completion probability like reliability.
The point is technical. The agent runtime is now exercising your system the way a production workload does. If your verbs are poorly specified, you get systemic failure, not user confusion.
Enterprises
Verbs mean operability determines whether a system can be used at scale by agents. If it can’t, it stays in the “manual exception” bucket forever.
Brakes mean risk budgets become product surfaces. Identity, approvals, audit, and rollback are not side concerns. They are the interface for responsibility.
Playbooks mean standardization. The organization needs canonical workflows with ownership and bounded scope. Otherwise the agent era produces drift faster than the enterprise can correct it.
The procurement flip is simple.
You are no longer buying software that humans use. You are buying operable change that can be executed repeatedly with bounded downside.
7. Operational tests
What to measure this quarter
If this story is real, you should be able to test it without belief.
If you build SaaS, treat your verb surface like production infra.
- Can your core jobs be expressed as bounded verbs, not screen choreography?
- Do verbs support preview, receipts, and an undo story?
- What is your recovery behavior under partial execution?
- Can you measure completion probability under real constraints?
- Can you explain failures as contract violations, not “the agent got confused”?
If you buy SaaS, procure like runtime dependencies.
- Run agent trials the way you run load tests.
- Demand verb contracts, not demos.
- Ask for receipts you can audit and undo semantics you can trust.
- Prefer systems that make commitment cheap, not just execution fast.
Pixels remain. Humans remain.
But the distribution channel moves to protocols. The product surface becomes the verb contract. The UI collapses to commitment.
In an A2A world, the battlefront is not your screens. It is your semantics.
Concepts Compilation thesis · The linker