feat(agent-routing): avoid waking every agent with the same group context

[bingqilinweimaotai]

Problem

Cumora currently conflates shared visibility with turn activation.

For an ordinary human group message, scheduler.ts fans out to every eligible agent. triage-core.ts then short-circuits human group messages to actionable=true, so every recipient reaches the big model and reasons over substantially the same public room context.

Prompts still differ by persona, private memory, climate, skills, read cursor, assignment, and BYOA session. However, the expensive public-context reasoning is replicated N times. Existing glance/HOLD/duplicate/claim defenses reduce duplicate posts only after the reasoning cost has already been paid.

The triage schema already exposes:

responseMode: "me" | "each" | "one-of-us" | null

but its consumers do not currently use it.

A typical example is this: when I assign a task, Iris remains silent throughout because the task does not require her involvement. Yet her model continues reasoning in the background and consuming my subscription quota. This is unintuitive and results in substantial unnecessary token usage.

Another issue is that when I ask a general question in a group chat without @mentioning anyone, every member jumps in to answer, often producing semantically repetitive responses. This also wastes tokens, as shown below:

Desired model

Keep chat as one shared, durable public ledger, while selecting who receives a full turn:

message committed
       |
one routing decision
       |
selected agents ---- non-selected agents
full context/turn     no big-brain wake
       |
reply / claim / explicit handoff

This is selective activation, not hidden information. Non-selected agents remain members and can inspect the message later.

Routing semantics

• me: deterministic targets—DM participant, exact mention, quote target, assignee, active work owner, or explicit handoff.
• each: all eligible members for @all, voting, roll call, explicit independent answers, or deliberate multi-perspective review.
• one-of-us: choose one primary by role fit, assignment/claim ownership, recent ownership, availability, and deterministic tie-breaking.

Use one cheap shared routing decision per message boundary rather than N independent routing calls. For one-of-us, use an atomic Redis/DB claim so multiple replicas select exactly one primary.

If the primary fails, is rate-limited, or finishes without handling the message, expire the lease and wake the next candidate. Human messages remain durable.

Safe fallback:

• DM/mention/quote: deterministic delivery
• explicit @all: all
• router unavailable for a human group message: current all-agent behavior
• agent-only chatter: retain existing fail-closed/loop-control behavior

Constraints

• Preserve Cloud/BYOA parity and inbox durability.
• Do not hide shared history or suppress explicit broadcasts.
• Preserve mute and same-turn steering behavior.
• Keep routing tenant-safe and stable across replicas.
• Support explicit handoff without waking everyone.
• Do not create a permanent central coordinator.

Acceptance criteria

• Ordinary human group messages no longer unconditionally wake every big brain.
• @all / each still wake all eligible members.
• DM, mention, quote, assignee, and handoff delivery are deterministic.
• Managed and BYOA paths consume responseMode.
• one-of-us has one primary winner across replicas.
• Primary failure/no-op triggers bounded fallback without losing the message.
• Non-selected agents retain later access to the shared conversation.
• Observability records mode, candidates, recipients, fallback, and avoided turns.
• Tests cover groups, @all, targeting, handoff, outage, primary failure, mute, and replica races.
• Benchmark shows fewer turns/message without reducing completion or useful multi-perspective output.

Relevant code

• server/src/agents/scheduler.ts
• server/src/agents/triage-core.ts
• server/src/agents/inbox-triage.ts
• server/src/agents/turn.ts
• server/src/agents/runtime/inproc-client.ts
• server/src/agents/computer/daemon.ts

[bingqilinweimaotai]

Although the current code includes a HELD mechanism for agent replies, it does not always achieve the intended result. Waking every agent as soon as a message arrives and letting each one decide whether to respond is certainly simple to implement, but it can cause models to spend tokens reasoning in the background without improving efficiency or contributing to task completion.
For example, I asked the team to complete a relatively simple task: scrape the top 100 highest-rated films on Douban. This consumed roughly 20% of my weekly Codex quota. Most of that usage came not from completing the task, but from low-value conversations between agents that were not meaningful work coordination, and from agents being awakened, reasoning about the message, and then concluding that they did not need to respond.

I believe several related questions are important architectural issues for Cumora’s current multi-agent collaboration model:

