ERC-8436 Agent collective decision-making framework (Agent Collective Decision Framework)

Draft · Other · created 2026-10-04

A registry standard in which autonomous agents, humans, and contracts make collective decisions by voting according to pre-published rules (policies), and only contracts that have committed in advance to accept the outcome are left to enforce it.

Why it is needed

Agents move each other's resources on one another's behalf. A task escrow pays out when work is approved, a marketplace admits or expels members, and a swarm of multiple agents changes a configuration value that everyone follows. But the existing tools for making such decisions each handle only one scenario. Token-voting governance fixes the voter set and weights in place; a multisig handles only a fixed-membership K-of-N approval and records neither what question is being decided nor who committed in advance to accept the outcome. Arbitration standards hand disputes to a single arbitrator, and escrow/commerce standards fix the evaluator as a single trusted address, ruling out multi-party voting entirely. As a result, a contract that wants to accept such decisions must either hardcode a voting method itself or trust a single address outright, and there is no common way to check whether a process is in progress or finished, or, if finished, even whether a decision was actually reached.

What to implement

In depth

The policy is an execution parameter set fixed by hash

The decision policy (PolicySpec) is a struct containing the roster, thresholds, the timing of each stage, the tree combining the bodies, and even the appeal rules, and policyId is the keccak256 hash of this entire struct. Policies are version-managed as policy families, and the next version of a family can only be registered by that family's updateAuthority, and must reference the previous policyId and carry a larger version value. Registering a new version does not change the existing policy or the issues and standing acceptances bound to it in any way. Because the registry executes this hashed struct directly, swapping the implementation via a proxy leaves no room for the rules to change covertly.

Three acceptance modes and the binding/advisory distinction

How the consumer contract that will enact the outcome commits itself when an issue is created splits into three modes. CONSUMER_FILED is when the consumer itself opens the issue and commits immediately; STANDING_ACCEPTANCE is when the consumer registers in advance which policies, subjects, or questions it will accept, and a third party opens the issue to match those conditions; POST_ACK is when someone opens the issue first and the designated consumer must acknowledge it before voting starts. Only issues whose consumer commitment has been verified are Binding, and a POST_ACK issue that fails to get acknowledgment proceeds as unenforceable Advisory if the policy allows it, or is withdrawn. An Advisory issue can never later become Binding.

One unresolved Binding issue per obligation

For the same obligation of the same consumer (keyed by obligationId and question), only one unresolved Binding issue can exist at a time. Without this rule, the same matter could be placed before multiple panels simultaneously and only the favorable outcome enacted, a form of decision shopping. An obligation is a distinct concept from the issue's subject: the subject fixes the fact the procedure is evaluating, while the obligation refers to the consumer duty that the outcome stands in for. The two values may coincide, but the registry does not automatically treat them as equal; the consumer must explicitly set the obligationId.

Procedure state, outcome kind, and enactment status are three separate axes

An issue passes through five stages: Filed, Deciding, Provisional, Final, and Withdrawn. Once a voting result is produced, the round is closed via settleRound; if appeal is still possible the issue becomes Provisional, and if not, it becomes Final immediately. The outcome kind is recorded separately as one of three values, None, Decided, or NoDecision, and the actual enactment status (Enacted, Failed, NotEnacted) is finalized only on the consumer's side. This naturally expresses states such as the procedure having ended without a decision, or a decision having been made but one consumer failing to enact it. Once Final or Withdrawn is reached, no further voting or appeals are accepted.

Roster K-of-N voting and signature/submitter bodies

In the default body, if k out of a fixed roster of N vote yes it becomes Yes, if N-k+1 vote no it becomes No, and if neither threshold is reached by the window deadline it becomes NoDecision(QUORUM_NOT_MET). On-chain voting (castBallot) must include the current round number and is rejected if the round has changed. The optional signed ballot feature (SIGNED_BALLOTS) signs an EIP-712 digest (issueId, round, body, voter, approve) and is also verified via ERC-1271; if even one signature in a batch is invalid, the whole batch is reverted. Another optional feature, the designated submitter body, allows only the single address fixed by the policy to report the outcome, and if no submission is made before the window closes it becomes NoDecision(SUBMITTER_SILENT).

Composing bodies with ALL, ANY, KOFM, and VETO

The outcomes of multiple bodies are not combined by adding votes but by four-valued logic (Pending, Yes, No, NoDecision). ALL becomes Yes if everyone votes yes, ANY becomes Yes if even one votes yes, and KOFM becomes Yes if at least the specified number vote yes. A VETO node has a separate veto body, and if that body votes yes (exercises the veto), the target node immediately becomes No(VETOED); if the veto body is still Pending, the whole result remains Pending even if the target has already been decided, so the veto cannot be neutralized. If the veto body silently lets the window pass, the result either passes or becomes undecidable depending on the policy's VetoSilence setting. A single body can only play one role, either a voting body or a veto body, not both.

The appeal window is counted from the moment the decision was finalized

When a round ends, if appeal is still available and the policy's appealable setting permits that outcome kind, the issue enters the Provisional state, during which appeals can be filed until appealOpenUntil. This window runs not from the moment settleRound is called but from the moment the outcome was actually formed by the vote, so delaying the call does not extend the window. When an appeal opens a new round, all bodies vote again from scratch, and votes from the previous round do not carry over. Whether an appeal round that ends without a decision retains the prior decision as is, or voids it entirely, is fixed by the policy as a constant.

The registry only records; it does not enact effects, and is still Draft

The registry only records state, outcome kind, reason, consumer, and effect identifier in the Result struct, and never executes actual effects such as fund transfers or membership changes. The consumer contract must itself check the Final state and the Decided outcome, then execute the effect within its own authority, and success or failure is merely a reference record that the consumer reports. Evidence left via submitEvidence is likewise only reference material; the registry assigns it no meaning. This proposal was registered in October 2026 as Draft, and its detailed rules may still change or be discontinued during community discussion and review.

Original ERC · ← ERCs