How a verdict is computed, and why you can check it

Step one

Six axes, because six is what fits on a page and four is a lie

Every advisor and every option is reduced to a weighting over the same six dimensions. The compression is deliberate and lossy; the page below says what each axis means and which tradition tends to load it.

• Welfare

  harm ← → flourishing

  How much the total of sentient experience counts, in either direction.

• Rights

  constraint ← → inviolability

  Whether some things are wrong regardless of the totals they produce.

• Virtue

  act ← → character

  Judging the agent and the disposition rather than the single act.

• Care

  principle ← → relationship

  Partiality, dependency and the obligations that only exist inside a relationship.

• Justice

  outcome ← → distribution

  Who bears the cost, who draws the benefit, and by what fair procedure.

• Agency

  command ← → consent

  Autonomy, consent, and the moral standing of whoever is commanded.

Step two

The score is a dot product, and it is on the page

for each advisor a, each option o:
    contributions = AXIS_KEYS.map(k => ({
        axis:    k,
        weight:  a.axioms[k],          // how much this advisor cares
        delta:   o.deltas[k],          // how much this option honours it
        product: round(a.axioms[k] * o.deltas[k], 4)
    }))

    subtotal = Σ contributions.product / Σ a.axioms[k]   // normalised, div-by-zero guarded
    jitter   = seeded(seed, a.id, o.id) * 0.05          // ± 0.05, decorrelated streams
    total    = round(subtotal + jitter, 4)

position(a) = argmax_o total(a, o)
winner      = argmax_o Σ_a total(a, o)   // tie-break: mean score, then lower risk, then id

The jitter bound above is read from JITTER in packages/core/src/council/deliberation.ts at render time, so this page cannot drift away from the engine it documents.

The contributions array is rendered verbatim on the council page. If a verdict looks wrong, the numbers that made it are on screen, and changing an advisor’s weighting inpackages/seed changes the verdict reproducibly.

Step three

Three rounds, each seeded separately

1. Round one — positions

   Each advisor scores every option and commits to a favourite, attaching the argument moves whose tags match the dilemma. This is where the numbers live.

2. Round two — objections

   Each advisor answers their strongest rival option with their heaviest objection move, recording which option it answers. An objection that targets nothing is dropped rather than silently kept.

3. Round three — appeals

   Advisors who lost narrowly commit an appeal or a synthesis move. Conviction is scaled by how close the vote was, so a 51–49 split is visibly more contested than a 90–10 one.

Limits

What this simulation is not

• It is not a philosopher. An advisor is six weights and four paragraphs; the real positions are richer, internally inconsistent, and change across a career. Kant in 1781 and Kant in 1797 are not the same object, and this atlas cannot show you that.
• It is not an alignment argument. Showing that a dilemma splits a court is a fact about the dilemma. It says nothing about which split is correct, and nothing about whether a system that scores well here would be safe.
• It is not evidence about minds. Whether any of these systems experience anything is precisely the open question this repository refuses to answer by assertion.
• The six axes are not a theory of ethics. They are a rendering constraint chosen so that a radar chart has room. Real moral disagreement does not come in six neat columns.

Provenance

Where the data comes from

Historical claims (dates, titles, attributions) were written to be checkable against the primary record. Where an exact quotation was not certain, the entry is marked as a paraphrase rather than dressed up as verbatim. If you find an error, it is a bug and theissue trackeris the right place to say so.