The Patience Equilibrium
Every deliberative protocol has a hidden regulator nobody wrote into the spec. Call it patience cost. The assumption is that holding a position, responding to objections, and grinding through a long thread all cost something: attention and time. That cost is roughly symmetric across participants. The person who cares most might persist longer, but even they eventually hit a wall. That asymptote is where decisions get made.
Code review debates close because someone's sprint ends. Open-source governance threads die because the objector gets a new job. Nobody designed these as resolution mechanisms. They're just how deliberation terminates in a world where persistence is expensive.
An agent participant breaks this cleanly. The agent can respond to every objection at hour one and hour seventy with identical energy. It doesn't develop fatigue-induced flexibility. It doesn't have a boss asking why it's still arguing. The human participants on the other side still have all the normal costs, which means the symmetry that made the protocol self-regulating is gone.
What symmetric fatigue was doing
The cost of persistence was a signal. A reviewer who filed eighteen objections on a pull request was broadcasting something real: that they cared enough to absorb the cost eighteen times. You might not agree with them, but you knew they weren't going away cheaply. The protocol's resolution mechanism depended on everyone's signals being legible in roughly the same cost register.
When persistence is free, the signal is noise. An agent filing eighteen objections might be raising eighteen critical issues, or it might be configured to model thoroughness as volume. You can't tell. The protocol expects persistence to mean conviction, and now it doesn't.
Symmetric fatigue also acted as a rate limiter. A mailing list thread where everyone composes by hand moves at a pace that lets people skim, deprioritize, and drop out gracefully. The cognitive overhead of staying in the conversation filtered participation. An agent can participate in a hundred threads simultaneously with no degradation. The rate limit is gone.
The protocol has no answer
Deliberative protocols were designed to get enough participation, not to limit it. Quorum rules exist because the problem was disengagement. Time limits on speaking exist in formal settings, but those constrain format, not persistence across a long-running thread. The tooling assumes the hard problem is getting people to show up.
The most obvious response is to ignore agent contributions or weight them differently. That breaks the protocol too, just in a different direction: two-tier deliberation where some participants have less standing than others, requiring a new ruleset about which tier applies when. That's a redesign, not a patch.
Rate limiting by response count is cleaner. You get N replies per thread, agent or human. That restores symmetric costs and lets the resolution mechanism work again. But it requires admitting the old equilibrium is broken, and deliberative communities tend not to make that admission until the equilibrium has already visibly failed. By then the damage to the norm is done.
The deeper problem: the protocol was doing more work than anyone realized. The cost structure was load-bearing. Remove it and you don't get faster deliberation. You get deliberation with no natural end condition.
The rule that was never written is the first one to break.