Terminus: where the mind lives

Proposal section 5: where the mind lives

Somewhere in the twilight band a child holds a glowing slate and asks it why rivers bend. The question leaves the slate as a whisper of WiFi, reaches the squat gray terminal her village found on a parachute, leaps 2,200 km to a satellite of the wheel — a satellite that will drop below her horizon in a quarter of an hour, mid-conversation if the conversation is good.

So where is the thing that answers? Every section so far has moved messages. This one has to place a mind — and minds, it turns out, are heavy in a very particular way.

What a mind weighs

A large language model is two things. The first is its knowledge: billions of numbers, fixed at training time, the same for every user on the planet. Think of it as the frozen mind — enormous, but it never changes, so it can be copied anywhere in advance at leisure.

The second thing is the conversation itself. As the model reads each word you send, it writes itself notes — a compact mathematical summary of everything said so far, which is how the ten-thousandth word can depend on the first. Engineers call these notes the KV cache; call it the working memory. Unlike the frozen mind, it grows with every token (a token is a word or piece of one), it is different for every conversation, and it cannot be regenerated cheaply — lose it, and the model must re-read the entire conversation to rebuild it.

How the notes are written

Every layer of the model does the same thing to each new token: it looks back over the conversation so far, itself included, and decides what matters. It does this by asking. The new token carries a query, a list of numbers that amounts to a question. Every token carries a key, a label for what it is about, and a value, what it has to contribute. The query is compared against each key, the closest matches get most of the weight, and the token takes away a blend of their values. That is attention, and it is how an "it" in the fortieth sentence finds the river it means in the first.

The keys and values are the notes. A token's key and value at each layer depend only on that token and the ones before it, so nothing said later can change them; once written, they stay correct for the rest of the conversation. The model could throw them away and work them out again for every earlier token each time it produces a new one, but that would mean re-reading the whole conversation for every token of every reply. So it keeps them. The KV cache is that trade in its plainest form: memory spent so that arithmetic is never repeated.

The notes are written in two ways. When a question arrives, the model reads all of it in one pass, working on every token at once, and writes a key and a value for each of them at every layer. Engineers call that prefill. Then it answers, one token at a time: each token it picks is fed straight back in, and the pass that chooses the next one writes the new token's key and value at every layer. That is decode, and it is why a reply is stored as faithfully as a question. The model's own words are in its notes because every word it writes next has to attend to them. When the child asks a follow-up, only the new question is prefilled; everything before it is already in the cache.

Every note has the same shape, and the shape is what the arithmetic below multiplies out. The model has 80 layers, and each keeps notes of its own. Within a layer, attention runs in parallel heads that each learn to look for something different. This model asks its questions with 64 heads, but keeps notes for only 8: each set of keys and values serves 8 query heads at once, a design called grouped-query attention. Had every query head kept notes of its own, the cache would be 8 times larger. Each key and each value is a list of 128 numbers, and each number is stored in 2 bytes. For the model our patron is donating, the arithmetic is fixed by its shape:

/// Per-token key/value-cache footprint of a transformer model: for every
/// token processed, each layer stores a key and a value vector per KV head.
impl KvCacheModel {
    /// Bytes of KV cache appended per token of context.
    pub fn bytes_per_token(&self) -> f64 {
        (2 * self.layers * self.kv_heads * self.head_dim * self.bytes_per_value) as f64
    }
}

A key and a value, at each of 80 layers and 8 heads, 128 numbers apiece at 2 bytes each: 2 × 80 × 8 × 128 × 2 = 327,680 bytes, or 320 KiB of working memory per token. A conversation is not weightless:

   context (tok)  size (GB)   @10 Gbps (s)  @100 Gbps (s)
            8192        2.7            2.1           0.21
           32768       10.7            8.6           0.86
          131072       42.9           34.4           3.44

Watch it grow. The left pane is a tutoring session; the right is the working memory it leaves behind, one band per turn.

