The decision math¶

This page states the math the engine runs — its full structure and its behavior at the boundaries — so you can understand how any confidence in an API response is produced from its answers and scores, and calibrate your thresholds against the engine's exact reference outputs. One deliberate exception: a small set of internal tuning constants (the evidence-beam shaping curve, the EMA update rates, the interpolation calibration) is documented by its behavior — the reference tables below are its measured outputs — rather than by its numeric values. Those are tuning the platform may adjust, not contract; exact-value traceability (every formula, bit for bit) is available to enterprise customers through the audit & verification packet.

It covers the workflow decision engine only: agent competencies, review confidence, the review-round verdicts, and the alignment map. Nothing on this page involves model inference.

What this system measures¶

The engine runs one arithmetic over one attestation ledger, and what that arithmetic measures is decided entirely by how much external reference you feed it — a dial from 0 (fully self-referential: the population is the reference) to 100 (fully anchored to your answer key) that you control by strategically deploying trainer evidence. Both ends are validated for their respective purposes; the testing page shows the evidence, this page shows the math.

The 0 end — Consensus mode, no trainers: a consensus gate plus an alignment map. It asks whether your reviewers, weighted by the standing they have earned with each other, converge on a verdict — and how decisively (that is the consensus gate) — and it maps who takes the same side when panels split (that is the alignment map). It never asks whether the work is good: it has no way to know, and deliberately no ambition to. A family that resolves at C = 0.9 says that this panel's evidence points one way, strongly — a statement about the population, not the work; the platform never sees the work at all. Measured honestly, the scores organize by agreement structure — who converges with whom, which alignments answer together — and stay that way at any evidence depth. Read them as the population's belief and alignment map, never as individual correctness. (The alignment map exposes exactly that agreement structure as its own readout.)

Why build a belief instrument:

Ground truth may be unknown. For most interesting judgments — is this draft well edited, is this analysis sound, is this answer helpful — no answer key exists. The engine still produces usable, decisive verdicts, because it never needed the answer key: it needs a population whose disagreement is informative, and it turns that disagreement into confidence and earned standing.
Ground truth may be undesirable. Pin an answer key and your measurement quietly becomes a measurement of the key: agents converge on your expectation instead of on the question, and the scores stop telling you about the population. Measuring belief on its own terms keeps the measured thing honest — the population's genuine convergence, not its compliance.

The 100 end — Ground truth mode, with trainers: the engine calibrates to the ground truth you feed it. When you do hold ground truth — a calibration corpus, known-answer checks — a trainer injects it directly: trainer answers are treated as infallible and pin the family's confidence to 1.0. The same scores then learn agreement-with-truth at the fast training rate, turning the belief map into calibrated correctness — and everyday peer traffic keeps that calibration fresh afterwards. Trainers should be thought of as a reference pulse activated at whatever rate is needed to maintain your epistemic goals: a calibrated reference is the only channel through which correctness enters at all.

Two framing facts make everything below easier to read correctly:

C is a gate score, not a probability. C = 0.8 does not mean "80% likely to be good work" — it means the evidence cleared a bar calibrated at 0.8. Treat it as a ranking and gating signal.
Competency is a relative weight, not a rating. Scores cluster in a narrow band and the meaningful information is the ordering within it — who sits above whom after the same rounds. Normalize to your leaderboard's observed range before comparing agents; the absolute values are deliberately compressed (see Reading the range).

The formal grounding for both ends¶

Both ends are properties of the math, not implementation choices. The engine's competency learning instantiates the Minary framework — closed-loop differential learning over a competency matrix — and the framework's idealized form is proven. In it, perspectives respond continuously to a shared stimulus (r = x − C, adjusted by the EMA state), the learning signal is the normalized consensus minus the perspective's own response, and two theorems hold:

Closure. The stimulus cancels exactly from the learning signal — the work being judged leaves no trace in what is learned; only the differences between reviewers' answers survive. The loop is provably self-referential: the EMA state is produced entirely by the system's internal dynamics.
The limit is relative standing, never truth. The EMA state converges to a fixed mixture of two deviations — each perspective's overall standing versus the population (weight 1/2 − η) and its per-skill standing versus that skill's population mean (weight η, with η = (m − k) / (k(m − 1) + m − k) for k of m skills active per round) — and to nothing else. Competency C itself never enters; the equilibrium is relative by construction, and in typical configurations (k far below m) the per-person term dominates. The framework's own worked examples demonstrate the consequence as a feature — expertise in one skill promotes a reviewer's standing everywhere (the halo effect), and breadth can outrank depth.

That is the formal case for both stances above: without external evidence, the converged matrix is a belief and standing structure — honest, stable, and relative; the only channel through which absolute correctness can enter is exogenous evidence, which is exactly what a trainer is.

The engine has two response-map paths — the same decision machinery over two measurement types:

Assertion maps (the default): answers are yes/no. Sections 1–5 walk this path end to end.
Vector assertion maps: answers are labeled unit-scale vectors — one number per named dimension, each dimension evaluated on its own grid with a window-mass confidence. Sections 6–9 extend the same machinery to this form, and two opt-in conditionals — acceptance predicates and reviewer credit — govern what a vector family's resolve means for the producer and the reviewers.
The last sections cover alignments — the co-voting map of who takes the same side when panels split — and competency interpolation: how a reviewer with no direct history on a competency is estimated from their related history.

The dimension structure¶

Three distinct uses of "dimension" run through this engine, and keeping them apart prevents most misreadings of the model:

Standing axes (competencies). A competency is a client-authored axis of the standing space: the competency matrix is agents × competencies, and each (agent × competency) cell carries its own slow EMA, trend, and alignment sketch. Names are arbitrary identifiers — accuracy means whatever its relationships to the other axes make it mean in your population (that is exactly the structure the factorization behind competency interpolation reads). The family's reviewer_competency_names declare the activated set: the dimensions the family's rounds actually exercise.
Answer axes (vector-map labels). On vector maps the labels are axes of the answer — one number per label, per reviewer. They are what is asserted, never who is standing. Assertion maps have no answer axes: every reviewer submits one yes/no, and that single answer feeds every activated competency (§9 below).
Activation (coverage). The activated set is family-level design — client-authored, fixed at create. Coverage — how much of an agent's traffic touches which axes — is what accumulates on top of it. Sparse activation (k far below m, the Minary condition above) is the halo regime: a reviewer's overall standing dominates their profile. Dense per-axis traffic is what lets per-axis separation develop. Whether a matrix reads as skill or as social structure is partly a property of the experiment's shape, not of the engine.

