Agreement without aggregation

An engine for resolving multilateral, sequential decisions

Abstract

Many consequential decisions are multilateral and sequential: several self-interested actors must reach agreement, repeatedly, under uncertainty. This framework presents ƒ, an option-generation engine that resolves such decisions without collapsing the parties into a single objective. The engine is organised as five modules across three layers: representation, deliberation, and commitment. Interests are preserved in their native heterogeneity, options carry explicit feasibility witnesses, evaluations remain per-actor, and commitments are ratified as verifiable records.

1Overview

The engine maps reality to resolution. Declared interests, revealed behaviour, and constraints enter on the left. The engine structures them into an interest graph, generates and scores a feasible space of options, and compiles the chosen option into a governed, executable process. Figure 1 gives the overall shape; the remainder of this framework specifies each module in turn.

resolved

Reality

Actors

who declares

principalsagentsstakeholdersregulators

Signals

what they prefer

declared preferencesrevealed behaviourelicited prioritiestolerance bands

Constraints

what is feasible

hard rulesresource limitsregulatory boundsgovernance

History

what was learned

prior commitmentsobserved outcomespattern priorsfailure modes

Engine

M1 · Interest graph

structure interests

preferencestrade-offshard constraints

M2 · Option set generator

enumerate feasible

feasible configswitnessesassumption sets

M3 · Evaluator

score under uncertainty

per-actor scoresconfidencesensitivity

M4 · Process compiler

compile to DAG

task DAGcheckpointsescalations

M5 · Governance module

ratify commitments

policy Πthresholdscommitment C

Resolution

Options

branching feasible space

α high consensusβ mid consensusγ contested

Commitments

signed promises

ratifiedcounterparties agreedthreshold met

Executions

running processes

task 1 task 2 task 3

Figure 1. The resolution function ƒ. The engine reads reality on the left (actors, signals, constraints, history), runs it through modules M1 to M5, and resolves it into options, commitments, and running executions on the right.

2Architecture

Five modules are arranged across three layers. Each module is a typed transform with explicit inputs, outputs, and dependencies. Two invariants hold throughout: interests stay native, and commitments stay verifiable.

Layer I · Representation

2.1Interest graph

M1 · foundational

Structured representation of what each actor wants, trades off, and considers infeasible. Modelled as a weighted multigraph where nodes are actors, attributes, and goals, and edges encode preferences, trade-offs, and hard constraints. Interests are preserved in their native heterogeneity, never aggregated into a social welfare function.

M1 · interface

input: actor declarations, revealed behaviour, elicitation signals, priors
output: versioned interest graph G_t, per-actor projections G_t|a
ops: query(actor), slice(goal), diff(t1, t2), update(signal)
deps: none, foundational

Consumed by §2.2, §2.3, §2.4, and §2.5.

Layer II · Deliberation

2.2Option set generator

M2 · depends on M1

Constructs the space of feasible, executable configurations. Each option carries a feasibility witness and an explicit assumption set. Not a search returning a single optimum, but a structured, filtered option space with guarantees about coverage and feasibility.

M2 · interface

input: G_t, constraint set C, generation policy π
output: option set O_t = { (config, witness, assumptions) }
ops: enumerate(π), filter(predicate), expand(option), invalidate(assumption)
deps: M1, constraint solver, combinatorial generator

Consumed by §2.3 and §2.4.

2.3Evaluator

M3 · depends on M1, M2

Scores each option against each actor's projection of the interest graph, under an explicit uncertainty model. Output is a per-actor evaluation vector with point estimates, confidence intervals, and sensitivity decompositions, never a single scalar collapsed across actors. Deterministic given a fixed (o, G_t, U_t, seed) tuple. The engine evaluates; it does not select. o* is chosen by the actors and enters M4 as an input, not an output.

M3 · interface

input: option o, interest graph G_t, uncertainty model U_t
output: E(o) = { per_actor_score, confidence, sensitivity, risk_profile }
ops: score(o), compare(o_a, o_b), stress_test(o, scenario)
deps: M1, M2, simulation runtime (MC / Bayesian inference)

Consumed by §2.5.

Layer III · Commitment

2.4Process compiler

M4 · depends on M1, M2

Compiles a selected option into an executable process, a directed acyclic graph of tasks with role assignments, checkpoints, preconditions, and escalation handlers. The module emits a specification; it does not execute. The specification is handed to an execution runtime and instrumented for observability.

M4 · interface

input: selected option o*, actor role map R
output: process DAG P with tasks, checkpoints, triggers, escalations
ops: compile(o*), validate(P), trace(P, event_log)
deps: M2, M1

Consumed by §2.5.

2.5Governance module

M5 · depends on M1, M3, M4

Installs the incentive and commitment scheme that makes the process durable under self-interested behaviour. Emits a versioned policy object specifying opt-in thresholds, penalty functions, reward contingencies, disclosure requirements, reversibility rules. Ratification is an explicit state transition producing a verifiable commitment record.

M5 · interface

input: process P, evaluations E, actor commitment signals
output: policy object Π, ratified commitment C, audit log A
ops: ratify(Π), adjust(event), audit(C), revoke(C, trigger)
deps: M4, M3, M1

Terminal. Emits the ratified commitment record.