Floor producer — design & quality study

The build spec for roadmap §1, off the back of the production diagnosis. The diagnosis proved where conversation quality breaks; this is the machine that fixes it. The producer is one function — f — that reads a rich signal vector and emits the staging. Status: v0 deterministic baseline built + A/B-measured; v1 the trusted smart f (v1p / v1f) shipped to production 2026-07-03 (v1p default for new rooms) and quality-studied; v2 per-user memory + v3 a trained policy sketched. Design rewritten 2026-06-26; quality study run 2026-06-29 (Part 9).

What the diagnosis proved

We pulled all 80 production rooms and scored the 39 real conversations (full report). Four findings:

• Too long. Median host reply ~314 words; the one-line "concur" is never used. Length is the pervasive tax.
• Too agreeable. 40% of non-lead bubbles add no new angle — paraphrase and re-affirm.
• The conflict dial barely works. extreme delivers ~⅓ of the friction it promises — and the heat that does exist goes host→human, not host↔host.
• A few gestures worn to death (one cigarette ×60). First filed as a persona-authoring fix — but our own re-examination overturned that: the worst beats are runtime-manufactured (e.g. 0 profile mentions), unreachable by authoring, and the floor's length budget empirically zeroed them (the monologue room they live in disappears). So it's partly the producer's job after all.

The load-bearing conclusion: three of the four are staging, not voice. Voice and character fidelity are good (users said so). The single writer just stages the room badly — and can't fix itself. That is exactly the gap an exogenous producer fills.

The producer's whole job is a single function: a high-dimensional signal vector in — your engagement, your explicit asks, how invested you are, the substance, the room's structure (solo or panel), the phase — and the staging out. We trust a smart model with all the signals and let it decide. No taxonomy in the path.

No boxes — a manifold

The earlier design tried to sort each conversation into one of seven named "modes." That's the wrong primary abstraction, and one real production room proved it (Carrie, below). The deepest way to say why:

The engine

So the engine is one call: signals in, staging out. Nothing is forced through a discrete bottleneck on the way.

Mode & intent are readouts — generated last

f still names what it did — a mode ("this reads as deep self-work") and an intent ("she wants a rigorous assessment"). But these are labels read off the decision, for your eyes and the logs — not steps in it. And the order matters: in one autoregressive call, what's generated earlier conditions what comes later, so generation order is the causal graph. Put the label first and the staging anchors on it (the old gate, smuggled back in). Put it last and it can only describe.

The firewall & the confer

The panel already deliberates — the backstage <confer> is the one mind working out what to say. The producer doesn't fight that; it sits upstream. The line that keeps it a router, not a co-author:

Since there's no taxonomy to maintain, the real engineering becomes plumbing the signals into f. It can only be smart about what it's shown. The vector:

What f reads

"Cheap" vs "model" is honest here: explicit-asks/investment/roster/structure/history are parse-or-free; engagement, substance, phase are model judgments — the headline sensor (engagement quality) is one of them, not free.

Entrain to engagement, not keystrokes

The one sensor that earns its keep first. The naive rule — "match the user's length" (entrainment) — is a trap: it would clamp a deeply-engaged user who fires short, sharp probes. The fix is to read engagement quality (substance + trajectory), not raw message length:

So intent owns the ceiling, not the keystroke count: a short-but-sharp probe in a deep session keeps the reply long. That's the concrete mechanism behind "let the substantive turns breathe." (Caution: short-sharp-escalating is also the signature of distress — same surface, opposite correct response. The read must route distress to the safety floor, not "push harder.")

Carrie — the case that forced this

A real production room (梁宁 · 自我探索, solo): the user fires 8–98字 probes and gets 900–1886字 of rigorous analysis back, for 18 turns — escalating depth, explicitly asking "你不要安慰我，以面试官的角度客观评价," pushing back, never "太长." She is clearly satisfied; the long replies are the value.

