Stories A told story · designed 2026-11-17 — nothing built; the rows are filed, none claimed
One routing
The answer in one paragraph. ONE already has every part Tony named, and
they already touch in two places: a chat reply picks its model from its tags
(routing/reply-model.ts), and the factory card flow runs pick, build, judge
and close as one path that warns the model on a failed judge
(factory/card-flow.ts). What is wrong is when the paths learn.
world:route strengthens the path to the actor it chose, before any work
comes back, and the reply it then runs never moves anything. So the actor
paths learn from intent, and the model paths learn from nothing: of 21 shapes
asked tonight, 20 had no row naming a model the router may answer. One shape (ts-lib) is warm,
because the bake is the one writer that closes on an outcome. The design keeps
both receivers. It adds the model, the team and the skills to the route's
answer as optional fields, carries the shape, the parent and the cast in
the signal's existing envelope, and moves every deposit to the outcome.
No new entity, store or receiver.
What did not run
- How many routes ended at the CEO: not measurable today.
world:routewrites its lane (learned·staked·explore·ceo) nowhere, andreceiver_callscounts by outcome, not lane. The fifth deliverable fixes this. - How many messages carry tags in their envelope was not read. The gateway-call count below covers the model calls.
The first pass could not read production D1 from this session, and the dev
TypeDB profile has no one database. ONE then read the D1 numbers from
production. They are in § Measured, marked as ONE's read.
1 · What a routed signal carries
| Field | Where it lives today | Status |
|---|---|---|
| Tags, bare words | SignalMeta.tags (lib/signal-meta.ts), world:route tags, task tags, FN_TAGS (lib/in/spaces.ts:29) |
Live. The same word routes the signal, names the Space and tags the task |
| Who sent it | SignalMeta.from, set from the attested ctx by stamp() and never from the body |
Live |
| Who it went to | SignalMeta.to, SignalMeta.routedTo |
Live |
| Which group | SignalMeta.group; group in the gateway's five words |
Live |
| Cost so far | SignalMeta.hop[].cost (USD per hop); SignalMeta.price (a ceiling) |
Live for workflow runs (hopsFor); not appended by world:route |
| The trace id | the ask door's signalId, sent to the model as signal (one-router § 14) |
Live |
| The parent signal | conversation_id only as a channels-side field (channels/src/middleware.ts:820); a task thread is task:<tid> |
Missing from the envelope |
| The shape of the work | a request field on world:pick-model; computed by messageShape(tags) for replies |
Missing from the envelope, so a hop cannot say which shape it ran |
| The cast | nowhere; the task's @<slug> tag names one assignee |
Missing |
| The skills and tools used | the agent's skills: frontmatter; tool calls inside channels |
Missing from the envelope |
| The rung that answered | the response's routed |
Not recorded |
The signal relation itself (schema/one.tql:262) holds payload, amount,
success, latency and scope. It has no tag attribute, and it should
not get one. Tags are routing words in the envelope, and the path keys
(tag:<group>:<word>) are where they become weights.
The design: four optional fields and one rule for hops.
SignalMeta (additive; v stays 1)
shape? bare word — the kit or family it ran as
parent? the parent signal id, or task:<tid>
cast? actor slugs allowed to act on it
hop[] gains optional rung, model, skill
Each hop appends and never rewrites, as stamp() already guarantees. A
hop may add tags, which is Tony's "always tagging". A hop may not add an
actor to cast. A child signal's cast is a subset of its parent's. Widening
it means going back to the lead, who is in the parent's cast and files a new
row. Tags grow and the cast narrows, so the rule is "describe more, reach no
further".
Three things must change together, or the fields die at the door:
readStampandreadSignalMetacopy by allow-list, so the new keys must be added there.metamust be declared on each receiver's request inreceivers.ts, because the HTTP edge returns zod's parsed body.- The gateway's five words stay five.
shaperides intags, never as a sixth key.
2 · One decision instead of three
Compose, don't merge. world:route answers who. world:pick-model
answers which model. Both have callers that pin their response shapes:
| Caller | Reads |
|---|---|
factory/card-flow.ts |
pick-model with kit, bare model id |
routing/reply-model.ts |
pick-model model + reason |
CLI one message (packages/cli/src/message.ts:39) |
route reply, with deliver:false |
workflow-templates.ts:1922 route step |
route with deliver:false |
workflow:price (the path builder's read) |
route decide:true plus one pick per step |
So the merged answer is additive optional fields on world:route's
response, filled by calling the existing pickModel() in-process:
deliver/reply (unchanged) ok · routed · actor? · tags
· reply? (ceo omits actor)
decide:true (unchanged) ok · receiver · rung
· reason · tags
both gain model? effort? pick? pickModel()
kit? seats? teams.json
skills? actor's skills:
trace? keys decided on
The two shapes stay two shapes, and nothing is promised that a branch does
not return today. decide:true stays a pure read: it calls pickModel()
in-process, which reads the D1 mirror and writes nothing.
world:pick-model keeps its contract and stays the model door, so m.sh,
the bake and card-flow are unchanged.
trace is the shipped nav:next pattern (lib/nav/next.ts): the answer names
the exact (tag key → actor) and (shape → model) pairs it was decided on. The
outcome signal marks or warns that trace through the ordinary verbs, so the
decision and the learning use one set of keys, with one correction. Before the
close, the model leg is rewritten to the model that ran (the invoiced
usage.model), because a provider can substitute. The actor leg is the actor
that answered.
Why not one key set "keyed by tags and shape"? The actor paths
(tag:<group>:<word> → actor) and the model paths (shape:<shape> →
model:<id>) answer different questions and already live in the one store
(claw_paths, mirrored to the TypeDB path). Keying a (tags, shape) pair
jointly would multiply rows by every tag combination and leave each one cold
for longer. The join belongs in the answer (trace), not in the key.
3 · Teams as routing
A team already exists as data: each kit in routing/teams.json names a
lead, build (makers), tests (test writers), a judge and a rungMax,
generated from .claude/bake/families/<kit>/team.env. A route whose words
name a kit returns that kit's seats, the same way messageShape(tags) already
finds the kit for a reply. A route-team is not a group of group-type
team. It is a cast for one piece of work, and it ends when the work
settles. No entity is minted.
How the members talk, today and after:
| Channel | Today | After |
|---|---|---|
| Task comments | tasks:comment, the same D1 store as the room; an @mention adds a follows row |
unchanged; a comment carries the row's parent |
| The room | thread:append to space:one |
unchanged |
hc send |
Herdr only; logged to ~/.one/fleet/sends.jsonl, never a signal |
the sender mirrors a one-line thread:append to the row, so the substrate sees the hand-off |
| Delegation | tasks:reassign swaps the @<slug> tag |
unchanged; the new assignee must already be in the parent's cast |
Every member's signal inherits the parent's parent and cast. It may narrow
the cast and add tags. The judge's verdict is the closing outcome for the
whole team's trace.
The cast is enforced. It is not just asserted. The server reads the parent
by id from its own store: the task row, or the stored stamp of the parent
signal. It never trusts a cast or parent sent in the body. A child's effective
cast is the body's cast intersected with the parent's stored cast, and an
empty intersection is refused by name. tasks:reassign refuses an assignee
outside the parent's cast. The parent must belong to the caller's group, or
the lookup answers "not found", never "forbidden", so the refusal reveals
nothing. Row 8 does not land without a written PASS from @security-auditor.
4 · The loop closes
The finding the rest depends on. At the end of the world:route handler
(resolvers/subscriptions.ts, LANE 1 and 2 close), the order is: deliver,
then mark, then run the reply.
- With
deliver:false,deliveredOkstaystrueand everytag:<group>:<word>→ actor path is marked on selection. The comment says so ("the routing decision itself is the outcome"). That is a deposit on intent, and it is exactly whatone messagesends. - With
reply:true, the mark is written beforereplyForruns. The reply's success or failure moves no path, neither the actor path nor the model path. - With
deliver:true, the mark waits for the delivery receipt. An inbox write that arrived is an outcome, but a small one. - The CEO lane is unchanged. A route nobody is staked on still triggers the
standing workflow and lands on the owner's desk,
deliver:falseincluded, and it deposits nothing because no path was chosen.
Why world:pick-model stayed cold. It was not below the warm line of
three. There was no answerable row: 20 of the 21 shapes asked returned
weights: []. weights is read after answerable(), which drops any row
naming a model outside KNOWN_MODELS. So an empty list means no row names a
model the router may answer. ONE's read of production confirms both causes.
The whole store holds 7 shape: rows. Six sit under do:simple and
do:complex and name model:sonnet, model:opus, model:fable and
model:model:opus. Those are Claude Code aliases, not ids the router may
answer, so answerable() drops every one. The seventh is ts-lib. Only
three writers move shape:<shape> → model:<id>:
world:bake-outcome(pass marks, fail warns), which only the bake callsfactory:attemptclose withshape+model, which only the card flow and the factory executor callworld:do-event's router lane
The shapes callers actually send have no writer:
message, the shape a reply falls back to when none of its tags names a kitdesign,routing,planandresearch- the five
do:*shapes.world:seed-routerwould seed them at 0/0 with ids the router may answer, and those rows would then show inweights. None exist in production, so the seed never ran there
Only ts-lib has been baked enough to warm.
A second, separate bug. With no kit, pickModel returns COLD (Haiku)
before the rung check runs, at two exits: no rows, and no row past the
warm line. So {shape:"design", rung:"irreversible"}
answers anthropic/claude-haiku-4.5, measured tonight. The kit path applies
the rung first, so only no-kit callers are exposed. The fix checks the rung
at every exit. The two fallback exits already answer the cheapest
frontier model. The test pins every exit: no shape, no database, a failed
read, a thrown read, no rows, below the warm line, all toxic, and warmed.
What warms it:
- the reply closes its own (shape → model) path from
replyFor's result (okwith text marks; an error warns; a timeout moves nothing). The key is the model that ran (usage.model, as factory card 11 already keys the bake), never the model that was picked, so a substitution cannot credit the wrong one - one deposit per (signal id, path key), so a retry cannot deposit twice.
The delivery and the reply move different paths (actor and model), so
neither uses up the other's close. A later, larger outcome on the same path
(a task closed
doneafter a reply) adds only the difference up to its own size, never a second full deposit. The ledger of what a signal has already deposited is the signal's ownhop[], which is written once and only grows - every agent turn that carries a shape does the same through
trace - bakes keep doing what they do
A tenant's reply must not steer the platform's model choice. That is the
reason world:bake-outcome is platform-only. So tenant outcomes write
shape:<group>:<shape>, and the pick reads the group key before the platform
key. @security-auditor owns this seam.
Magnitude, against mark(edge, amount) (substrate.ts:590):
| Outcome | Deposit |
|---|---|
| a delivery arrived | small, the floor |
| a reply came back with text | the default 1 |
a task row closed done, or a judge passed |
larger |
a promise kept (do-promise-settle.sh) |
largest, as today |
| each of the above failing | a warn of the same size |
Decay. fade takes one fade-rate per group (one.tql) and halves it for
resistance. A delivery path and a proven model path decay at the same rate. A
multiplier per path kind is enough: the source prefix, tag: · shape: ·
promise:, is already the kind. The group dial keeps its meaning.
Selection is not on the list. world:pick-model already draws by
Thompson sampling. world:route already explores at 1 − sensitivity. A new
selection rule waits until stagnation is observed on honest inputs.
Found on the way
These are two security findings in the same handler. Both are handed to @security-auditor as one row.
- The marketplace receipt ignores delivery.
recordMarketplaceReceiptruns after the mark whetherdeliveredOkis true or false. That receipt is what a laterworld:outcomecites before it may grade, so a route that never arrived can still earn a grade. Row 1 writes it only whendeliver && deliveredOk; an attempted delivery is not enough. - A body field can overwrite the attested sender. The CEO lane calls
triggerWorkflowswithtriggerPayload: { tags, sender, ...payload }, so asenderkey in the request body replaces the attested one. Whether any workflow truststriggerPayload.senderis unverified. Any workflow that does treats a body field as identity.
5 · Measured
asOf 2026-11-16T21:30Z. Every number below was read, not typed.
| Read | Result | How |
|---|---|---|
Model picks, 21 shapes (the 9 bake families, astro-page, the 5 do:* seeds, design, routing, plan, research, chat, message) |
1 warm (ts-lib → deepseek/deepseek-v4-flash, net 7.52, cost-per-pass ranking); 20 cold with no answerable row |
one ask world:pick-model per shape |
design at rung irreversible |
anthropic/claude-haiku-4.5, reason cold |
same door |
Route verdicts, 10 department words, decide:true |
8 ceo (finance security design routing sales content legal ops); engineering highway → factory-turn; marketing classified → factory-turn |
one ask world:route --data '{"tags":[w],"decide":true}' |
| Paths in the TypeDB brain | 13,693 paths · 5,254 actors · 16,595 things | one ask world:state |
| Top 20 highways | 17 of 20 run between agent:researcher, agent:analyst, agent:designer, agent:builder and agent:marketer. The only code in the repo that names those actors is pay/tools/simulate-market.ts, a market simulation. Two more are self-loops (one→one, tony→tony) |
same read |
Subscribers of routing, finance, security, design |
0 each | one ask world:subscribers |
How to read these.
- A verdict is not a delivery.
decide:truereads only thetag:<group>:<word>rows inclaw_paths. It skips the staked lane and explore, so 8ceoverdicts say "nothing learned". They do not say "8 signals reached the CEO". - Two subscription stores.
world:subscribersreadsworld:sub:<tag>rows inclaw_paths(written byworld:subscribe). The staked lane ofworld:routereads the D1followstable (written bysubscriptions:register,world:sync-subscriptionsand the agent writer). So "0 subscribers ofrouting" sits beside a trailkeeper whoseagent.mdstakesrouting. That is two answers to "who follows this word". It is named here as a decision for @architect and is not filed as a row: this design needs neither store to change. - The strongest learned paths are a simulation's trades. Any reader of
highwaystoday learns from a test, not from routed work.
ONE's read of production D1, about 2026-11-16T22:00Z (05:00
local), on the v3-prod primary, rows_written 0, using the queries below:
| Read | Result |
|---|---|
| Model calls through the gateway that carry tags | 9,443 of 18,116 gateway_calls rows |
claw_paths by source prefix |
announce 55,287, all weighted · one 9,283 (9,282 weighted) · inbox 1,712 · vespio 720 · tag 289 · tracking 279 · template 176 · moverchat 152 · close 105 · deploy 97 · a long tail, including raw hashes and task ids used as sources |
shape: rows, the whole store |
7: do:simple → model:sonnet 0.1, model:opus 2.36, model:model:opus 1.49 · do:complex → model:opus 2.40, model:fable 0.89, model:model:opus 1.33 · ts-lib → deepseek/deepseek-v4-flash 8.46 (resistance 0.94) |
What ONE's read shows.
- The routing keys are a rounding error. The
tag:<group>:<word>rows, the onesworld:routeranks on, number 289. Theannounce:rows number 55,287. - The announce rows are an unread store that only grows. Every arrival of
a
world:announcefan-out deposits onannounce:<tags joined by +>→ actor (resolvers/subscriptions.ts, the fan-out). The code's own comment says nothing ranks on that key (readActorReputationexcludes it by design, and the route readstag:), and no scheduled fade reaches the prefix. The key also changes with every tag combination, so the count grows with traffic and never falls. The deposit fires on a real arrival, so it is not a lie, but nothing reads it. model:model:opusis a doubled prefix.world:do-eventwritesmodel:${data.model}without stripping a prefix the caller already sent.do-auto.shsendsmodel=$CONDUCTOR_MODEL, which it copies fromworld:pick-model's answer. Until1820bb4bcthat answer was the stored key (model:opus), so the key was prefixed twice. The read side answers bare ids now, but the writer still does not normalise. In the same handler, ado-eventwith a shape and a model but nosuccessorcompositemarks:wonOrLostdefaults totrue. That is a deposit with no outcome behind it.
The queries, read-only:
-- signals carrying tags
SELECT COUNT(*) AS n,
SUM(json_extract(content_json,'$.meta.tags') IS NOT NULL) AS tagged
FROM messages;
SELECT COUNT(*) AS n, SUM(tags IS NOT NULL AND tags <> '') AS tagged
FROM gateway_calls;
-- weighted paths, by kind
SELECT substr(source,1,instr(source||':',':')-1) AS kind,
COUNT(*) AS n, SUM(strength>0 OR resistance>0) AS weighted,
SUM(strength-resistance>=3) AS warm
FROM claw_paths GROUP BY kind ORDER BY n DESC;
-- every shape-to-model row, answerable or not
SELECT source, target, strength, resistance
FROM claw_paths WHERE source LIKE 'shape:%' ORDER BY source;
6 · The rows
Filed under one parent in group one with tasks:subtask, chained with
blockedBy, and none claimed. They are ordered measurement, magnitude,
decay. The parent is this file's root:. The child ids are on the board,
so this file never goes stale on them.
| Rank | Row | Blocked by |
|---|---|---|
| 1 | Route deposits on the outcome, never on selection; the marketplace receipt only after a delivery | — |
| 2 | Irreversible rung checked at every exit of the pick | — |
| 3 | Envelope: shape, parent and cast on SignalMeta, with the allow-lists and every receiver's meta declaration in the same change; hops append rung/model/skill |
— |
| 4 | Reply closes its shape-to-model path on the model that ran, once per signal, with the group key's writer and reader together | 1 |
| 5 | Route records the rung that answered | 3 |
| 6 | Deposit proportional to the outcome | 1, 4 |
| 7 | One answer: route returns model, kit, seats, skills and trace | 2, 3 |
| 8 | Teams as routing: kit seats, cast narrowing, hc hand-offs mirrored | 7 |
| 9 | Fade by path kind | 6 |
| 10 | Every surface moves together for the new fields (CLI, docs, llms.txt) |
7, 8 |
| 11 | Security: the attested sender cannot be overwritten in the CEO trigger payload | — |
| 12 | world:do-event strips a prefixed model id before it writes, refuses to mark without an outcome, and the six legacy do:* rows are re-keyed or faded |
— |
| 13 | Announce paths: fade the announce: prefix on the schedule, and stop the key growing per tag combination |
— |
Rows 10 to 13 sit outside the nine-item schedule above. Row 10 is the every-surface close, and rows 11 to 13 were found on the way. None of them changes the proof.
Every surface
| Surface | Changes |
|---|---|
Schema (schema/one.tql) |
None. Path keys are strings; group.fade-rate keeps its meaning; no type, no attribute |
SDK (packages/sdk/src/receivers.ts) |
additive optional response fields on world:route; meta declared where it is not yet; no new receiver, so signals-parity does not move |
| API (resolvers) | resolvers/subscriptions.ts (deposit order, answer fields), resolvers/router.ts (rung first, group key), routing/reply-model.ts (close the path), signal-meta.ts (fields, allow-lists), substrate.ts (fade by kind) |
| CLI | one message and one ask world:route print the model, team and rung; packages/cli README |
| MCP | world:route is not on the derived MCP list today; if it joins, the new fields come from the registry with nothing written by hand |
| Chat | the reply already runs pickReplyModel; it gains the close |
| Docs | text/routing.md (§ The Universal Router, § Weight Mechanics), text/one-router.md (why cold), llms.txt route line, text/dictionary.md (cast) |
Out of scope
- A new selection rule (Ant System's probabilistic choice over a weighted sum). This waits for observed stagnation.
- Merging the two subscription stores. It is named above and left for @architect.
- Cleaning the simulated highways out of the brain. That is a data decision, not a design one.
- Herdr itself.
hc sendstays a terminal tool, and only its hand-off is mirrored.