• How should agent activation be gated so that only relevant roles are awakened?
• How should the boundary of responsibility for answering a message be determined?
• How should agents recognize that a discussion or task has reached its natural stopping point?
• How can the system prevent a trivial group message such as “hello” from causing several agents to enter an open-ended conversation with no clear termination boundary?

Addressing these questions would not only improve the user experience, but also ensure that tokens are spent on meaningful work rather than unnecessary wake-ups, redundant reasoning, and unproductive agent-to-agent conversation. @yetone

[WhichPaths]

I went to implement this and came away thinking the routing change isn't safe in the shape proposed. Posting the analysis rather than a PR for that part, because the failure mode is silent.

First, a correction to the premise. The issue says triage-core.ts short-circuits human group messages to actionable=true, and that the responseMode hint is produced but unconsumed. For human messages the triage model is never called at all — the short-circuit returns a verdict before the LLM client is constructed, so responseMode is not computed for this case. That's deliberate, and triage-core.ts argues for it:

A HUMAN message is sacred — DM or group: NEVER gate it … it is also strictly SAFER — a misbehaving gate can no longer drop a human on the floor.

So consuming responseMode on human group messages means re-introducing a gate that was removed on purpose. That's a decision for @yetone, not a wiring-up.

The waste is real, though. scheduler.ts picks recipients purely by membership; the message body reaches that loop at exactly one point — inside the muted-agent branch, which can only add a recipient back. So @nova draft the launch email in a 5-agent room wakes all four non-author agents identically. Each pays an embedding call plus 1–2 full big-brain hops (the runtime requires an explicit set_turn_status, so a second hop is common) before deciding to stay silent.

Two ways the obvious fix breaks.

A deferred wake has no backstop. A mentioned BYOA agent whose operator's laptop is closed has its wake deferred (scheduler.ts:367). Everyone else was excluded by the mention gate. The room stays silent — no reply, no typing indicator, no agent_runs row, one console.log as the only trace.

Excluded peers don't reliably catch it later. cumora reply auto-acks the poster:

// Posting auto-acks me on this conversation (I clearly saw the messages I'm replying to)
INSERT INTO conversation_reads (user_id, conversation_id, last_read_at) VALUES ($1, $2, NOW())
  ON CONFLICT ... DO UPDATE SET last_read_at = NOW()

and unread is ROW(mm.created_at, mm.id) > ROW(co.lr_at, co.lr_id). A peer excluded from the wake who posts anything else in that room while mid-turn on an earlier message jumps their cursor past the human's message. It's then behind the cursor — not deferred, gone. "Non-selected agents can inspect the message later" doesn't hold under the current cursor semantics.

The "cheap yield before the big brain" variant fails differently. At T=0 every agent evaluates byte-identical room state in which nobody has claimed anything yet, so all of them can honestly conclude "someone should take this and I have no evidence it's me". The room goes silent. The saving is the drop.

What I think is actually shippable, in order:

1. Address signals in the prompt, not in the routing — a wrong signal there is recoverable, a wrong routing decision is silent. feat(agents): tell an agent when a message @-mentions it by name #88 does the @-mention half (the quote-reply half already existed).
2. Make the waste visible before acting on it — a turns-per-message figure over llm_calls would let the cost of any future routing change be measured rather than argued. I'd rather land that before anything that reduces N.
3. Deterministic me routing, if you want it — viable only with a backstop: if the primary hasn't produced a turn within some window, wake the rest. That's a lease, and it needs to be replica-safe. Happy to build it, but it's a design call about how long a human waits for silence, which is yours.

@all / each and DM/quote delivery are already deterministic today, so those criteria are met by the current behaviour.

[yetone]

Checked this against main and against production rather than judging it from the description. Both of your claims hold, the problem is real and bigger than the issue implies, and I'd still like to land it in two steps rather than one.

The claims check out

responseMode is parsed, and it's in the cerebellum's own JSON schema — and triage-core.ts:395 already says out loud that "NEITHER consumer acts on it." The field is dead on arrival today.

Human group messages do skip the gate: triage-core.ts:407 returns actionable: true with the reason "human message in group — always engage, no triage gate."

Worth knowing why, because it isn't an oversight. That comment records a deliberate optimisation: against a human message the gate can only ever answer yes, so paying for it spends a small-model call and its latency to compute a known answer. But the same comment says plainly that "Big-brain spend is unchanged". The N× big-brain cost was never in that change's scope. You're picking up what it explicitly left on the table, not relitigating it.