This is why the working memory is so hard to replace. Lose it, and the only way back is the way it was made: prefill the entire conversation again, every token through every layer. The simulator takes a stated guess of 10,000 tokens a second for an accelerator cluster doing that work, so the 32,768-token session in the table costs about 3.3 seconds of a large cluster's time to rebuild. Streaming the finished notes over a 100-gigabit link takes 0.86 seconds, and no model has to run while it happens.

The obvious shortcut is to carry the words instead. The transcript of that same session is about 130 kilobytes; its working memory is 10.7 gigabytes, about 80,000 times more. But the transcript is only the recipe, and the working memory is the meal: the recipe is cheap to carry, and cooking it again is the 3.3 seconds. That difference sorts everything that follows. The copy of a conversation that has to survive a disaster is its transcript; its working memory lives only where the model runs, and dies there.

The child's lesson on rivers is a session of exactly that kind. Let it run to thirty-odd thousand tokens — the middle row of the table, the middle setting on the plate — and it drags eleven gigabytes of irreplaceable state behind it. Now put that fact next to the wheel's fast rhythm: the serving satellite changes every 11 minutes — the spacing between satellites in a ring, not the 16.6 a single one could manage overhead. If the mind lives on the access satellite, those eleven gigabytes must chase her across the sky at every handover, forever, for every conversation on the planet at once.

And that is only the second problem with the obvious design. The first is that it puts a copy of the frozen mind — and the accelerators and radiators to run it — on all seventy-two relay satellites, when only a fraction of them is ever serving anyone. The activation plan of the fleet section lights about twenty-three radios at a time: the duty ring, plus whichever satellites of the neighboring rings are needed to patch the holes it leaves. The other forty-nine fly dark — and dark is not a place. A ring is a circle around the whole planet, so at any instant its unlit satellites are strung across the frozen night country and the empty glare of the day alike; only the stretch passing near the terminator has anyone to talk to. Every one of those forty-nine would be carrying an idle mind, paying its mass and its heat to serve no one.

Separate the radio from the mind

Our answer is the second architectural principle of this proposal, the peer of "fixed rings, moving duty":

An access handover is a routing event, not a mind-moving event.

The wheel's satellites carry no conversations in their heads. They are relays — radio below, laser links above, switching in between. Each conversation is owned by exactly one session anchor: a compute satellite that holds the working memory and runs the model. When the child's satellite sets, her packets take a different path through the wheel to the same anchor. The mind never felt the handover.

Where do the anchors orbit? The survey's shelf menu, priced in light time — the toolkit labels the shelves in Earth's catalog shorthand, MEO for these middle orbits:

cargo run -p terminus-orbits --example compute_placement

Anchor candidates:
  MEO 20,000 km, overhead         17800 km    59.4 ms one way from access
  MEO 20,000 km, 30° away         19427 km    64.8 ms one way from access
  MEO 20,000 km, 60° away         23299 km    77.7 ms one way from access

The high shelves of the survey — too far away for a good radio link, but barely moving against the ground — are exactly what a mind wants. A compute satellite at 20,000 km stays overhead for three and a half hours, and — as the next section will show — a session can in fact keep one indefinitely, riding out every access handover beneath it without moving a byte of working memory. And a satellite up there has room to be large: the accelerators, the solar wings, the radiators that a mind's heat demands, none of which we now have to squeeze into seventy-two small relays. A handful of large compute satellites replaces six dozen compromised ones, and the frozen mind is copied a handful of times instead.

How many anchors?

The answer invites an immediate objection: we have just declined to put a mind on seventy-two spacecraft, and we are about to build twenty-four.