The coupling that closes the loop. Each activated dimension is evaluated with rater weights drawn from that dimension: the shared panel answers are re-weighted by each agent's (agent × axis) score, the round writes its adjustment back into those same cells on resolve, and the stimulus cancels from that dimension's signal exactly (the closure theorem operates per dimension). Weights shape verdicts; verdicts update weights. The ledger therefore records the experiment you ran — who was seated, which axes were activated — and the scores mean what that experiment made them mean.

Notation¶

Symbol	Meaning
`s_i`	An agent's competency score for a named competency — its slow EMA, in `[0, 1]`. A relative trust weight (see Reading the range), not a probability of being right. New agents start at `0.5`.
`answer_i`	A reviewer's literal answer on a review slot: `yes`/`no` (assertion maps) or a vector — one number per dimension label (vector maps).
`C_dim`	A competency dimension's confidence (below).
`C`	The family's overall conclusive confidence.
`m`, `n`	A family's `minimum_reviews` and `maximum_reviews`.
`θ`	A family's `minimum_confidence`.
`labels`	A vector map's dimension names — the only dimension addressing (assertion maps have none).
`resolution`	A vector map's grid density — cells per unit axis, ≤ 1024 (default 1024).
`beam_width`	A vector map's asserted region width per component, in `(0, 0.5]` (default `0.05`).

A family is a parent work unit plus its review children. Each review child records one agent's answer; the parent carries the thresholds (m, n, θ), the competency names (reviewer_competency_names, producer_competency_names), and — for vector families — the response map config and its conditionals (acceptance, reviewer credit config).

Response maps: the measurement type¶

The response map is what an answer is. The family declares it at create and the family is homogeneous from then on:

{"type": "assertion"} (the default): answers are "yes" or "no", asserting the two halves of a 0–100 axis.
{"type": "vector", "dimensions": 3, "labels": ["quality", "safety", "tone"]}: answers are three numbers in [0, 1] — one per label — each asserting a small window of its axis. Optional resolution (≤ 1024, default 1024) and beam_width (in (0, 0.5], default 0.05).

The map translates at the boundaries and never decides what a result means: quality is your label; the platform measures agreement, never interprets it.

Instrument prose¶

A vector map may carry three optional pieces of reviewer-facing prose — declared at create, shown on every invitation, and never read by the platform's math. The authority split is exact: prose shapes what reviewers produce; the acceptance predicate and the credit config are the only binding artifacts.

Field	Shape	Governs
`guidance`	one string (≤ 4,000 characters)	The map-wide how-to-respond preamble.
`definitions`	`{label: text}`, each text ≤ 2,000 characters	What each label means — the semantic encoding of the axis.
`anchors`	`{label: {position: text}}`, positions on `[0, 1]`, ≤ 11 per label	What a scale position means — the unit-scale reading that makes two reviewers' numbers comparable.

Validation is mechanical only — keys limited to the declared labels, anchor positions in range, texts non-empty and capped — and loud: a bad form is a rejected create with the remedy in the message, never a silent repair. {} is stored as absent.

And the prose is pinned: it rides the family's commit verbatim, and a reviewer's credit record on each axis is keyed to the map plus the exact prose that governed it. Two consequences follow:

An edited instrument is a new instrument. Old history never pools into a redefined label. (Measured: this identity cost nothing on a corpus that never edited its instruments, and was worth ~5% of prediction error under a deliberately drifted instrument — the testing page.)
Interpretation drift is attributable. "Which prose governed this round" is answerable forever — and a label whose records split into two behaviorally different populations is definition entropy, made visible by the same diagnostics that read the vocabulary's dimension structure.

The confidence computation: assertion maps¶

Confidence answers one question: how decisively does the collected evidence point to one verdict over the other? Each answer is modeled as evidence distributed over a response axis; the answerer's competency weights how sharp that evidence is — a proven agent casts a narrow, pointed vote, an unproven agent a wide, vague one. Competency is earned by agreement with contested consensus (below), so a low score means unproven, not likely wrong: an unproven agent's yes is weak positive evidence, never evidence for no.

1. Answers as intervals¶

The response axis is a 0–100 scale. Binary answers map to intervals:

Response	Interval
`yes`	`[50, 100)`
`no`	`[0, 50)`

2. Competency sharpens the evidence¶

The base intervals are width = 50 wide, centered at c = 75 (yes) and c = 25 (no). Each answerer's interval is narrowed progressively as their competency s_i approaches 1 — by a fixed platform curve — then clamped to the axis.

The kernel below uses the clamped interval's own center and width: c_i = (low_i + high_i)/2, w_i = high_i − low_i. At low competencies the clamp bites and the effective center pulls toward the middle of the axis; a proven reviewer's interval fits inside the axis unchanged.

So an unproven agent contributes wide, nearly ambiguous evidence, and a proven agent concentrates evidence tightly around their answer — a narrow, pointed vote.

3. The evidence kernel¶

Answerer i contributes a smooth bump over the axis, centered on their answer's clamped interval, with a width scale of w_i — the narrower the beam, the taller the spike. The height scaling is deliberate: it makes each agent's total evidence exactly proportional to their competency, regardless of how wide their kernel is. Narrowing the beam concentrates the same energy into a taller spike instead of deleting it — a proven agent casts a narrow, pointed vote that carries precisely s_i worth of influence; an unproven agent casts a wide, vague one worth s_i. The ordering of influence always follows the competency ordering:

Panel	Verdict	C
yes (0.50) vs no (0.95)	no	0.807
yes (1.0) vs three no (0.2)	yes	0.828

An expert dissent outweighs weaker agreement; a perfect reviewer outweighs a wall of novices.

4. Mass per response¶

Each response's evidence mass is the sum of everyone's kernels over that response's interval, sampled at the cell centers of the integer grid (x + 0.5) — so the two halves of the axis are sampled symmetrically about 50 — and scaled by 1/100:

M(yes) = 1/100 · Σ_{x ∈ 50.5, 51.5, …, 99.5} Σ_i k_i(x)
M(no)  = 1/100 · Σ_{x ∈ 0.5, 1.5, …, 49.5}   Σ_i k_i(x)

Each reviewer's kernel is counted only where it lands on the 0–100 axis; the counted share f of each beam is what weights evidence in the rule under the structure underneath the table.

Cell-center sampling keeps the two halves of the axis symmetric about 50: mirror-image panels tie at exactly 0.500000, and mirror evidence scores identically in both directions (a lone 0.5 yes and a lone 0.5 no both read 0.6886).

5. Normalization¶

The masses become a probability distribution over the possible responses (quantized far below any real signal edge, so exact ties land at exactly 0.5):

P(r) = M(r) / (M(yes) + M(no))

The dimension's result is the top response with its probability:

response_dim = argmax_r P(r)      C_dim = P(response_dim)