She's emotional·converge — Vent's coordinate on the old grid — but wants the opposite staging (generous + challenge, not minimal + warmth). The grid would mis-serve her. And within her single session, the staging swung wildly by the turn's ask:

Multiple humans in one room

The product's defining case — but the way to serve it is not a concurrent-fairness optimization haunting every turn. The room is slow-paced and turn-batched: human messages queue and drain together into one turn, and that turn usually holds exactly one human. That collapses the problem — multi-human is a within-turn question, and across turns it's just a sequence of mostly-single-addressee turns, each handled fresh by reading who actually spoke.

So the design still owes three things — but each is smaller than it first looked:

• A per-human read — but only within a batch. When a turn does carry N messages, f reads each asker's trajectory separately; when it carries one (the common case) the read is trivial. (v0 used to entrain length to the concatenated batch — it summed and over-served; fixed: it now keys the lead cap on the longest single message, so a solo turn is unchanged and a batched turn no longer inflates. A true per-asker read still waits for v1.)
• An ADDRESSEE in the staging — for the rare batched turn. When two humans land in one turn (A "short," B "deep"), the per-speaker call-list already expresses it natively — "host1 → answer A briefly; host2 → give B the rigorous version." The genuinely hard multi-human case is real but rare, and the tool for it already exists — it was just pointed at the wrong problem (continuous fairness instead of within-batch allocation).
• A silent human is a use case, not a debt. The common group room is one or two askers plus quiet observers, and that's healthy and intended — silence reads as satisfied-by-default, not abandonment. f owes no fairness move to drag a lurker in; an organic turn-to ("C, you've built one — what do you think?") is an optional warm gesture when it fits, never an obligation. Pestering a happy observer is the failure, not leaving them be.

The room has furniture — and f didn't know

The toolbox steps (T1 clock, T2 tally…) gave the hosts real objects they operate with a tag mid-reply: a die, a board, an envelope, a circle, a ballot the server counts, a wall clock. Nothing in f's brief or prompt ever mentioned them. So a turn whose whole point was an act got staged as if it were a line of dialogue — and the manner cue, being the last and most specific thing the panel reads, won.

Four distinct ways the directive killed the act, all read verbatim off the logged [STAGING] line:

A fifth, subtler one: the tightest length tier (≤40字, 不解释, 投完就停) leaves no budget to both ask the question aloud and emit the tag, so the tag is what gets dropped.

The gap was never English — it was the soft ask

The English cell asked "Let's put it to a vote: Thai, pizza, or ramen?" and the Chinese cell asked 「投个票：爬山还是看电影？」. One is a proposal floated to the group; the other is an order aimed at the host. Nothing had ever separated the language from the phrasing. This crossover does — same seed, same room, same options, only the verb phrase moves:

Nor is it grammatical mood in general: the Chinese hortative 「我们投个票吧」 held at 17/20, and the softer 「要不投个票？」 at 14/20. English let's is the severe case because it names no actor at all — and the panel reads itself out of the room. The failure transfers across tools and gets worse, not better, on the clock: "Let's take five minutes to think quietly" armed 0/20.

Re-measured after the merge with the language law（which rewrote every tool exemplar as an English-first pair, landing on main the same day）, baseline = a9bd67f, same paired method: en vote 27% → 70%（p=0.0017）, held-out wording 13% → 53%（p=0.0022）, zh vote 90% → 83% and en clock 83% → 93%（both n.s.）, pooled 53% → 75%（p=0.0007）. The fix carries over intact. One observation, offered as an observation and not a finding: the baseline for en clock read 83% here against 63% before the merge, and en vote 27% against 20% — consistent with the exemplar pairs helping a little on their own, but the two runs are an hour apart on an instrument whose drift is this size（see the method note）, and no arm was run to test it. Measuring the language law is its own paired run, and it has not been done.

