We have spent two decades treating coordination as a people problem. Reorganise the teams, redraw the org chart, refine the Jira workflow, add a standup. The implicit assumption was that the units being coordinated were humans, and that humans coordinate through conversation, hierarchy and shared intent. That assumption is now breaking. Gartner expects 40% of enterprise applications to feature task-specific AI agents by 2026, up from less than 5% in 2025, and forecasts that by 2029 seventy per cent of enterprises will run agentic AI within IT infrastructure operations. Once a meaningful share of your delivery capacity is non-human, the old coordination instruments stop working. An agent does not attend standup. It does not read the org chart. It does not infer intent from a Slack thread.
So what does coordinate a mixed human-and-agent team? The contrarian answer is that it is not the ticket and not the reporting line. It is the event and data contract — the schema-governed, versioned interface through which work is handed off. Event-driven architecture, long sold as a decoupling pattern for systems, turns out to be the substrate for hybrid delivery. The contract becomes the guardrail for autonomy, and schema governance becomes, almost without anyone deciding it, agent governance.
Coordination is an infrastructure problem, not a model problem
Sean Falconer of Confluent puts the case bluntly: scaling agents is fundamentally a coordination problem, not a model problem. "This isn't an AI problem, it's an infrastructure and data interoperability problem." His argument is that synchronous RPC and API calls force agents to wait on one another, whereas event-driven loose coupling lets agents "react to what's happening in real time." That distinction matters enormously when some participants are humans operating on a scale of hours and some are agents operating on a scale of milliseconds. Synchronous coupling assumes both sides are present and fast. Events do not. A human can pick up an event tomorrow; an agent can consume the same event in the same second. The contract, not the clock, governs the handoff.
The convergence is visible across vendors. Google's Agent2Agent protocol, introduced as an open standard in April 2025, leans on common web standards — HTTP, JSON-RPC, Server-Sent Events — and supports asynchronous push notifications for long-running tasks, with security, auditing and compliance guardrails built in. The cross-vendor agent interface is settling on asynchronous, event-style contracts rather than synchronous calls. That is not a coincidence. It is the same lesson distributed systems learned the hard way, arriving again with autonomy attached.
The schema is the contract
If events are the medium, the schema is the law. In Confluent's reference architecture for agentic event-driven systems, Mohtasham Sayeed Mohiuddin states the rule plainly: "Every event must conform to a versioned schema registered in a schema registry. Producers cannot publish events that violate the schema contract." The failure mode is specific and nasty — undetected schema drift causes agents to fail silently. A human reading a malformed handoff usually notices something is off. An agent confidently processes garbage and propagates it downstream. The schema registry is what makes the contract enforceable rather than aspirational, and the technical substrate already exists: Confluent's Schema Registry offers backward, forward, full and transitive compatibility modes that determine whether a new schema may coexist with older versions.
This is where the data-contract discipline earns its keep. A data contract is a formal producer-consumer agreement that bundles schema — field names, types, nullability, allowed values — with data-quality rules, SLAs, explicit ownership (who produces, who consumes, who approves changes), validation triggers and governance policy into a single machine-readable artefact. It is, increasingly, a machine-readable governance agreement. And crucially, the discipline of evolving it safely is already well understood by large-scale operators. The rule that lets Uber, Netflix and DoorDash evolve schemas with zero outages distributes responsibility across the boundary: producers must stay backward compatible, consumers must stay forward compatible, and safe changes are additive — add optional fields with defaults, never delete or rename in a way that breaks readers. That is exactly the property you need when one side of the contract is a human team shipping on a sprint cadence and the other is a fleet of agents redeploying continuously.
From task allocation to bounds
The deeper conceptual shift comes from the academic side. The Agent Contracts framework of Qing Ye and Jing Tan reframes coordination itself. Where the classic Contract Net Protocol asked "who should do this task?", Agent Contracts ask "within what bounds may this task be performed?" They formalise a contract as a seven-tuple — input, output, skills, resource constraints, temporal constraints, success criteria and termination conditions — and argue these provide "formal foundations for predictable, auditable, and resource-bounded autonomous AI deployment." Attribute that reframing to its authors, because it is the right one: autonomy is not the absence of control, it is control expressed as bounds rather than instructions.
The cost of skipping those bounds is concrete. Ye and Tan motivate the work with a multi-agent research system that ran undetected for eleven days and accrued a $47,000 API bill because there were "no stop conditions, no budget limits." Ungoverned autonomy is not a hypothetical. It is an invoice.
The ticket tells an agent what to do. The contract tells it what it is allowed to do — and that is the only instruction autonomy actually respects.
Schema governance is agent governance
Here is the quiet inversion. In Confluent's agentic architecture, the governance of the event layer is the governance of the agents. Topic-level read and write permissions are enforced per agent and per service; "agents can only consume topics relevant to their decision domain." Every agent action is validated against policy and passes approval gates before a command is emitted, and an immutable event log gives a complete decision history for compliance. Notice what has happened: the controls you would want over an autonomous agent — least privilege, policy validation, human approval gates, full auditability — are precisely the controls a well-run event platform already provides. You do not need a separate agent governance plane. You need to take your event contracts seriously.
Regulators are arriving at the same place from the opposite direction. NIST's AI RMF Agentic Profile extends RMF 1.0 with concepts specific to agent autonomy, tool-use risk, runtime behavioural governance and delegation-chain accountability — and NIST is explicitly soliciting input on audit and non-repudiation mechanisms for agents and on portable, attestable agent identity. Auditability of agent action is becoming a governance requirement, and an immutable, schema-governed event log is the most natural place to satisfy it. The delegation chain that NIST worries about is, in practice, a sequence of contracted handoffs.
What this means for delivery architecture
Treat the event contract as the primary design surface for any team that mixes humans and agents. Decide who owns each event, version it deliberately, enforce compatibility at the registry, and write the policy and approval rules into the contract rather than into a wiki page nobody reads. The org chart and the ticket do not disappear — they coordinate humans with humans. But the load-bearing interface, the one through which an agent safely hands work to a person and a person safely hands work to an agent, is the contract. Get the contracts right and autonomy becomes governable. Get them wrong and you are eleven days from a $47,000 surprise.
This is event-driven architecture doing far more than decoupling systems. To see why we think the pattern has been systematically underestimated as an organising principle for delivery itself, read our argument in Event-Driven Architecture Beyond the Technology.