A small team doesn't coordinate by talking through every handoff; it coordinates by converging on shared formats, predictable cadences, and standard signals that compress most of the talking away. The conventions are partly about decisions and partly about distributing legibility — every member knows what was done, on what basis, and what comes next, because the protocols broadcast that information cheaply. Four layered mechanisms do most of the work in software, clinical, aviation, and architecture teams.
Cadence rituals. Stand-ups (15 minutes, three questions, one-day window), sprint planning, weekly demos, Friday retros. Each ritual is a periodic synchronization point: at a known moment, the team pauses, surfaces what's been done and what's blocked, and resyncs. Engineering teams converge on agile or shape-up cadences; medical teams have rounds; aviation crews have briefings before each flight phase.
Handoff protocols. Standards for transferring work between people. SBAR in nursing (Situation, Background, Assessment, Recommendation) at shift change. Aviation handoff briefings on long-haul flights. PR descriptions in software (what changed, why, how reviewed, how tested). Design handoff documents from architects to engineers. Each is a fixed-format compression of context, calibrated to the receiver's reading time and prior knowledge.
Shared format conventions. RFCs and ADRs (architecture decision records), commit-message styles, ticket templates, OKR formats, status-update structures. Standards the team converges on so each work product is legible without explanation. A well-written commit message, a properly-templated PR, a one-page ADR — these reduce coordination cost to near zero because the format is the protocol.
Postmortem and incident review. Blameless postmortems (Google's SRE practice), morbidity-and-mortality conferences in medicine, NTSB accident reports in aviation, project retrospectives in software. The team pauses after a significant event, reconstructs what happened, identifies what could be different, and writes it down. The protocols presuppose that the participants remember the event and have access to whatever state the system was in.
The four layers reinforce each other. Cadence rituals create the moments at which handoffs and shared formats get reviewed; shared formats make handoffs cheap; postmortems update both the cadence and the formats. None of these depends on heavy machinery — they work because the team converges on conventions everyone can follow.
What team protocols actually do is keep a group acting as a coordinated unit: they sustain shared situational awareness, transfer decisions with their context, preserve a navigable canon of accumulated practice, and convert incidents into institutional learning. When these functions fail, the team doesn't just get clunkier; it stops being a team. People (and agents) keep producing work, but the work stops adding up to a coordinated whole.
Five differences between agent contributors and human ones load-bear. The first three are agent properties; the last two are properties of how agent work meets the team's existing infrastructure.
The four mechanisms fail in specific load-bearing ways:
Cadence rituals — shared situational awareness collapses. A stand-up's load-bearing function is that, after fifteen minutes, every team member has roughly the same picture of where the team's work is. With agents working continuously between rituals, the team operates on a picture that's stale before the meeting ends and that nobody can refresh by asking the agent (its activity doesn't compress, and the summary it offers can't be cheaply verified). Two agents make incompatible changes between Monday's and Tuesday's stand-up; nobody catches it until something breaks. The ritual continues; the synchronization function is gone, and decisions get made on shared pictures that aren't shared. Tireless and throughput drive the failure.
Handoff protocols — decisions transfer without their context. A handoff's load-bearing function is that the receiver gets enough to continue without re-deriving — and that the audit trail later shows what was decided and on what basis. When an agent authors a handoff at machine throughput, the receiver (human or agent) either drowns in unfiltered context or trusts a summary nobody verified; the human-readable PR description signs off on substance no human actually reviewed. When something breaks downstream, the audit trail shows "approved" without showing what was approved. The handoff goes through; what it was supposed to transfer didn't. Re-instanceability and throughput drive the failure.
Shared format conventions — the team's accumulated canon stops being navigable. RFCs, ADRs, runbooks, and commit conventions worked because the body of decisions stayed small enough that any team member could read in and orient themselves — and any new member could absorb it on the way in. With agent throughput, the canon grows faster than anyone reads it; new decisions cite old decisions nobody verified; new humans and new agents arrive into a body the existing team only partially holds either. The format persists; legibility becomes a fiction maintained by ceremony, and the team's grip on its own accumulated practice loosens. Throughput and developer instrumentation drive the failure.
Postmortems — the team loses the capacity to learn from its own failures. A blameless postmortem's load-bearing function is that incidents convert into institutional learning — the team gets better over time at the failure modes it's bad at. When an agent was running during the incident, the instance is often gone, its operating context (prompt, tools, scratchpad, model version) wasn't retained, and the developer who deployed it is outside the team's authority to compel cooperation. The team holds the postmortem and produces a finding about what it can see; the layer where the actual failure originated stays opaque. Incidents recur with the same root causes, and patterns across deployments stay invisible because no individual team can see across them. Re-instanceability and developer instrumentation drive the failure.
Sketches of how each mechanism could be rebuilt for mixed teams. Each is a starting point, not a worked design.
Cadence rituals rebuilt as continuous status broadcasts with human-cadence digests. Agents publish state at defined intervals (every meaningful action, every commit, every escalation), with a daily digest summarizing the last 24 hours of agent work in human-readable form. The stand-up no longer asks each agent "what did you do yesterday"; it reviews the digest, surfaces anomalies, and the team adjudicates only items the digest flagged. The digest is generated by an independent process, not by the agent that did the work — so the summary is auditable against the raw activity log.
Handoff protocols rebuilt as receiver-shaped formats. Handoffs split into two paths: human-receiving (tight summary, structured for quick read, optimized for the receiver's prior context) and agent-receiving (full context, machine-readable, including everything the sending party considered). A handoff includes a declared receiver type so the format matches. The PR template, the on-call runbook, the design handoff all get a paired machine-format counterpart, and the team's conventions specify which gets generated when.
Shared format conventions rebuilt with throughput limits and provenance. RFCs, ADRs, and commit messages gain a provenance field (human-authored, agent-authored, agent-drafted-human-approved) and a throttle on agent-generated submissions per cadence cycle. The team's review capacity becomes the explicit budget the format respects; agents that exceed it queue or escalate. Conventions stop being purely structural and acquire a flow-rate dimension.
Postmortems rebuilt with developer participation and preserved state. When an agent is on the team, deployment requires retention of operating state (prompt, tools, recent context, model version, deployment parameters) for a defined window past any incident. The postmortem protocol extends beyond the deployment instance to the development pipeline: the agent's developer (or its represented organization) participates in the review and surfaces what the agent had access to. The team's incident review now spans two organizations, with defined responsibilities at each layer.
Anchor contexts. A 6-person software team with two coding agents that work continuously and three engineers who maintain a 10am stand-up; a small clinical team with AI triage and documentation agents operating across all shifts.
The gap. Cadence rituals like stand-ups worked because every team member's activity compressed into a recap-able window. Agents working continuously don't fit the format; teams that include them face a forced choice between losing visibility, padding the ritual with unverifiable text, or excluding agents from the coordination function entirely. We lack a status-broadcast protocol that surfaces agent activity in human-adjudicable form, that the team can verify against raw activity, and that integrates with the existing cadence without absorbing the meeting.
Success criterion (stress tests). A regime succeeds if it survives:
Deliverable. The status-broadcast specification — trigger, digest production, verification, stand-up integration, flag-and-escalate filter. Designed for a 6-person team with 2–3 agents. Specify the attention cost in minutes per week and the storage cost in GB per month.
Anchor contexts. A software team's PR template currently shared across human-to-human, human-to-agent, agent-to-human, and agent-to-agent reviews; an on-call runbook handoff at shift change when one shift is staffed by a human and the next by an agent (or vice versa).
The gap. Handoff protocols like SBAR, PR descriptions, and design handoffs converged on a specific receiver — a person with bounded reading time, prior context, and the ability to ask. When the receiver is an agent (which could ingest more) or the sender is an agent (which could write more), the format under-serves both ends. We lack a handoff protocol that adjusts format to declared receiver type, that prevents agent-authored output from drowning human review queues, and that doesn't force the team to maintain four parallel templates by hand.
Success criterion (stress tests). A regime succeeds if it survives:
Deliverable. The handoff-protocol specification — receiver declaration, format coupling, throughput limits, re-routing, context-completeness. Plus worked examples: a PR template adapted for each of the four sender×receiver pairs (human→human, human→agent, agent→human, agent→agent), with the rendering rules.
Anchor contexts. A small software team running an AI on-call agent that responds to pages and executes runbooks; a small clinical team with an AI triage agent that operated during a misdiagnosis incident.
The gap. Postmortems work because the participants remember the incident and have access to whatever state the system was in. When an agent was running during the incident, the instance may be gone, the operating context (prompt, tools, scratchpad, model version) may not be retained, and the developer who deployed it may not surface that state on request. We lack a postmortem protocol for mixed teams that preserves the operating state long enough to investigate, that pulls the developer into the review when their agent was involved, and that produces a finding the team can act on without re-litigating who-owns-what across organizational boundaries.
Success criterion (stress tests). A regime succeeds if it survives:
Deliverable. The postmortem-protocol specification — state retention, standing, counterfactual reconstruction, finding ownership, cross-incident pattern. Designed for a small team deploying an agent from a separate vendor. Identify which provisions have no analogue in pre-AI blameless postmortems (Google SRE, NTSB, M&M conferences) and why.