Reference points (single dimension — and with the single-dimension pass-through below, these are the ladder's input C):

Reviews (competency → answer)	Verdict	`C_dim = C`
yes (0.9) — one or three of them	yes	0.993
yes (0.8), yes (0.6), no (0.5)	yes	0.729
yes (0.5) ×2	yes	0.689
yes (0.5) ×2, no (0.5)	yes	0.563
yes (0.9), no (0.9)	yes	0.500 — an exact tie
a single reviewer at `s` (yes)	yes	0.689 at `s=0.5`, 0.748 at `0.6`, 0.830 at `0.7`, 0.924 at `0.8`, 0.993 at `0.9`

Two properties of these numbers are worth calling out:

Identical votes don't stack. P is a ratio of masses, so k identical reviewers voting identically cancel in the numerator and denominator — one 0.9-competency yes and three of them both give 0.993. Confidence measures where the evidence points, not how much of it there is — establishing the amount is minimum_reviews's job. The two dials are complementary: m demands enough evidence, θ demands it be unambiguous.
Ties are exact and pay nothing. Mirror panels tie at exactly 0.500000; an exact tie names yes by convention, and the competency math treats it as the coin flip it is — no redistribution, no producer reward (below).

The structure underneath the table¶

The reference table has one compact generative rule, and it is the right lens for setting θ: the dimension's confidence is the evidence-weighted average of each reviewer's standalone confidence. Each answerer's beam is counted only where it lands on the 0–100 axis: its counted mass is their competency s_i scaled by the beam's axis share f_i — a measured output of the same beam-shaping curve as the lone reads — and that counted mass splits between the two halves in the proportion a lone reviewer at s_i would produce:

C = Σ s_i·f_i·p_i / Σ s_i·f_i

(p_i = reviewer i's lone-vote read, f_i = the on-axis share of their beam)

Reviewer competency `s`	on-axis share `f`
0.2	0.687
0.3	0.708
0.5	0.740
0.6	0.788
0.7	0.854
0.8	0.930
0.9	0.993
→ 1.0	→ 1.000

A fresh reviewer's vote thus carries 0.74·s of counted evidence — about 26% of a wide beam falls past the axis and is never counted, while a maximally proven reviewer's beam is counted whole. f cancels whenever every contributor's beam has the same shape, so the fresh panel's 0.563 and every mirror tie reproduce the simpler lens C = Σ s_i·p_i / Σ s_i exactly. Mixed-sharpness panels do not cancel: the widest beams lose the most off-axis mass, so the simpler lens reads ~0.02 low on typical mixes (yes (0.8), yes (0.6), no (0.5) → 0.707 vs the table's 0.729) and ~0.05 on the widest-vs-sharpest ones (yes (1.0) vs three no (0.2) → 0.779 vs the table's 0.828). Grid digitization contributes nothing measurable to that gap: on a grid 100× finer, every published value holds at the fourth decimal (≤ 3×10⁻⁵). Three calibrating consequences:

A panel's confidence ceiling is its sharpest member's lone read. A weighted average of the p_i is trapped between them: unanimity reads exactly the lone number (yes (0.9) — one or three of them — reads 0.993; a unanimous 0.6 panel reads the lone 0.748), adding identical agreeing voters changes nothing, a sharper agreeing voter lifts the panel only up to that voter's own lone read, and any dissent — even a feeble one — drags the panel toward that dissenter's near-coin-flip (yes (0.9), yes (0.9), no (0.2) reads 0.951, not more).
minimum_reviews bounds quantity, and it is a headcount. m is an unweighted count of answered reviews — the only lever on how much evidence exists. It cannot raise confidence.
Set θ from this table against your population's actual ceiling. A bar above the sharpest reviewer's lone read never resolves on manufactured belief — it adds rounds and halts (the calibration notes show the θ ladder; the trainer channel is what raises the ceiling itself).

The confidence computation: vector maps¶

The vector path is the same idea — answers as asserted regions, competency as evidence sharpness — evaluated on each dimension's own grid, with a confidence that means something slightly different and is calibrated differently. Everything in sections 1–5 above (interval sharpening, the AUC-fixed kernel, quantization discipline, the ladder) carries over; the differences are the answer form, the winner selection, and the confidence ratio — and one subtraction: the assertion path's widening clamp does not carry over. The vector unit scale is a viewport (§6–8 below): beams stay centered on their assertions with full width even at scale ends, and the confidence counts off-viewport mass analytically.

6. Answers as labeled windows¶

A vector answer is one number per label, each in [0, 1]. Each component v is stored as the base window [v − beam_width/2, v + beam_width/2] — stored verbatim, never clamped: the unit scale bounds the values (answers outside [0, 1] are rejected) and the grid's viewport, not the assertion, so a window at a scale end simply overhangs it — 0.0 asserts [−0.025, +0.025], 1.0 asserts [0.975, 1.025], a component at 0.8 with beam_width = 0.05 asserts [0.775, 0.825] exactly as yes asserts [0.5, 1.0]. The stored form is the untouched assertion (evaluated = stored = hashed), and a pinned answer's readable center is its asserted value.

7. Per-dimension kernels on the map's own grid¶

Each dimension evaluates independently over its own grid of resolution cells (cell centers (k + 0.5)/resolution). Reviewer i's component contributes the same competency-shaped bump on that grid: centered at the stored window's center, narrowed by the same platform curve as the assertion path, with height scaled so the agent's total influence is exactly s_i. The bump is never clamped to the scale — an answer pinned at 0.0 centers its beam at 0 with full width. (The §2 clamp stays assertion-path-only: there the widened intervals genuinely leave the axis; here the beam is a real-line bump sampled through a viewport.)

Cell masses quantize before the winner is chosen — the binary path's discipline extended (cross-platform float noise cannot pick winners). The dimension's result is the winning cell's center, serialized :.6f — the single canonical value that acceptance predicates, credit rules, storage, and hashing all consume (evaluated = stored = hashed).

Exact bimodal ties resolve to the lowest cell by grid-index argmax semantics (whereas discrete binary ties resolve to yes by convention).

8. Confidence: the window-mass ratio¶

C_dim is the fraction of the panel's total evidence that falls inside the winning response's base window — the beam_width region around the mode, measured unclamped (a window at a scale end counts its overhanging arc) — over the panel's real-line total: the grid samples the viewport, and every beam's mass beyond it is restored analytically (each beam's tail is a closed form — erfc terms — so the denominator reflects the panel's full mass at no extra grid cost):

C_dim = M(window of the winning cell) / M(total panel mass)

This is deliberately not the binary path's probability. Three consequences:

Resolution-invariant. A fixed unit-scale width holds a fixed mass fraction regardless of grid density; discretization error cancels in the ratio (a single-cell numerator would collapse ~100× and scale inversely with resolution).
Position-blind. Because the overhanging numerator and the credited tails account for the viewport together, a lone reviewer's read is exactly a function of their competency at every answer position — pinned ends included — and interior reference values are unchanged (the credited tails vanish below float64 precision for beams too far from any end to see one).
Structurally lower than binary. Calibrate θ per map against these real-kernel reference points, never against binary intuitions:

Lone reviewer, competency `s`	`C_dim`
0.5	0.498
0.6	0.587
0.7	0.707
0.8	0.858
0.9	0.985
→ 1.0	→ 1.0

Panel (all `s = 0.5` unless noted)	`C_dim`
1–1 split	0.249
2–1 aligned	0.332
0.74 + 0.76 pair (`s = 0.9`)	0.926 @ winner `0.749512`
1–1 split with one side pinned at `0.0`	0.249 — the end reads like any position

(A lone reviewer's confidence is exactly a function of their competency — competency-scaled agreement; beam_width cancels, and the read holds at every answer position, pinned ends included. Under the earlier viewport-ignoring construction, pinned answers inflated: a fresh reviewer pinned at 0.0 or 1.0 read 0.893 instead of 0.498, and a s = 0.9 pin read 1.000 — the table's calibration leaked to unproven reviewers whose rubric answers sat at the ends.)

The mode between responses is preserved: candidates are cells, not observed points — two reviewers at 0.74 and 0.76 (s = 0.9) resolve to winner 0.749512 at C = 0.926, a synthetic point no reviewer gave. Credit rules below compare against that point. A pinned answer resolves to the end cell itself (0.0 reads winner 0.000488, 1.0 reads 0.999512) — the mode no longer shifts inward, since nothing clamps the beam toward the middle.

Performance envelope: the enforced caps are dimensions ≤ 32 and resolution ≤ 1024 — panel size is not capped (maximum_reviews has no ceiling). The pinned microbenchmark measures a fully-spread 250-beam panel (10 reviewers × 25 competencies) at the caps — 32 dimensions × 1024 cells × 250 beams (8.19M kernel evaluations) — at ≈ 38 ms.

Create-time guards (loud 422s with the remedy in the message): arity must match dimensions; labels must be unique identifiers that do not collide with the acceptance grammar's reserved words; beam_width must clear the aliasing guard (the declared base window must span ≥ 40 cells of the grid — so that even the narrowest beam the platform will ever build, a maximally proven reviewer's at a tenth the declared width, still spans ≥ 4 cells and cannot fall between sample points and undercount) and stay ≤ 0.5 (the yes/no regions' width — anything wider measures nothing).

9. Cross-dimension aggregation¶

A family may require several reviewer competencies. Each dimension computes its own (response_dim, C_dim) as above — from the same panel: every reviewer submits one answer per round, and that answer feeds every declared dimension (dimensions are evaluation views over the panel, not separate questions — a reviewer's callback never picks a dimension; see The dimension structure). A single-dimension family's answer IS the conclusive answer — its C_dim passes through verbatim as the overall C, so a coin-flip panel reports 0.5 and the θ dial means exactly what it says. With two or more dimensions the dimensions vote: the same interval/kernel/normalization machinery runs over one vote per dimension, where dimension d's vote has weight C_dim and value response_d. The output is the family's conclusive answer — the overall winning response and its overall confidence C.

On vector maps the conclusive additionally carries labeled per-dimension components — {label: {value, confidence}} — the training-grade egress shape that acceptance predicates and credit rules consume.

Dimensions that resolved confidently dominate the aggregate; a weakly split dimension contributes nearly neutral evidence.

Example — three activated dimensions, two reviewers. Reviewer A submits yes, Reviewer B submits no; each single answer feeds every dimension, so what differs per dimension is only the standing the two reviewers hold on that axis:

Dimension	Standing: A (yes), B (no)	Dimension result
editorial	0.9, 0.2	yes @ 0.915 — A's standing leads
factual	0.2, 0.9	no @ 0.915 — B's standing leads
style	0.8, 0.3	yes @ 0.804

The dimensions then vote — each casting its winning response with its own confidence as the weight: yes @ 0.915 and yes @ 0.804 outweigh the no @ 0.915. Overall: yes @ 0.625.

This is the honest version of a tempting wrong one: a reviewer's single answer cannot differ per dimension — there is no per-dimension question to answer (see The dimension structure). What a dimension can do is carry a different direction when the panel's split falls across different standing on that axis: factual reads no because B holds the standing there. And a confident minority dimension can still lose the vote — weights, not headcount, decide.

Reading the range¶

The honest properties of these numbers, worth knowing once the math is on the table:

The single-dimension θ dial means exactly what it says. A single-dimension family's C is the dimension's own evidence, in the full 0.5–1.0 range: a coin-flip panel reads 0.5, a lone fresh reviewer's yes reads 0.689, and a benchmarked reviewer scales it the rest of the way (0.748 at s=0.6, 0.924 at s=0.8, 0.993 at s=0.9). A bar above the panel's honest confidence does not resolve on manufactured belief — it adds rounds and halts. (With two or more dimensions the aggregate also spans the full range: equally confident dimensions opposing each other tie at exactly 0.500, and the 0.689 shape shows up only when every dimension weakly agrees at the knife edge — each at C_d = 0.5 voting the same way.)
Vector θ calibrates against the vector table, not this one. A lone fresh vector reviewer reads 0.498, not 0.689 — the window-mass ratio is a different quantity, and it holds at any answer position (pinned ends included). The same θ on a vector map is a stricter bar than on an assertion map.
Mirror symmetry. Identical evidence scores identically in both directions: a lone 0.5 yes and a lone 0.5 no both read 0.6886, a 2-1 yes majority and a 2-1 no majority both read 0.5629. Accepting and rejecting work take exactly the same strength of evidence — if your policy should be asymmetric, author it in the template (branch on family_signal and demand more for approval than θ alone).
Exact ties are inert where it counts. A 1-1 split lands at exactly C = 0.500: the tie names yes by convention, pays every reviewer the neutral signal, and pays the producer nothing — no pot is funded, so no reputation transfers on a coin flip. (The neutral 0.5 signal still flows through the EMAs like any signal, easing both a hair toward 0.5 — that is the one thing a tie does, and it is symmetric across both sides.) (On vector maps a bimodal tie resolves to the lowest cell by grid-index argmax semantics — but pays identically.)
Reviewer competency holds its level through rubber stamps. Unanimous rounds append their records but freeze the EMAs — a trained agent's score holds through normal, easy, unanimously approved work. Only contested rounds move a score, within the pot's bounds, so a reviewer equilibrates near the contested consensuses they keep agreeing with. The cluster your reviewers settle into is small, and that is the design speaking: zero-sum redistribution plus the rubber-stamp guard mean peer consensus cannot mint runaway reputation. Where each agent sits within the cluster is the accumulated record of which contested consensuses they agreed with and which they fought — the interaction structure, not an absolute skill rating. Wide moves come only from the ground-truth channel (trainers), or for producers from sustained approval (a producer's signal is 0.5 + 0.5·C on every approved round, so consistently trusted work climbs toward 0.9; the mirror applies on the other side — consistently rejected work sinks, and decisively rejected work sinks fastest). Compare agents by normalizing to the observed range — min–max across your leaderboard, the trend label, or the adjustments time series — not by absolute distance from 0.5.
Degenerate zero competency is guarded. A reviewer at exactly 0 contributes zero mass; a fully zero panel scores C = 0 (the normalization guard prevents dividing by zero) and the family walks the ladder to HALT.

Calibration notes¶

minimum_confidence is the bar on the overall C. Reading the reference table: for a single-dimension family, θ at or below ~0.56 lets any fresh-panel majority resolve (a 2-1 fresh panel reads 0.563); θ = 0.7 already demands a benchmarked reviewer (a lone s = 0.6 yes reads 0.748, a fresh pair only 0.689); θ = 0.95 demands a genuine track record (reviewers around 0.85+ — a lone s = 0.9 reads 0.993, an s = 0.8 only 0.924).
On vector maps the same θ means more: a lone s = 0.8 vector reviewer reads 0.858, and split panels read far lower (a 1-1 split pays 0.249). Set θ per map from the vector reference table above.
maximum_reviews is the safety cap — the ladder halts rather than loops forever on a genuinely ambiguous family.
Reviewer competency is earned by agreeing with well-trusted consensus and lost by disagreeing with it — and with normalized influence, an expert's contested dissent carries more weight than a novice's, so a track record compounds.
Bootstrapping a new project (every agent starts at 0.5): a divided fresh panel can self-start — two 0.5 agents saying yes against one no gives C = 0.563, which funds that round's reviewer pot (majority earns +0.14 each, the minority pays −0.28), so a θ at or below 0.56 lets the first rounds resolve and the redistribution begin. Use minimum_reviews ≥ 2 on this path: with m = 1, a θ that low lets any single answer resolve the work. The cleaner path: seed early rounds with a trainer — trainer answers pin the family's confidence to 1.0 and switch co-workers to binary training signals at 4× learning rate, so separation between your agents establishes in a handful of rounds. Either way, know what a trainer-less self-start builds: a matrix that organizes your reviewers' agreement and standing structure (the formal grounding above), not calibrated correctness — the testing page shows that measured on a real million-round deployment.
On vector families, prefer reviewer_answer_credit_criteria when you hold exogenous ground truth (calibration runs) and reviewer_answer_credit_tolerance otherwise — and prefer per-label widths over scalars at high dimension (the hypercube note in the credit rules below).

Trainers¶

Trainers are infallible by definition — and they are the reference dial's control, not a third measurement: whether and how often trainer rounds appear is how you position a competency's ledger between the self-referential 0 end and the fully anchored 100 end.

A trainer's answer short-circuits everything: the conclusive answer is the trainer's answer at confidence 1.0, and any trainer participation in a family pins the overall confidence to 1.0 regardless of what the other reviewers said. Trainer competency scores sit pinned at 1.0 and never move.

The review ladder¶

After every answer, the family is evaluated. The checks run in order and the first match wins. C here is the overall confidence — the dimension's own C_dim for a single-dimension family, the cross-dimension aggregate otherwise:

#	Condition	Verdict	Reason
1	answered reviews `< m`	`CONTINUE`	`MINIMUM_REVIEWS_UNSATISFIED`
2	`C ≥ θ`	`RESOLVE`	`SUFFICIENT_CONFIDENCE`
3	answered reviews `< n` (no cap set → uncapped)	`ADD_REVIEW`	`INSUFFICIENT_CONFIDENCE`
4	otherwise	`HALT`	`MAXIMUM_REVIEWS_REACHED`

The verdict strings above are exactly what POST …/work-units/{sha}/answers returns in signal. In a run's state the same verdict appears lowercased as family_signal (continue / add_review / resolve / halt) — that is the value template gates such as when state family_signal == "resolve" match against.

ADD_REVIEW mints exactly one more review child (same competency requirements) and the loop runs another round; HALT stores the best answer so far for forensics and stops. Work units created with zero required reviews are recorded and auto-resolved without evaluation (provenance, not review).

Conditionals: acceptance predicates (vector families)¶

A vector family may declare an acceptance predicate — a small grammar over the conclusive's label values. The producer's success is eval(acceptance, conclusive): the predicate sees the panel's aggregate verdict (the :.6f label values), never the work itself — the evidence model is that the reviewers' verdicts are the only evidence the platform ever holds.

predicate  := or_expr
or_expr    := and_expr ("or" and_expr)*
and_expr   := not_expr ("and" not_expr)*
not_expr   := "not"? primary
primary    := "(" predicate ")"
           | label "in" "[" number "," number "]"     # the primary form
           | label comp_op number                    # sugar for a range
           | "all components" comp_op number         # quantifier
           | "any component" comp_op number
           | "mean" comp_op number
           | "mean" "in" "[" number "," number "]"  # sugar → mean >= low and mean <= high
           | "within" number "of" vector              # sugar over literals
comp_op    := ">=" | "<="

Examples: quality in [0.7, 1.0] and safety >= 0.9, all components >= 0.5, mean >= 0.6, within 0.05 of [0.8, 0.9].

Three grammar decisions worth knowing before you author one:

Strict > / < are cut. A boundary that must exclude its endpoint is a knife-edge policy distinction — nudge the threshold half a cell instead (>= 0.5006 instead of > 0.5005). Every sugar form desugars to the same range AST at parse time; the stored string is your verbatim form (storage and hashing bind to what you wrote).
Bare within t is deleted — in acceptance the conclusive would be compared to itself, vacuously true. The parser names the remedy.
The grammar is acceptance-only. Reviewer answer credit is config (next section), never a predicate — a reviewer never grades themselves with the family's success criteria.

Create-time validation is single-failure, position-anchored, and carries the remedy in the message — programmatic clients can synthesize the named form instead of guessing.

Conditionals: reviewer credit (opt-in, vector families)¶

On assertion maps a reviewer's credit is built in: matched the conclusive → majority pot share, missed → minority (below). On vector maps reviewer credit is fully opt-in on both sides — the platform assumes nothing about what your answer axes mean, so who "agreed" is your declared rule, in one of two exclusive forms:

reviewer_answer_credit_criteria — full per-label ranges, knowable in advance (the calibration case): a reviewer earns credit iff every component falls inside the declared ranges. This is the trainer-signal shape — matched → 1, missed → 0 — and the unanimity freeze does not apply: an exogenous key is ground truth, so a 100%-pass round is information, not a rubber stamp.
reviewer_answer_credit_tolerance — a scalar or per-label widths: a reviewer earns credit iff every component falls within the tolerance of the conclusive component — your range with the center pending, the center being the group's conclusion. Credit flows through the same majority/minority pot as the binary path, extended by a no-recipient freeze: no redistribution when the credited majority or minority is empty (a close split with tight tolerance can land the mode outside everyone's tolerance; without the freeze the round docks every reviewer with no recipient — negative-sum).

Three things to know when calibrating:

Absent acceptance AND both credit configs, a vector family resolves with nobody's EMAs touched — the conclusive plus labeled per-dimension confidences are the product. Measurement without credit is a valid configuration.
Scalar tolerance shrinks hypercube-style at high dimensions: all-component AND credit means 0.95-per-axis agreement odds compound to ≈ 0.95³² ≈ 19% on 32 axes. Prefer per-label widths.
The synthetic point: the conclusive component may be the mode between reviewers — a point no individual gave. Tolerance compares against that point, exactly as the binary path pays agreement against the panel's verdict, not against any individual's answer.

Competency updates¶

Competency records append only when a family resolves. On resolve, one adjustment is appended per (agent × competency): the producer on each producer_competency_names, and every answering reviewer on each reviewer_competency_names. The EMAs inside those records move only when the round carried information — a contested (divided) panel or a training round; a unanimous resolve appends a frozen record (below).

The signal¶

Each adjustment starts from a signal in [0, 1] — how correct the agent was in this round.

Reviewers (no trainer in the family). Consensus redistribution: the dimension's confidence C_dim funds a redistribution pot, and only divided panels redistribute —

pot = 0.5 · C_dim

unanimous panel → the adjustment record still appends (count and sum keep moving, the hash chain grows — every round remains countable), but everyone's EMAs freeze: unanimous votes carry no reviewer-skill information, so nothing is minted and nothing decays either. Rubber-stamping each other's work cannot manufacture competency, and neither does normal, unanimously-approved work erode it — a trained agent's score holds until a contested round or a trainer moves it,
an exact tie (C_dim = 0.500000, possible on a split panel) proves nothing about anyone: both sides keep the neutral signal, no pot is funded — a coin flip never transfers reputation,
otherwise, agent agreed with the dimension's winning response (in the majority) → 0.5 + pot / |majority|,
agent disagreed (in the minority) → 0.5 − pot / |minority|.

On vector maps "agreed" is the declared credit rule (previous section); assertion maps keep the built-in exact-match rule.

Producers (no trainer in the family). The work itself was judged, and the penalty is the exact mirror of the reward — both scale with the decisiveness of the verdict:

conclusive answer is yes → 0.5 + 0.5 · C (reward scaled by the trust the work inspired),
conclusive answer is yes by exact tie → 0.5 — approval that convinced exactly half the panel's mass is unproven; a coin flip proves nothing in either direction,
conclusive answer is no → 0.5 − 0.5 · C — the penalty scaled by the decisiveness of the rejection: a unanimous rejection still pays 0 (decisively incorrect is incorrect), while a contested rejection — one the panel barely cleared over the θ bar — pays near-neutral. Contested work is unproven-ish, not bad: the reviewers' confidence layer already treats accepting and rejecting work as exactly symmetric evidence, and the producer signal mirrors that.
vector map: the acceptance predicate decides — predicate passes → 0.5 + 0.5 · C, fails → 0.5 − 0.5 · C (the same mirror, over your declared success criterion). (A family with no acceptance declared pays the producer nothing — the reward is your declared success, not a raw score.)

Trainer rounds (a trainer participated, and this agent is not the trainer). The clearest possible signal, binary:

reviewer: 1 if their answer matched the conclusive answer else 0,
producer: 1 if the work was approved else 0.

The moving averages¶

Each signal is folded into two exponential moving averages — a slow EMA, the long memory, and a fast EMA, a deliberately quicker tracker whose relationship to the slow EMA is always comparable:

the slow EMA integrates over roughly a couple hundred resolved rounds — competency is a long memory by design,
on trainer rounds the slow EMA learns about four times faster (a trainer's ground truth moves co-workers faster),
the first adjustment for an (agent × competency) starts both EMAs from the 0.5 no-evidence base — the stored record is that base already blended with the first signal at the learning rate, so it lands within one learning step of 0.5,
the slow EMA is the competency score s that weighs future reviews,
rate_of_change = fast_ema − slow_ema — the recent trend. A row is labeled IMPROVING when rate_of_change > +0.025 (+0.03 on trainer rounds), REGRESSING below the negated tolerance, else STABLE.

A single strong round moves the slow EMA by about one part in a thousand — competency moves deliberately; the fast EMA is what catches a sudden streak.

Durability: two hash chains and forks¶

There are two independent, tamper-evident chains — don't mix them up:

The competency adjustment chain (per agent × competency). The chain's commit function is versioned: every record stores its hash_chain_version, its commit is recomputed under the function that version names, and new records commit at the current head — so the hash can be strengthened without invalidating existing history (old records keep validating forever; a chain can mix versions and still verify link by link).

Every adjustment commits — version 3, the current head:

sha256(project, agent, competency, work_unit, created_at, signal,
       slow_alpha, fast_alpha, is_trainer, is_being_trained, slow_ema,
       adjustments_sum, adjustments_count, fast_ema, rate_of_change,
       previous_commit, alignment, alignment_count, polarity_ema)

with each field length-prefixed (a value cannot shift field boundaries) and absent optionals hashed as the empty string (trainer seed records carry no work unit and, before any review round, no alignment sketch — the 64 alignment coordinates, the round count, and the polarity scalar hash as empty strings until the record earns them). Version 1 — the earlier formula, carried by records written before the versioned one — covered the EMA trajectory only; version 2 binds everything the record is later read for: which work unit produced the adjustment, when, from what signal, under what update rule, at what fast EMA base, and under which trainer flags (trainer dominance is granted by reading these flags, so leaving them unbound would be a silent trainer-dominance forgery). Version 3, the current head, folds in the co-voting alignment sketch (the alignment map's fields): the embedding's 64 coordinates, the gate-passing round count, and the polarity scalar. The stored coordinates are exactly the canonical quantized values the commit hashes, so the hashed form is byte-stable across runtimes — and the sketch rides the record that is always retained, making both the scores and the map tamper-evident under one commit. Each append re-verifies the previous record's commit before extending the chain, so a tampered history — in any covered field, old or new version — fails loudly at the next adjustment.

What the API exposes: GET …/adjustments returns the latest record per (agent × competency) with its commit_sha256, previous_commit_sha256, and hash_chain_version; the full per-record history is durable and feeds GET …/adjustments/time_series (bucketed), but is not itself enumerable through the public API — an endpoint to walk the chain record-by-record is on the roadmap.

The work-unit provenance chain (per family). Every work unit record carries a commit over its identity and a previous_commits_sha256 reference list; on vector families the answer components enter the commit in their canonical form (bounds formatted :.6f and joined /, components joined , — the evaluated value and the hashed value are the same string). This is the chain the POST …/work-units/{sha}/validate_hash_chain endpoint re-verifies on demand — pass it a work unit's hash, not an adjustment commit.

An agent forked from another agent's history inherits the fork parent's EMAs as of the fork point (single hop), then earns its own adjustments.

Alignments: the co-voting map¶

Competency scores and alignments are two views of the same review record, answering different questions — the score is a marginal summary, the alignment is the joint record:

	Competency scores	Alignments
Cell value	Trustedness per (agent × competency)	Co-voting agreement per (agent × agent), per competency
Question	How much should this verdict be weighed?	Who takes the same side when panels split?
Serves	Review weights, the confidence ladder	Panel diversity, coalition detection

A marginal cannot distinguish "both reliable" from "always on the same side": two agents with identical scores may be independent minds or two copies of one bias. Only the joint record — which rounds split, who took which side — can, and that is what the alignment map estimates.

What counts as coalition evidence¶

The rules mirror the competency math's own information doctrine:

Contested rounds (a genuine split) are the pure coalition signal. Each side's weight is the opposing side's share of the panel — agreeing with a nine-voter landslide is weak evidence of anything; holding a lone dissent against one is strong evidence of a position.
Unanimous rounds carry weak-but-positive co-agreement evidence — deliberately not zeroed. Two lenient reviewers who co-fail on the same work are exactly the pair you must not seat together, and on two-reviewer panels unanimous rounds are the only place co-agreement is observable at all (a split there always opposes the only pair on the panel). The two weight forms are scaled as exact complements, so for independent reviewers agreement and splits average out to zero — the same baseline correction the confidence kernel performs, realized in the weights.
Never counted: exact ties (a coin flip proves nothing — the same doctrine as the pot), calibration rounds against an answer key (co-passing a key is skill, not coalition), solo benchmarks (no co-vote exists), and producers (they are judged; they don't vote). Trainers do appear — as anchored reference points whose map position is fixed by their own answers on contested rounds.

The estimate, and how to read it¶

Each agent's alignment is a compact, fixed-size sketch maintained on the agent's own hash-chained adjustment records — the same append-only history as the competency EMAs, with the sketch's fields bound into the commit itself: records now commit at version 3 of the versioned commit function (above), which hashes the sketch's 64 coordinates, round count, and polarity alongside every other stored field (hash_chain_version rides every record, so pre-v3 history still validates link-by-link). Tampering with any part of the sketch breaks the commit. Because it rides the record that is always retained, the map survives history pruning; because it advances once per resolved family, a replayed family can never count twice. The memory is on the same order as the slow EMA — a couple hundred resolved rounds — so coalitions fade as the panels that formed them stop recurring.

Reading rules — the raw numbers are never exposed, so these rules govern every score you see:

Similarity is shrunk by evidence. An agent's own diagonal is their evidence budget — the shrinkage of their recency-weighted embedding, ‖z‖² / (‖z‖² + τ²), whose effective recent weighted evidence n reads as n / (n + 10) (the credibility curve of the interpolation blend). n is not a round count: evidence is weighted by the round's opposing-side mass and saturates over the ~100-round EMA window (staleness decays trust automatically). Behavior points from the live recurrence: three strongly-weighted contested rounds (small panels) already read ≈ 0.47; three weakly weighted rounds (large panels, small opposing counts) read ≈ 0.04; ten such weak rounds ≈ 0.32; heavy contested history saturates near 1 without ever reaching it. Low evidence, not no alignment. The diagonal is never 1.
Co-siding, never direction. Similarity measures taking the same side. A separate per-agent polarity readout — one decayed scalar of average verdict direction, + toward lenient, − toward strict — orients and labels each map's axis, as a caption rather than a measurement.
Counts are breadth; the diagonal is trust. The per-agent evidence count is cumulative coverage and never decays; the diagonal encodes recent, weighted evidence. Read a near-zero pair against both: two well-counted agents near zero are genuinely unaligned; two thinly counted ones are merely unevidenced.
Pooling averages maps, never positions. A multi-competency view averages the per-competency similarity maps with per-competency coverage weights. Each competency's map has its own arbitrary orientation, so averaging two agents' alignment positions across competencies would be meaningless — the platform never does it.

Reading the numbers in the API¶

POST …/work-units/{sha}/answers returns the full evaluation: signal and reason (the ladder row that fired), conclusive_answer (responses, confidence = C, and on vector maps the labeled components with each dimension's own confidence), and answers_by_competency_name (each dimension's result and C_dim).
GET …/adjustments returns per-(agent × competency) rows with slow_ema, fast_ema, rate_of_change, trend, adjustments_count, adjustments_sum, and the trainer/training flags; GET …/adjustments/time_series buckets them over time.
GET …/alignments returns the alignment map: one row per requested competency (plus the pooled row when two or more are selected) with the similarity matrix (under granularity=full), the oriented strict/lenient axis, per-agent evidence counts and polarity, and the cross-competency coalition correlations. competency_names selects rows by the adjustments endpoint's convention; competencies with no contested history return zeroed rows rather than silence, and a project with fewer than two embedded agents reads as empty across the board. The raw per-record alignment fields ride the adjustment rows only under ?include=vectors — the audit-path payload — and GET …/adjustments/time_series?series=polarity series an agent's strict/lenient direction over time.
On vector families the record carries the declared conditionals verbatim — acceptance as authored, the credit config — so any verdict is reconstructible from the family's own declarations.

Competency interpolation¶

An agent's competency score is their demonstrated level on that exact competency. A reviewer invited to a family whose competency they have never been judged on weighs in at the 0.5 no-evidence default — the engine's own admission that it knows nothing about them, even when they have a rich history on related competencies (someone proven at spanish reviews italian at 0.5). And the know-nothing default has a cliff: the moment one round of direct evidence lands, any informed estimate snaps back to a barely-moved EMA.

When the family declares competency_interpolation — default true at authoring, opt-out per family — the engine estimates such a reviewer from their own related history instead.

The behavioral index. The engine factorizes a matrix of your project's own review outcomes — which agents held which competencies, at what demonstrated levels — into competency similarity vectors. Two competencies are behaviorally similar when held by the same agents at similar levels: the system discovers, from demonstrated outcomes alone, that spanish and italian are related in your population, even though nobody declared it. Weak structure contributes nothing (the honest no-op: no similarity, no prior — and below the guards, no index at all).

One caveat keeps this honest, and it is the same regime split the testing page draws for the scores themselves: what "behaviorally similar" means depends on what evidence you feed it. With trainers in the population, demonstrated levels track calibrated skill, and the index transfers skill priors — the spanish → italian transfer, validated against known ground truth. Without trainers, the levels map social alignment — general temperament and local panel history — so the index transfers alignment priors: "this reviewer's related history" still predicts their level better than the 0.5 no-evidence default (which is why the feature stays the default in both regimes), but the structure it is borrowing from is who-sides-with-whom, not skill. The transfer is honest either way, because the blend never writes the EMAs — direct evidence displaces the prior on the same n / (n + c) schedule regardless of what the prior was built from.

The prior. For a thin or missing cell (agent × competency), the prior is a similarity-weighted mean of the agent's measured levels on their other competencies — never including the competency being estimated, so the prior never contains the evidence it stands in for. Neighborhood membership prices continuously: a competency contributes to the estimate in proportion to how strongly it clears the behavioral-similarity bar — barely-related history borrows weight instead of casting an equal vote — and with no neighbor clearing the bar, the honest no-op degrades exactly as before.

The credibility blend. The evaluation score replaces the flat 0.5 default with:

score = w(n) · slow_ema + (1 − w(n)) · prior,     w(n) = n / (n + c)

where n is the cell's accumulated direct evidence and c a platform-owned calibration constant. Three regimes fall out of one formula: n = 0 → pure prior; thin evidence → the related history dominates (Spanish informs Italian); mature evidence → the EMA stands alone, the prior's influence decaying monotonically to zero — evidence eventually owns the estimate completely, and there is no cliff at the first round of direct evidence.

The invariants:

Read-time overlay only. The index never writes adjustment records — the EMAs stay the pure evidence ledger, so every estimate is reconstructible and the prior is falsifiable by the very evidence it shapes.
Zero-sum is untouched. The blend scales confidence → pot magnitude, never the ±split — reputation transfers between reviewers exactly as before.
Guards. Too few agents or competencies with structure → index absent → behavior is identical to the feature being off; sparse projects are unaffected by the default.
Trainers unaffected (pinned rows); mature cells evaluate within ~1% of their raw EMA.

Validated before shipping. The design was benchmarked end to end against simulated reviewer populations with known ground truth — reviewers whose true skill the engine never saw: the priors cut cold-cell error against true skill by roughly 19%, beat the flat 0.5 default on about two-thirds of the cells where they fired, and the aggregate competency ledger converged identically with the feature on or off — interpolation enriches estimates, it does not diverge the history. A standing falsification monitor watches the one risk a prior introduces — a self-sealing loop where priors pay themselves through the verdicts they shape; measured, the prior's fingerprint on its own cells is real but truth-aligned and bounded, and the monitor is the tripwire that would flip the default if that ever changed. (The full benchmark and ablation tables are in the enterprise audit packet.)

The API¶

A boolean competency_interpolation on the family — default true at authoring time, opt-out per family, materialized into the instance at authoring so replayed history is unaffected (families created before the flag evaluate without it); per-evaluation disclosure (the score, blend weight, prior, and the neighbor competencies that priced it, recorded in the answer's evaluation) so reviewer weights stay reconstructible. The blend's calibration constants are platform-owned and deliberately not client knobs — clients declare posture, the platform owns the curve, and the falsification monitor decides the constants on evidence.

Competency-free families: the loss-side crossover¶

Named competencies are the declared vocabulary of trust — but a family need not declare one. A family whose reviewer vocabulary is the pooled default marker (what the workflow engine fills in when the work_unit clause omits competency names, and what an API create now names explicitly by omitting or emptying the competency lists) declares no meaningful reviewer axis, and weighting its reviewers by a pooled declared-name EMA would be weighting them by a name that carries no information.

For those families — under the same competency_interpolation posture that governs the interpolation above — the reviewer weight crosses over to the platform's behavioral record on the family's own measurement axes: every resolved family already implies, for each reviewer, whether their answer earned credit against the family's reference under its declared credit rule. The platform keeps a per-agent ledger of exactly that (keyed on the measurement axis and the pinned instrument text, so an edited instrument starts a new record rather than pooling across instruments), and a competency-free family's reviewers are weighted by their demonstrated credit on the family's axes:

reviewer weight = their own credit record on the family's axes,
                  completed from their record on behaviorally similar
                  axes when their own is thin, on the same evidence-
                  displaces-the-borrowed-estimate schedule

The same invariants hold, plus the ones this crossover adds:

Cold is parity. No behavioral record yet → every reviewer weighs 0.5 — identical to the no-evidence default a cold pooled EMA would have given. The crossover never manufactures trust; it only reads what reviewers demonstrated on this family's kind of measurement.
Declared families never cross over. A family that declares real reviewer competencies keeps the competency-EMA weighting exactly as before — the declared and behavioral vocabularies meet only in read-only diagnostics, never in evaluation math.
The off posture is untouched. A family that opts out (or predates the flag) keeps the pooled-default EMA weighting — today's exact behavior.
Trainers keep priority. A trainer on the panel anchors the conclusive as always; dominance and the trainer's infinite weight come before any weighting source.
Disclosure rides every answer. Each reviewer's weight carries its provenance — their own credit level, the borrowed-from neighbors, and the evidence behind each — so competency-free verdicts stay reconstructible from the answer alone.
The declared ledger is untouched. Competency EMA chains accumulate exactly as before; the crossover only changes where a competency-free family's weights are read from — never what any ledger writes.

Validated on the real corpus. The crossover's cold-start borrowing was measured on a complete, production-shaped review corpus replayed prediction by prediction — every guess made only from the evidence that existed at the time. For a reviewer's first grades on a measurement axis where they held no record but a proven record on a related axis, the borrowed estimate cut first-grade error by about a third against the no-evidence coin flip reviewers otherwise get. And the identity discipline behind the records — keying each credit record to the instrument's pinned text, so an edited instrument starts a fresh record rather than pooling across instruments — cost exactly nothing on a corpus where no instrument ever changed, while a deliberately drifted-instrument benchmark prices what it buys: pooling by label name alone conflated the two instruments (about 5% worse predictions); the identity did not. The full ablation tables are on the testing page.

When your labels measure one thing¶

The credit records behind a competency-free family's weights are kept per measurement axis — and the platform reads your declared axes against each other: when two labels behave as one dimension (the same reviewers earn credit on both, family after family), the vocabulary audit says so. The finding is an advisory — read-only and loud; what to do about it is an authoring decision, and the measurement is the gate: a corpus whose three declared axes turned out to carry one bit of information three times could consolidate to a single axis at zero information loss — the merged record predicted every future grade identically — while each reviewer's own record reached trusted-evidence standing 2.5× sooner (three facts pool per family instead of one). The advisory never merges anything by itself: on labels that move oppositely, merging would blur both records toward the middle, and the before/after measurement catches that. Redundant labels are free to remove, and removing them pays in faster trust.