## Working

**STATE.problem**: Design how to collect and combine employees' private estimates so the aggregate tracks reality, and people keep reporting honestly over time. Failure = gaming toward desired numbers, OR people withdraw because reporting feels risky.

**meta_model (lift)**: A principal wants to extract dispersed private signals from self-interested agents and pool them into an estimate that beats naive averaging. Agents' payoffs depend on *what they report* (project owners are optimistic, some fear an honest pessimistic number is held against them, some echo perceived leadership preference). The principal controls the questions, the scoring, who sees what, and how the aggregate is computed and used.

**Verbs run (verb — why):**
- match (search_prime, domain-stripped meta-model) — anchor to catalog. Top hits: incentive_compatibility / mechanism_design, wisdom_of_the_crowds, information_cascade/herding/groupthink/conformity, signaling, optimism_bias, calibration.
- match (search_by_facets, 6 structural facets) — oblique problem with several structures at once. Per-facet surfaced the aggregation engine (wisdom_of_the_crowds top of facet 4), the punished-honest-signal facet (winner's-curse/signaling/bias), the authority-conformity facet (herding/conformity), and the scoring facet (calibration/measurement-decoupling). Confirmed the four load-bearing structures.
- salience-rank — order by load-bearing relevance: (1) wisdom_of_the_crowds owns the *quality* claim and its failure modes; (2) incentive_compatibility owns *honest reporting as best response*; (3) information_cascade owns *correlated-signal collapse / reputational echo*; (4) calibration owns *scoring against revealed truth + per-person bias correction*.
- prune — drop signaling, adverse_selection, agency_problem (redundant once IC carries truth-telling), epistemic_justice (framed, not operative).
- get_prime ×4 (incentive_compatibility, wisdom_of_the_crowds, information_cascade, calibration) — pull structural signatures, tensions, anti-signatures.
- compose — relational model: nodes {agents w/ private signal+bias, principal, elicitation rule, scoring rule, visibility policy, aggregator}. Edges: visibility→correlation (cascade T4/T6), scoring→truth-telling (IC alignment), aggregation→bias-survival (WOTC T3), publication→independence-loss (WOTC T4).
- evaluate-fit (gate) — WOTC anti-signature: correlated inputs + shared bias survive aggregation; so the design must *manufacture independence* and *measure/strip bias*, not collect more answers. IC anti-signature: off-path gaming + reliance on enforcement; so truth must be the agent's own best move, not policed. Cascade anti-signature: visible early/authority choices override private signals; so hide peers' answers and the leader's view until commit. All pass under the design below.
- lower — instantiate in the firm: blind collection, accuracy-scored reputation currency, decorrelation, bias de-meaning, sealed leadership view.
- reconcile — resolve scoring-vs-participation tension: score only on accuracy revealed later, never on optimism/pessimism direction; protect honest pessimism explicitly so reporting stops feeling risky.

COST: ~6 operations, ~20k tokens.

===RECOMMENDATION_BEGIN===
Treat this as an estimation system whose accuracy comes from the *structure of the collection*, not from finding the smartest forecaster. Three things do the work: collect signals independently, make honest reporting the reporter's own best move, and score against reality after it arrives. Get those right and the aggregate beats polling; get them wrong and you are averaging an echo.

**Collect blind, then combine.** Ask each person privately for a number and, crucially, never show them anyone else's answer, the running average, or what leadership expects, before they commit. The single biggest destroyer of accuracy is people anchoring on each other or on the boss's known preference: once answers correlate, a hundred estimates carry no more information than one, and the system looks confident while converging on a shared error. So elicit in isolation, lock the answer, and only then reveal the pool. Deliberately recruit estimators with different vantage points (someone close to the work, someone outside it, someone who has shipped similar things) because diversity of error is what cancels out. Combine with the median or a trimmed mean, not the simple average, so a single extreme self-serving number cannot drag the result.

**Ask for ranges, not points.** Require a low, likely, and high figure (e.g. a 10th / 50th / 90th percentile). This surfaces who actually knows versus who is guessing, makes optimism visible as suspiciously narrow high-confidence bands, and gives you a distribution to aggregate rather than a single anchored number.

**Make accuracy the only thing that pays.** Keep a private, running accuracy score for each estimator, settled only when the truth is later known (the project ships, the cost lands, the date hits or slips). Reward calibrated accuracy and nothing else: never reward optimism, never reward agreeing with leadership, never reward the *direction* of an estimate. Reporting that a launch will slip must score exactly as well as reporting it will land, if the slip was real. Over time, weight each person's input by their demonstrated track record, so the people who are actually right gain influence and the people who report what they wish were true quietly lose it. This is what makes honesty the rational move: the only way to win the score is to predict reality.

**Protect the honest pessimist, structurally.** People stop giving real answers when a bad number feels like a confession. Break that link by hard rules, not exhortation. The raw individual estimates are seen only by the small team running the aggregation; managers and project owners see the combined result and their own private accuracy score, never who said what. Estimating must be formally walled off from performance review and headcount decisions — an honest pessimistic estimate can never be cited against a person or team, and you should say so explicitly and then never violate it, because one breach teaches everyone to round their numbers up forever. Owners should not be the sole estimators of their own projects; their number is one input among several outside views, never the answer.

**Correct for known bias before combining.** Track each estimator's historical lean. If someone is reliably 20% optimistic on timelines, de-bias their input by their own track record before it enters the pool. This removes a person's systematic tilt while keeping their genuine signal — and it removes the *shared* tilt too: if everyone runs optimistic, naive averaging preserves that optimism with false confidence, so anchor the aggregate to how past estimates of this kind actually turned out.

**Close the loop, openly.** When the truth lands, publish what actually happened against what the pool predicted, and quietly update everyone's accuracy score. The feedback is what turns guessers into calibrated forecasters over months, and it is what keeps the system honest as conditions drift. Recalibrate the bias adjustments periodically; a track record from a stable year may mislead in a turbulent one.

**Operating rule.** Collect every estimate in private and as a range, before anyone sees others' answers or leadership's view; combine the diverse, de-biased inputs with a median weighted by each person's revealed accuracy; reward only correctness scored against what later actually happened, never the direction of the number or agreement with anyone; keep individual answers confidential and firewalled from evaluation; and when reality arrives, score it, show it, and re-weight. If you are ever tempted to let people see each other's numbers first, reward an optimistic forecast, or use someone's estimate against them — don't; each of those quietly converts an informative aggregate back into a poll of what people think you want to hear.
===RECOMMENDATION_END===