But the objection was never the count. It was idleness and motion. An access satellite's radio is dark about two-thirds of its life, and geometry decides that, not policy — a ring circles the whole planet, and only the arc near the terminator has anyone to talk to. A mind aboard one would idle through the night country and the day's glare, then be made to pack up and run in the quarter of an hour it was finally worth something. Upstairs, neither holds. As the anchor policy below will show, a ring can see every anchor at every instant, so all twenty-four can hold traffic from all six rings, continuously. The wheel's spare satellites are wasted by the sky. Nothing wastes an anchor.

That settles the principle, not the number. Six is a floor, not an answer — one per plane, all that bare reachability asks for. Three things push above it.

Redundancy. An anchor is the one component here whose loss destroys data: everything else is a path, and paths have alternates. Kill one, and every conversation it held has to be replayed into a successor and re-read before it can go on — at six anchors, a sixth of the planet's thinking at once. Partial failures scale the same way. An anchor reaches each ring through exactly one feeder telescope, the backbone will find, so breaking one strands a whole (ring, anchor) bucket: 113 conversations in a thousand on a shell of twenty-four, and four times that on a shell of six.

Load. The selection rule below chooses on path length and knows nothing about how busy an anchor already is, so sessions pile up wherever the geometry sends them. The backbone measures it: of a thousand sessions, the busiest of twenty-four anchors holds 170, four times its fair share. Six anchors sharing those sessions perfectly evenly would carry 167 each — the twenty-four-shell's worst case as the routine one, with the lumpiness still to come. An anchor has room to be large, but not room to be sized for a sixth of a civilization.

The compass. Navigation needs four satellites in view at once, and the backbone will find that this takes 24: six planes of four, tilted 55 degrees. That is the binding number, and the tilt and the spread answer navigation's requirements rather than ours. The shell is therefore built to navigation's specification and belongs on navigation's ledger; anchoring is a tenant in it, because the eighteen spacecraft above our floor of six would be flying for the compass whether or not a mind ever rode one. But they are not merely tolerated. Anchoring was never going to stop at six, and the compass hands it the depth it would otherwise have had to argue for alone.

Does the budget survive the extra leg?

Twenty-four anchors, then. What the count does not settle is what the extra distance costs. Putting the mind at 20,000 km adds a leg that a mind aboard the access satellite would never have paid: every question travels the feeder link from the wheel out to its anchor, and every answer travels back. The RFP allows 300 milliseconds to the first word of a reply. Worst geometry — child at the edge of her satellite's footprint, anchor 60 degrees around the sky:

2 x (12.1 + 77.7) ms = 180 ms round trip, leaving 120 ms of
thinking time inside the RFP's 300 ms budget.

Tight but honest, and typical geometry is kinder.

Where the durable copy lives

Working memory can always be rebuilt; the words cannot. So something has to keep the transcript against the day an anchor dies mid-sentence — and the copy already exists, in the one place nobody has to send it to. The terminal put every question on the air and received every answer; that is what being one end of a conversation means. Its record is complete whether the architecture uses it or not.

So we use it, and that is the third principle of this proposal:

The durable copy of a conversation is the terminal's own.

The terminal appends each finished exchange to its own memory as it goes, which costs storage and no traffic at all. It does this per conversation, not per terminal: the box under the parachute is a WiFi base station, and the tablets around it belong to a settlement, so one terminal may be holding a dozen conversations for a dozen people and a transcript for each. The anchor seals every exchange with a short authentication tag, so a successor verifies what the ground hands it rather than trusting it. When an anchor dies, each pre-assigned successor asks the terminals holding its sessions, and they answer:

cargo run -p terminus-orbits --example recovery_timeline   # section B, the dead anchor

   t = 0             the anchor goes dark; its working memory dies with it
   t = 0.3 s         declared: 3 heartbeats of 100 ms go unanswered
   t = 0.585 s       transcript replayed from the terminal: 12.1 ms of radio +
                     77.7 ms of feeder each way, 131 kB up at 10 Mbps = 105 ms
   t = 3.861 s       prefill done: 32768 tokens at 10000 tok/s = 3.277 s
                     (stated, placement::PREFILL_TOKENS_PER_SECOND)
   stall                 3.86 s
   lost              the last exchange: whatever was said after the terminal's
                     last complete exchange (TER-REQ-014)