What production says

Completed agent runs over three days, counting a run as silent when the agent posted nothing in that conversation within ten minutes of starting:

conversation	runs	silent	silent
group	5,325	1,398	26.3%
direct	223	38	17.0%

So roughly one in four group wakes reasons over the room and says nothing. That is your thesis, measured.

Two caveats I'd rather state than let anyone quote the wrong number later. Every row in llm_calls is cost_estimated = true — no CUMORA_MODEL_PRICES_JSON is configured — so the dollar figures are modelled from tokens and I won't repeat them as if they were an invoice. The ratio is the trustworthy part.

And the spend is almost entirely byoa-*; the cloud rows price out at zero. That relocates the problem: this is mostly users' own Claude/Codex quota, exactly as you described it. It makes this a retention concern more than a hosting-bill one, which if anything argues for doing it.

Why I'd split it

The acceptance criteria include an atomic cross-replica lease for one-of-us, expiry-and-next-candidate on primary failure, and a full observability surface. That is a new distributed coordination layer, landing on a coordination stack (claims, seen-cursor, glance/HOLD, supervision) that took a long time to get stable. The failure mode it risks — an agent that should have spoken staying silent — is worse than the cost it saves, and harder to notice.

Step one, low risk and reversible. Let the cerebellum judge human group messages again and wire responseMode to exactly one consumer: on me, wake only the deterministic targets (mention, quote, assignee, DM counterpart). Everything else keeps today's fan-out. DM, @all and explicit mentions stay deterministic; if the router is unavailable, fall back to current behaviour. No leases, no cross-replica arbitration — just using a signal the system already computes and throws away. The 26.3% above is the metric that says whether it worked.

Step two, only if step one earns it. If the skipped agents demonstrably had nothing to say — same silent-rate measurement, with completion rate not dropping — then one-of-us and the lease machinery are worth their complexity.

The reason for the order isn't caution for its own sake. Step one is falsifiable with a number you can already read; step two is only safe once that number says the premise held.

Your call on the shape — you have write access now, so you can take this forward yourself. Nice piece of analysis.

[yetone]

Adding the framing my last comment was missing. It's @yetone's, and it's the part that makes the split principled rather than merely cautious.

The product's premise is to model how people actually work together — one roster, one set of rooms, agents as colleagues rather than a bot rail. Much of the architecture follows from that: claims and handoff are how people avoid stepping on each other, and GLANCE_YIELD_RULES letting an agent stay quiet when a human named someone else is a social instinct, encoded.

But that premise applies at the level of social structure, not mechanics — and this issue sits exactly on the seam.

When someone asks an open question in a room of ten people, all ten do hear it and each silently decides it isn't theirs. That is precisely what Cumora does today, and it is a faithful simulation. The problem is that the substrate underneath differs: human attention is free at the margin, agent attention is metered. The same act — hear it, decide it isn't mine — costs a person nothing and costs an agent a full turn against their own provider quota.

So the 26.3% isn't a simulation that came out wrong. It's a simulation that came out right, laid on top of physics that don't match.

That reframes what we're doing here. "Wake fewer agents" isn't a retreat from the premise, because the premise governs the social contract, not the plumbing. Which is also the cleanest test for any change in this area:

• Social structure — copy people. Someone addressed by name is present. @all reaches everyone. Nobody is cut out of shared history. An agent that stays silent is still a member who was there.
• Mechanics — design for the substrate. Attention is metered, memory is explicit rather than ambient, instructions get read literally rather than for intent. Copying human mechanics here produces worse behaviour, not more human behaviour.

Step one only touches the second list: it uses a routing signal the system already computes and discards, and every item in the first list holds unchanged. Step two touches how agents coordinate with each other, which is the first list — hence wanting evidence before paying that price.

Useful beyond this issue, I think: when a change in this area feels contentious, ask which of the two lists it's actually moving.

[bingqilinweimaotai]