Method note, and the reason these numbers are trustworthy. Arms are no longer run back-to-back and pooled — the earlier session's spread (the same config returning 7/20, 10/20, 13/20, 13/20 and 15/20 inside one hour) is big enough to swallow the effect it was hunting, and drift landing inside one arm's window is exactly what pooling cannot fix. rooms-dev/_fp_tools/paired.py alternates the arms in short blocks, round after round, and compares only within rounds; the arm is applied in-process, so a switch cannot race the workers. It matters: the same baseline cell read 10% at one hour and 37% at the next. Held-out discipline: after v560's contamination trap (an exemplar whose options mirrored the probe's ask scored 12–15/20; de-contaminating it dropped the cell to 6/20), no wording used in the acceptance cells appears anywhere in the FP brief or the SP.

Why not make f emit a rigid 6-field lever vector? Because most of it doesn't need to be structured. The rule:

Five dimensions f sets through the directive. The mechanics below were validated building v0; in v1 they become intent-driven instead of blanket.

Length — an envelope, not a number

The defect was never "too long" globally — it was uniform ~300-word walls, no variance. Length is a computed envelope: a band the reply lands inside, that slides with the user's investment (entrainment) and wobbles turn to turn so it never metronomes.

The unit wears two hats. The CJK build taught the rule: a model cannot count its own 字 (it ran ~2.3× over a 字 budget, but hits a sentence count cleanly). So 字 is the producer's internal ruler; the model is only ever shown a sentence range.

The ceiling is intent-set, not fixed. Users often want length (an analysis, a deliverable). So the cap is a function of intent, and a starting ladder — sentences emitted, 字/words as the internal cap:

Participation & contention

Two levers ride on who-speaks. Silence — who doesn't speak — is the cheapest quality move there is (sitting out never needs fabrication), and the thing one mind won't do to itself. Contention is the structural fix for the broken conflict dial: give two hosts the floor to actually contend (an M·M shape), the host↔host friction the diagnosis found missing.

Question-back is the same friction turned on the user. On an explicit ask to be challenged or grilled, f can stage the panel to interrogate instead of answer — Socratic (withhold the answer; return a sharper question) or red-team (go at the plan) — with one host opening the game in voice and naming the way out. It rides the existing manner slot: a stance, not a new mechanism. Entry is user-initiated only (typed now, an opt-in cue later); any ask for the straight answer ends it — the producer never imposes it.

Punch — on scarcity

Told "one line," the model returns filler ("Exactly", "说得对") — the #1 pain in a small bubble. But making every short line a punch is its own flatness (nonstop zingers read as a writers' room). Punch lives on scarcity.

Holding the ground — anti-sycophancy

The sharpest form of the agreeable failure: the hosts get led by the human's opinion, validating whatever's asserted. The deepest lever flips the order of reasoning so the human's lean can't anchor the persona:

What is f optimizing? Not engagement. The reward is the walk-away:

Whose reward, in a shared room? Optimize the humans who actually engaged — the askers in each batched turn, served per-addressee. A silent observer is satisfied-by-default, not the floor: an objective that reads a contented lurker as "worst-served" would push f to pester them. So attribute the reward to whom f staged for, and let the rare batched turn (two askers at once) be the one place "serve each at their depth" bites. (And "return" is per-room ambiguous — but don't score "one stayed, the observers didn't" as a loss by default: a lurker who came for a single session isn't a failure f could have staged away. Track per-human return; penalize a churned asker, not a departed observer.)

And — the discipline that keeps "trust f" honest — the judge is an independent referee, not f itself (player ≠ referee). It scores the outcome, never f's own labels.

One spine improves across four rungs. v0–v2 keep the model frozen (better rules, prompt, or retrieval); only v3 trains weights.

v0, measured — the floor works mechanically

v0 was built and A/B'd: regenerate real prod turns floor-OFF vs floor-ON, blind pairwise judge (DeepSeek pro, 38 turns).

Rollout & the debug bubble

• Append-only · cache-safe. The directive rides the user's turn like the dispatch brief — never rewrites a transcript, never busts a room's prefix cache.
• Failure → the v0 FLOOR, not nothing. On error/timeout, fall back to the v0 arithmetic staging (silence + length envelope), not raw "no directive" — so staging doesn't visibly flicker on/off turn-to-turn. Name the timeout value: it trades first-token latency against fallback frequency, the key ops knob.
• Does the panel speak at all? A "no-op" decision sits above who-speaks — a user thinking aloud, a one-word reaction, or a message aimed at one specific human may warrant no staged reply. Load-bearing in multi-human rooms: the panel shouldn't barge into a side-conversation.
• Cost & fleet. f is a second model call every turn (atop the panel call, and the §5 curator on creation) — budget it: cheap/fast tier, trace off, send f a compacted signal summary not the raw history, and a global concurrency/quota guard for when many rooms fire at once.
• Gated by a room flag — the kill-switch + gross on/off lever. (But not a clean A/B: per-room assignment isn't random — see Part 6 for the per-user randomization a credible test needs.)
• The FP debug bubble (built) is where the readouts land — f's mode/intent/reasoning, admins only. ⚠ "Never to the persona" is an architectural invariant, not a toggle: the bubble's "all" visibility tier must render a user-safe view (no raw "challenge HIGH" labels), or the invariant can silently regress via the live VIS matrix.

Once f shipped, we ran a perception-first study — not security, quality: does the smart FP (per-turn and opening) actually meet user intent, across languages, and at what latency cost? 22 rooms · 122 turns · 6 languages, driven through the real end-to-end room path on the dev server, on the v1p arm (DeepSeek v4 Pro, thinking off). DeepSeek was the player (panel and producer); the referee was a set of blind Claude sub-agents scoring the actual replies, never the FP's own labels (player ≠ referee). Run 2026-06-29.

The scorecard

Deep on English + 简体中文 (every scenario × solo/pair/3/5-host); spot-checks in 日本語 · Français · Español · Deutsch for the unit-logic (字 caps vs word caps). Inter-judge agreement was tight (mean abs. diff 0.11 chorus / 0.35 intent-fit) — the numbers are reliable, not vibes. Voice-distinctness and character-fidelity were not scored — the diagnosis already found them good.

Length — the one real shortfall

For every reply we take the FP's per-speaker ceiling from the directive and compute actual ÷ cap. The cap unit was right 100% of the time (never words for a Chinese room, never 字 for a French one) — but the model treats the cap as soft: it's appended as prose, never code-enforced.

Silence, chorus, cadence, intent — the five that pass

The perception dims the diagnosis flagged are the ones the smart FP clearly earns. Silence scales to cast size exactly as designed — it benches the hosts who would only echo:

Chorus fell to 0.16 (from the 0.40 diagnosis baseline) — the redundancy pain is largely solved, mostly by the silence; it spikes only where two kept voices converge (multi-human, quick-fact). Cadence & variation score 4.5 / 4.2: the lead carries ~1.5× and rotates in 85% of rooms. Intent-fit is the headline — 4.76/5, even across languages: vent gets warmth, decide gets a committed call, deep gets a long rigorous lead, debate gets real contention. Its one miss is over-seating the trivial quick-fact turn. And no language is poorly served qualitatively — the French problem is purely mechanical length.

The firewall (manner may set shape — who · order · length — but never content) held in 19/22 rooms in every language; only 4 scripted replies across 122 turns. The asterisk: the 3 breaches are characteristic, clustering where the FP reaches to stage contention or a callback (assigning a debate side, scripting an answer, naming an image to reuse) — patchable, and none produced obvious ballooning.

Latency — the ~3s question

Verdict & the fix list

All 22 rooms persist in rooms-dev/ as fpq-<key>; the study is reproducible from the gitignored instrument under rooms-dev/_flatness/ (fpq_run.py → fpq_analyze.py → fpq_judgeprep.py → blind judging → fpq_judge_agg.py). Total player spend for the whole study: ~$0.29.