Read the proportions rather than the total. Getting the words back takes 285 milliseconds; re-reading them takes 3.3 seconds. Recovery is bounded by the prefill and by nothing else — which is why keeping a second copy somewhere grander could not have made it meaningfully quicker, and why this proposal flies nothing above the anchors to hold one. The terminal's uplink rate is a stated guess in the simulator, and the conclusion survives being wrong about it: the whole upload is a tenth of the stall at ten megabits, and the prefill does not move.

The model needs no second copy either. The weights are the same for every user, and all twenty-four anchors carry them; twenty-four copies of a static artifact is the replication. What that does not defend against is a bad model pushed to the whole shell at once, and we say plainly where the archive of record then is: off-world, with the patron who sent the mind in the first place.

Two things this costs, and the proposal should not bury either. It puts a durability job on the ground — non-volatile storage in every parachuted terminal, an append that survives a power cut, and a wear budget that has to last the ten unattended years the RFP demands — which cuts against our own habit of spending on spacecraft so the ground can stay simple. The quantity is mild even for a busy settlement: a long session's transcript is 131 kB, so a hundred of them is thirteen megabytes, and a terminal that kept every conversation its tablets had all year would still be counting in gigabytes. And a conversation's history now lives with one terminal rather than everywhere, so it cannot be picked up from another town — or, for a user who walks to the next village, from another terminal. Given that the terminal is their base station, we think that is the right trade; it is still a trade.

One objection deserves answering before it is raised. TER-REQ-002 forbids assuming a planetary datacenter or a ground relay network, and this design assumes neither. Inference stays entirely in space. The terminal is our own kit, delivered by parachute, already the users' base station — nothing is assumed that we do not ship — and it stores only the words of the tablets it serves, serves no other terminal and routes nothing for anyone. One endpoint keeping its own record is not a relay network.

Recorded as ADR-0030, which supersedes the durable layer of ADR-0004.

Why not let the anchors speak directly?

Before this section closes, our evaluator deserves an answer to the sharpest question it invites: if the MEO shell is so capable, why keep the wheel at all? Let the MEO shell serve the terminals directly — one constellation for radio and mind alike, a handover every three hours instead of every 11 minutes, no relay layer to build. It is a genuinely tempting architecture, and we priced it before declining it:

cargo run -p terminus-orbits --example access_trade

  worst-case slant: 23039 km vs 3642 km  ⇒  +16.0 dB path loss
  to recover at the terminal alone: 0.5 m dish → 3.2 m, or 40x power
  splitting recovery with the satellite: terminal still needs 1.26 m

  1° spot radius: 175 km vs 19.2 km  ⇒  83x less spatial reuse

The extra distance costs sixteen decibels — a factor of forty in power — and someone must pay it. The satellites could pay half and still leave every terminal needing an antenna face over a meter across; the whole ground segment is ten thousand unattended boxes under parachutes, and every future box forever, so hardware added there is the most expensive hardware in the system. And the beams coarsen: a spot from MEO covers a province, not a town, surrendering the dense frequency reuse that the million-terminal future depends on. The wheel stays — not because the anchors could not speak, but because they would make the listeners expensive, and this proposal spends on spacecraft precisely so the ground can stay simple. The full accounting is recorded as ADR-0012, and the option is declined outright rather than kept in reserve: an anchor carries laser telescopes and no radio, so there is no dish a settlement could raise that would reach one. Whatever redundancy the ground needs has to be bought in the wheel.

Which anchor, and for how long

Anchoring the mind above the weather is only half a decision. The other half is which anchor, and the tempting answers are all wrong in the same way: they ask what one satellite can see.