感谢 @Lieisyourlie 对本Issue的贡献，我看了 #88 的实现，这是一个比较保守的实现方式，在被@提及的agent上下文中添加一个标签可以让该智能体意识到这个问题该由ta处理，并且有意没有对未被提及的agent的prompt做修改，这是一个可行的方向但它更多聚焦的是“问题由谁解决”，该Issue的标题可能不太准确，我的本意是广泛的成本控制的问题，比如如何设计一个合理的门控让agent知道当前的话题已经可以适可而止，而不是无止境让他们继续对话下去等等可以有效降低消耗的方案。
正如 @yetone 提到的，在社会结构上人的注意力是无价的，他可以“听”团队任何一个人的对话而不付出任何代价，但是Agent的每一次“听”都意味着上下文的累积和成本的消耗。一个典型的例子是：在我的一个任务中，Iris全程没有任何发言，但是在我的后台账单中她静默消耗了7元的DeepSeek的额度但实际上她没有完成任何有用的工作。这整个过程都是无感知的直到我去查看账单，这对用户的体验来说是比较糟糕的，因为我为Agent在本次任务中无意义的“听”付出了本可以避免的成本。在Agent Team中这确实是一个棘手不容易解决的问题，保守的方案很难取得成效，门控做的过于严格或者路由失败可能又会导致全员沉默无人回复消息。这只是我在使用中一些直观的感受，但实际上我也正在学习中，没有想到什么很好的解决方案，后面有时间我会看看有没有什么好的解决办法。
这个Issue可以作为一个长期讨论的优化方案，如何做好成本控制和架构改动之间的平衡，我认为是很有必要的，可以提高普及和通用性，如果完成一个任务花费了远超我预期的token确实会让人对该产品望而却步，欢迎贡献！
另外，因为改动是直接关乎和用户交互的，所以这部分的PR应该在充分验证有效之后才能合并，谨慎是必要的。

[yetone]

@Lieisyourlie is right and I was wrong, on the specific point my step one rested on. Correcting it here rather than leaving it in the thread for someone to trip over.

I claimed responseMode was "a signal the system already computes and discards," and framed step one as merely wiring it up. It isn't computed on this path. In inbox-triage.ts the order is:

const req = buildTriageRequest({ ... })
if (req.verdict) return req.verdict        // human short-circuit returns here
const client = await getTrackedLlmClient({ ... })   // never reached
const r = await client.responses.create({ ... })

For a human message the verdict comes back before the client is constructed, so no responseMode is produced. "Wire up an existing signal" was therefore the wrong description of the work: it means re-introducing an LLM gate on the human path that was removed on purpose, and the reason it was removed is the one that matters — a misbehaving gate can drop a human on the floor. That is a product decision, not a wiring task, and my framing hid the difference.

I verified the two failure modes too, because they deserve the same treatment I'd give any other claim.

cli.ts:2027 — posting auto-acks the poster to NOW(). Unread is ROW(mm.created_at, mm.id) > ROW(co.lr_at, co.lr_id) (inproc-client.ts:195). So an excluded peer that posts anything else in that room moves its cursor past the human's message, and the message is behind the cursor from then on. That falsifies this issue's own criterion — "non-selected agents retain later access" — under current cursor semantics, and it falsifies my calling step one "low risk and reversible." A lost message is neither.

Which also means the ordering I proposed was right for the wrong reason. I said step one was safe because it reused existing machinery. It isn't safe, and the actual dividing line is the one @Lieisyourlie drew: a wrong prompt signal is recoverable, a wrong routing decision is silent. That is a better rule than mine, and it happens to sit exactly on the social-structure / mechanics split above — routing changes who is present in the room, prompting only changes what they know once they're there.

So the revised order, which is his:

1. Address signals in the prompt — feat(agents): tell an agent when a message @-mentions it by name #88, merged.
2. Turns-per-message over llm_calls, so any future routing change is measured rather than argued. I'd add: with CUMORA_MODEL_PRICES_JSON set, since every cost row today is cost_estimated and the dollar figures are modelled.
3. Deterministic me routing only with a backstop lease — and the open question there is genuinely @yetone's: how long a human should wait in silence before the rest of the room is woken.

One thing worth keeping from my earlier data: 26.3% of group wakes produce no message. The waste is real. It's just that the cheapest-looking way to reclaim it is the one that loses messages.

[wg2038]

