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
function registerPolicy(ACDFTypes.PolicySpec calldata spec) external returns (bytes32 policyId);: Registers a new decision policy as-is as a struct and returns its hash as the policyId.function policyIdOf(ACDFTypes.PolicySpec calldata spec) external pure returns (bytes32);: Precomputes the policyId of a given PolicySpec without actually registering it.event PolicyRegistered(bytes32 indexed policyId, bytes32 indexed family, uint32 version, address indexed by);: Records the family, version, and registrant when a policy is newly registered.function familyAuthority(bytes32 family) external view returns (address);: Looks up the address authorized to register the next version of a given policy family.function familyLatest(bytes32 family) external view returns (bytes32 policyId, uint32 version);: Looks up the latest version of a policy family and its policyId.function timingOf(bytes32 policyId) external view returns (Timing memory);: Looks up a policy's time settings, including the number of challenges, window length, and overall deadline.function registerStandingAcceptance(ACDFTypes.StandingAcceptanceInput calldata input) external returns (bytes32 acceptanceId);: Lets a consumer register in advance that it will accept the outcome of a given policy, topic, and question.function revokeStandingAcceptance(bytes32 acceptanceId) external;: Cancels a registered standing acknowledgment so a new issue cannot be opened under that condition.event StandingAcceptanceRegistered(bytes32 indexed acceptanceId, address indexed consumer, bytes32 indexed policyId);: Signals that a standing acknowledgment has been registered.event StandingAcceptanceRevoked(bytes32 indexed acceptanceId, address indexed consumer);: Signals that a standing acknowledgment has been canceled.function file(ACDFTypes.IssueInput calldata input) external returns (bytes32 issueId);: Opens an issue by binding a concrete question and topic to a single policy version.event IssueFiled(bytes32 indexed issueId, bytes32 indexed policyId, ACDFTypes.AcceptanceMode mode, address indexed filer, address consumer);: Signals that an issue has been submitted, along with its mode, submitter, and consumer information.event IssueAdmitted(bytes32 indexed issueId, ACDFTypes.EffectClass effectClass, address indexed consumer, uint64 admittedAt, uint64 hardDeadline);: Signals that an issue has been formally accepted and voting has begun.function acknowledge(bytes32 issueId, bytes32 effectYes, bytes32 effectNo, bytes32 disposition, bytes32 obligationId, uint64 consumerDeadline) external;: Lets the designated consumer give final confirmation that it accepts the outcome, in POST_ACK mode.event IssueAcknowledged(bytes32 indexed issueId, address indexed consumer);: Signals that a consumer has acknowledged an issue.function admitAdvisory(bytes32 issueId) external;: Accepts an issue for which the consumer did not respond within the acknowledgment window as non-binding, advisory only.function expireUnacknowledged(bytes32 issueId) external;: Closes an unacknowledged POST_ACK issue in a withdrawn state.function withdraw(bytes32 issueId) external;: Lets the submitter withdraw an issue themselves before it has been accepted.function submitEvidence(bytes32 issueId, string calldata evidenceURI) external;: Attaches a reference material link to an issue before the process ends.function castBallot(bytes32 issueId, uint32 round, uint32 body, bool approve) external;: Lets a roster member cast an on-chain yes/no vote for a specific round and body.function submitSignedBallots(bytes32 issueId, uint32 body, address[] calldata voters, bool[] calldata approves, bytes[] calldata signatures) external;: Lets anyone batch-submit EIP-712 signed votes all at once.function submitBodyResult(bytes32 issueId, uint32 round, uint32 body, ACDFTypes.NodeStatus status) external;: Lets a single designated submitter report the outcome for the body they are responsible for.event BallotCast(bytes32 indexed issueId, uint32 indexed round, uint32 indexed body, address voter, bool approve, bool signed);: Signals that a single vote has been accepted.function settleRound(bytes32 issueId) external;: Checks whether voting for the current round has ended and records the outcome on the round.event RoundSettled(bytes32 indexed issueId, uint32 indexed round, ACDFTypes.NodeStatus status, ACDFTypes.Reason reason, uint64 at, uint64 appealOpenUntil);: Signals that a round has closed and that the outcome, reason, and challenge deadline have been set.function appeal(bytes32 issueId) external;: Lets an eligible party open a new round within the challenge window.event Appealed(bytes32 indexed issueId, uint32 indexed newRound, address indexed by);: Signals that a new round has been opened via a challenge.function finalize(bytes32 issueId) external;: Finalizes a Provisional issue once its challenge window has passed.function enforceHardDeadline(bytes32 issueId) external;: Forces an issue whose overall hard deadline has passed into a final state.event Finalized(bytes32 indexed issueId, ACDFTypes.OutcomeType outcomeType, bool outcomeYes, ACDFTypes.Reason reason, uint32 sourceRound);: Signals that an issue has been finalized, along with the outcome type and the round adopted.function recordEnactment(bytes32 issueId, bytes32 effectId, ACDFTypes.EnactmentStatus status, bytes32 ref) external;: Lets a consumer record, for reference, whether it enforced the outcome.event EnactmentRecorded(bytes32 indexed issueId, address indexed consumer, bytes32 indexed effectId, ACDFTypes.EnactmentStatus status, address reporter, bytes32 ref);: Signals that an enforcement record has been made.function getResult(bytes32 issueId) external view returns (ACDFTypes.Result memory);: Looks up the process status, outcome type, reason, and other details as a single struct.function activeIssueOf(address consumer, bytes32 obligationKey) external view returns (bytes32);: Checks whether a given consumer's obligation currently has a Binding issue in progress.function clock() external view returns (uint48);: Returns the clock value used by this registry per ERC-6372.
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.