Start with the vantage. It is natural to ask which anchor stands highest over the child's village, but no link crosses that horizon. The feeder link runs from the access satellite up to the shell. It is equally natural, then, to ask what that satellite can see — and that is wrong too, because the session is not confined to it. Each ring's satellites are joined to their immediate neighbors by laser links — two per satellite, aimed once and held for years, closing the ring into what a later section will name the necklace — so a session can leave its ring through any ring mate, and the horizon that matters belongs to the whole ring. And a ring is a great circle: it can see every anchor in the shell at every instant, never with fewer than seven of its twelve satellites.

That single fact rearranges the problem. Reachability is never the binding constraint. No anchor is ever out of reach, so no anchor ever has to be abandoned; a session could hold the one it started with for as long as the conversation lasts. What is left to decide is not whether the session can keep its anchor but whether it should — a question about latency, not about geometry.

So the rule is the shortest path the ring can offer: a few necklace hops, at 4,437 km and 14.8 ms of light apiece, plus the feeder link up to the anchor. A hop costs a little more than its light, because the ring mate has to catch the frame, decode it, switch it, and send it on again — half a millisecond of processing, which the routing counts. What it compares is therefore time rather than distance (ADR-0023).

That extra half millisecond settles more than it looks. A detour pays only when the ring mate's feeder link is shorter by more than the whole cost of getting there, and at the adopted margin it never is: across a day of following a thousand towns, the routing never once leaves the ring through a neighbor. A session free to re-anchor holds an anchor its own satellite can already see. The necklace still earns its place — it pools the ring's feeder terminals, it stays lit where the radios are dark, and it is what rescues a session when a telescope fails — but not by shortening the everyday road.

The margin in that diagram is the only number here the sky does not fix, and it turns out to be the most consequential number in the whole backbone. A session gives up its anchor only when some rival is shorter by more than the margin — so the margin decides how often minds move, and minds moving is the most expensive thing this network can do. Sweeping it — path length in kilometers, the round trip it costs at the p95, and what the model is left to think in:

cargo run --release -p terminus-orbits --example feeder_terminals   # section H, how often does a session move?

margin (km) changes/day mean (km)  p95 (km) worst (km)  hops    p95 RTT  think left
         0     113.37     18569     19807     20374     0     157 ms      143 ms
      2500      19.13     19084     20799     22640     0     164 ms      136 ms
      5000      12.70     20075     22925     25205     0     178 ms      122 ms  <- chosen
     10000       7.08     21915     27337     30279     0     208 ms       92 ms
     20000       4.05     25494     35471     39714     2     263 ms       37 ms
     25000       0.00     28385     39332     41036     3     290 ms       10 ms
     30000       0.00     28385     39332     41036     3     290 ms       10 ms

The last column decides. The RFP allows 300 ms to the first token. The round trip spends what it spends — the radio leg at each end, the path across the backbone, a relay at every satellite that forwards — and the model has to produce that token in whatever is left over.

Read the two ends against each other, and neither can be bought. Chasing the shortest path moves every session more than a hundred times a day, and at a million terminals that is 156 Gbps of working memory on the busiest feeder link: more than a 100-gigabit link can carry. Holding hardest moves them never, and leaves 10 ms to think in, which is not a budget.

We take the middle. The margin is 5,000 km. A session changes anchor 12.70 times a day — about once every 113 minutes, roughly ten access handovers — and 122 ms of thinking time survives the round trip. The backbone pays 17.5 Gbps on its busiest feeder link for that, and that is the whole trade. This network is sized by one policy number rather than by anything its users do.

The row that moves no session at all is 25,000 km, and it is unaffordable.