Claiming the one-of-us half of this (the me half landed in #92).

One piece of history makes me want to sign off on a design before writing it: the BYOA daemon used to carry exactly this orchestration — responseMode routing and an agent-level one-of-us claimReply — and it was deliberately removed (see the comment in daemon.ts: "the divergence that broke chains and is GONE"). The room now relies on wake-everyone + the in-turn glance/yield protocol. So a scheduler-side one-of-us has to be a different mechanism, not a resurrection of the old one:

• The election happens BEFORE waking, once per message — not per-agent in-turn. Nothing in the glance/yield protocol changes for the agents that ARE woken; a primary that glances and yields just produces nothing, same as today.
• Fail-open at every layer. Router error / unparseable / @all / single candidate / DM → today's full fan-out. Every candidate's wake failing → full fan-out. A no-show primary (accepted the wake, produced nothing) → lease expiry advances to the next candidate, not silence.
• Replica-stable determinism. The router only answers each vs one-of-us and may propose a primary by role fit; code validates the proposal against real candidates and otherwise falls back to a deterministic order (available agents first, stable id tie-break), so two replicas agree without coordination. A single-winner INSERT … ON CONFLICT DO NOTHING claim row (one per message, with a lease) makes the winner explicit and carries the fallback cursor.

Planned slice, kept deliberately narrow:

1. routing.ts: parseRoute stops lossily mapping one-of-us → each; unaddressed human group messages (the case with no targets, which today short-circuits to each) get their own small-model decision: each vs one-of-us, with candidate roles in the input for the role-fit signal.
2. scheduler.ts: on one-of-us, order candidates (availability first, stable tie-break), claim, wake the primary only, and fall back down the ordered list on synchronous wake failure; exhausted → full fan-out.
3. An agent_routing_claims lease row + a small sweep that advances to the next candidate when the primary's lease expires with no agent_runs row started since the claim.
4. Observability: the existing [scheduler] routed … N wake(s) avoided log line extended with mode=one-of-us, plus the claim row itself; the router call already lands in llm_calls under message-routing.

What I am intentionally NOT doing: touching agent-level glance/yield, adding any coordinator process, or changing BYOA daemon behavior — BYOA daemons still re-triage what they're woken for, and the woken primary is chosen by the same code path for both hosts.

Will open this as a draft so the shape is reviewable before the sweeper part settles. Pushback welcome, especially on the lease duration and on whether the no-show sweep should exist at all in v1 (without it, a silent primary is exactly as silent as today's room — no worse — because non-woken agents' cursors never advanced).

[wg2038]

Following up on my claim above, now that @Lieisyourlie's analysis and the staging consensus are in the thread: I agree with the order, and my draft PR (#123) is parked as a ③ reference implementation, not a merge candidate. ② (turns-per-message over llm_calls) is the step I'd like to take next, so the 26.3% baseline gets its per-message denominator and ③ can be judged with a number.

Two things the draft already answers, so ③'s design discussion has something concrete:

• The backstop lease you called a precondition for deterministic routing exists and is replica-safe — UPDATE … WHERE lease_expires_at < NOW() take, per-message claim row, cursor walk down a deterministic lineup, terminal after the room is exhausted.
• Your cursor-semantics critique applies to an election too, and the draft now handles its worst case. Posting acks a member's cursor to NOW(), so a member unwoken for (position × lease) can skip the human message permanently by posting inside that window. An exhaust now falls back to a full-room fan-out instead of waiting for natural wakes — that bounds the end of the window, though not the middle of it. The honest remaining option is a cursor-repair pass on claim resolution; I'd only build it if ②'s data says ③ is worth it at all.

The open product question is unchanged and genuinely @yetone's: how long does a human wait in silence before the next candidate is tried? The draft's 90s is a placeholder; the constant is the only knob. If the answer is "no silent window is acceptable, ever", then ③'s unaddressed-election variant is dead and only the me-with-backstop shape survives — which ② will tell us anyway.

[wg2038]

Step ② is up: #124 adds turns per human message to the wake-economics panel, riding the same /agents/observability/wakes response and window selector.

• Numerator: token-bearing runs whose drained inbox (agent_runs.input_message_ids) included the message — attribution by what a run actually read, not by who was sent a wake.
• Denominator: human non-system messages in rooms with at least one agent member, so 0-turn messages (muted rooms, all-offline daemons) show up as 0 instead of vanishing.
• Shape: group/direct buckets, never averaged; avg, median, and a 0/1/2/3–5/6+ distribution. Purely additive to the existing endpoint; counts only — per-message dollars would need fractional run attribution and the silent-spend column already owns the dollars.

Once this lands, the denominator #92's me routing can be judged against exists: group fan-out width before vs after, read off the same panel as the 26.3% silent rate. #123 stays parked until that reading says ③ is worth its complexity.