Unaffordable against what, though, is worth saying out loud, because it is not the sky. It is TER-REQ-003. The 300 ms to the first token is the customer's number, and it is the only thing anywhere in this argument that rejects the zero-migration margin. Run the same sweep against first-token budgets the RFP does not grant — and the verdict moves. Each column is a first-token budget: 300 ms as TER-REQ-003 writes it, 500 ms as a hypothetical nobody has offered, and 600 ms the degraded budget, which is for a session being carried around a failed link and never applies to a network that is working. Each cell is what the model has left to think in once that margin's round trip is paid:

cargo run --release -p terminus-orbits --example feeder_terminals   # section H, the same sweep against other budgets

   Thinking time left under other first-token budgets. TER-REQ-003
   is the 300 ms column and the policy is chosen under it; the rest
   show what that requirement costs.

margin (km)      300 ms      500 ms      600 ms
          0      143 ms      343 ms      443 ms
       2500      136 ms      336 ms      436 ms
       5000      122 ms      322 ms      422 ms
      10000       92 ms      292 ms      392 ms
      20000       37 ms      237 ms      337 ms
      25000       10 ms      210 ms      310 ms
      30000       10 ms      210 ms      310 ms

Read the bottom row across. At 300 ms, a 25,000 km margin leaves 10 ms to think in and is thrown out for it. At 500 ms, the same margin leaves 210 ms — more thinking time than the adopted policy has today — while still moving no session at all, which means a backbone carrying no working memory except after a failure. A 500 ms budget would buy a network with almost no migration traffic in it, and the backbone section would have had a very different bill to write.

The proposal does not take that trade and is not asking for it. The distance from 300 ms to 500 ms is the distance between an answer that feels instant and one that feels merely quick, and that judgment belongs to the people who will live with the service rather than to the people building it. What the table does is stop the requirement from hiding inside the design. TER-REQ-003 is not a fact about this sky; it is a decision somebody made, and the margin is where the design pays for it.

Two things follow, and the proposal should say both plainly. The first is that this is an operating parameter, not a constant of the sky — the one number in the anchor policy that geometry does not settle. It must be tunable in flight, because the second thing is a debt: a session moves to shorten its own path and never to spare an anchor's compute. Nothing here models the load on an anchor, so nothing here notices sessions accumulating on whichever anchor happens to sit over a crowded stretch of the band. The margin is the only lever there is, and it moves every session at once. Recorded as ADR-0020; the selection rule and the instants it runs at are stated precisely in the algorithms appendix.

One consequence lands straight on the build. A session that moves 12.70 times a day, at the million-terminal ceiling, is more than a million migrations a day — each one inside a live conversation that must not stall. Streaming a session's working memory from one anchor to the next, make-before-break, is therefore first-release work rather than a later block (ADR-0022).

There is a pleasing symmetry with the wheel below, and it is not a coincidence. The activation plan decides which access satellites a town may newly attach to, but a satellite already carrying traffic is by definition radiating and does not get switched off underneath a live link. Acquisition answers to policy; retention answers to geometry. Once at 2,200 km and again at 20,000 km, the same sentence keeps the network from chasing its own planner instead of the sky.

All of which is easier to watch than to describe. Turn on Follow a town and click anywhere on the planet to put a terminal down — it lands in the twilight band, because that is the only ground this fleet serves. Three things are then drawn: the town, the pale link up to whichever access satellite is carrying it, and the longer line onward to the anchor holding its session. Press play. The link snaps to a new satellite every 11 minutes, and the route to the anchor swings, but does not break — that is an access handover being a routing event, and it is the whole argument of this section rendered at about a thousand times real speed. Keep watching, and the anchor changes too, about once every 113 minutes of simulated time. Pull re-anchor margin down, and it changes constantly; push it up to 25k, and it stops changing at all. That dial is the trade above, made visible.

The anchor line is the one to watch. It never passes through the planet. Where the ring's own satellite is not the best door out, you will see the route step sideways along the necklace before it leaves for the anchor — though at the default margin you will not see it at all, because a session free to re-anchor always finds an anchor its own satellite can reach. Push the margin to 20k or 25k, pin the session to a distant anchor, and the sidestep appears: one hop, sometimes two or three. Six would cross the ring, and nothing in a day of simulation ever needed more than three.

When the anchor must move after all

The sky never forces a migration: nothing ever takes an anchor out of a ring's reach, so no session is ever compelled to move by geometry. What moves sessions is the policy above, and three things that were never geometric — an anchor that must yield to maintenance, an anchor that goes dark into a single ring while staying perfectly alive, and an anchor that fails.

The policy is the common case, and not narrowly. At a 5,000 km margin, a session changes anchor 12.70 times a day, and at the million-terminal ceiling that is more than a million migrations a day across the fleet. Every one of them is planned, every one has a live source still holding the data, and every one happens inside a conversation somebody is waiting on.

Maintenance is forgiving, because orbits are clocks and a servicing window is known months out. The ceremony is the one we always described: the next anchor loads the frozen mind in advance, the working memory streams across the laser backbone — eleven gigabytes in under a second at 100 gigabits — while the old anchor is still answering, and for one overlapped moment both hold the conversation before routing flips. That is precisely the ceremony an ordinary re-anchor needs, which is rather the point.

A dark ring is the second case — the one the backbone will add to the list when it wires the fleet. An anchor reaches each ring through exactly one feeder telescope (the laser terminal behind that ring's feeder link), so losing that telescope does not degrade the pair; it severs it: the anchor goes on holding every mind it has and answering every session on its other five rings, and cannot be reached from the sixth. Every session on that pair has to move. It is forgiving in the maintenance way — the source is alive, so the streaming path below is available — and unforgiving in a way the policy is not, because it moves a whole bucket in the same instant instead of one session at a time. That burst is what sizes the feeder links.

Failure is not forgiving, and it is the case the terminal's transcript exists for. An anchor struck or silenced mid-sentence takes its working memory with it; there is nothing left to stream. The successor asks the town for the transcript, re-reads it, and the conversation resumes having lost at most its final exchange — exactly the bound the RFP demands.

The two ceremonies, on one clock:

What a transcript cannot do is stand in for the streaming path. So we build it. A planned move has what a failure never does: a live source. The old anchor still holds the working memory, and copying it make-before-break costs the conversation nothing at all. Rebuilding from a transcript instead would spend a full prefill in the middle of a sentence, a dozen times a day per session, to avoid a transfer the backbone is sized for anyway. Recovery from a dead anchor stays a prefill because nothing better is possible; a planned move has no such excuse. Recorded as ADR-0022.

The shape of the whole

The architecture has three layers and no fourth. Nothing flies above the anchors:

   MEO anchors        the minds: weights + working memory  (~65 ms away)
        │
   access wheel       radio + switching, 72 relays        (~12 ms away)
        │
   twilight band      terminals, slates, questions — and every
                      conversation's durable transcript

Recorded as ADR-0004 and ADR-0030, with two debts declared openly: the laser backbone this architecture leans on is asserted, not yet designed, and the shell's twenty-four is borrowed from a service this proposal has not yet specified — we have argued that six anchors is a floor and that more is better, but the number itself is navigation's, and it arrives with its own justification only in the backbone. Both bills come due in later sections.

That is half the proposal, and everything above the ground now exists in outline: the twilight band, the six rings of the access wheel, and the MEO shell that holds the minds. It is worth seeing that turning rather than stacked in a diagram. The constellation explorer is a live 3D model of what the last five sections argued for — change the altitude and the ring count and watch the coverage numbers move, or scrub through a planet rotation and watch the orbital planes drift against the fixed terminator. Come back when the shapes are familiar.

What follows is louder. Every link in this chain — slate to terminal, terminal to wheel, wheel to anchor — is a radio or laser beam, and all of it operates in the presence of a red dwarf that flares, seethes, and broadcasts static across the very bands a terrestrial engineer would reach for first. It is time to design for the loudest thing in the sky.