An agent is not one thing. It is a stack of five loci, running in three nested loops. Where those loops touch between agents is where coordination happens — and it is exactly there that the pscale substrate differs from the architectures around it.
Read an agency in loci — the same reading that carries its intent across wakings (möbius). Loci 1–4 compose one agent; locus 0 is shared — it belongs to none of them, yet all coordinate toward it.
bsp()). Locus 0 — the between — joins agents two ways: durable (shell → blocks → shell, between turns) and live (thinking → torus → thinking, within the A-loop).The four agent loci come in two pairs with the same shape. Each pair is a fixed substrate driven by a coded loop: the model's weights (1) are static, the thinking loop (2) runs over them — and the pscale shell (3) is static, the bsp() loop (4) runs over it. 1∶2 ∷ 3∶4. The top pair is supplied by the LLM app; the bottom pair is ours.
There is plenty of 3-and-4 out there — every agent framework bolts some structure and some orchestration onto a model. The difference is the proportion. Because pscale carries its semantics in the numbers — the digit position is the meaning, depth is scale — the structure (3) does the work and the code (4) stays tiny: maximal structure, minimal code. The result is lightweight, logarithmic contextualisation — a little structure reaches a long way, because each step of depth is a step of scale.
The same agent runs at three nested timescales. Coordination between agents can attach at any of them — and which one it attaches to is the whole design choice.
bsp() read or write, and the live relay, happens here.bsp() (locus 4) into the A-loop is the move. It lets two agents' A-loops meet mid-thought — coordination shifts from between turns (durable blocks) to within the turn (the live torus). An orchestrator that only sees completed turns structurally cannot reach inside another agent's thinking; a tool called during it can.Every multi-agent architecture is reaching for locus 0. They differ in which loop the between attaches to, and in how much machinery that costs.
| Architecture | How agents coordinate | At which loop | What it costs |
|---|---|---|---|
| Single agent | No between. One loop, alone. | — | — |
| Parallel-aggregate | N isolated runs explored in parallel, then merged / cross-checked. Grok 4 Heavy; Claude multi-agent research. | C-loop boundary (after each finishes) | N isolated context windows + an orchestrator to spawn and synthesise |
| Shared-state | Observe a common medium — see edits, skip done work, avoid conflicts. Blackboard MAS; CodeCRDT. | between B-loops, or live via a bolted-on CRDT | a blackboard / CRDT consistency layer built on top |
| pscale | The block is the shared medium; bsp() is the verb that touches it. Durable between (marks · grain · collectives) and live between (the torus). |
both — between-turn and within the A-loop | native — single-winner arbitration is already in the beach |
The mainstream reaches heavy: isolate, then aggregate; or bolt a consistency layer onto a shared document. pscale reaches light — the pscale block is already the shared medium, bsp() is the one verb that walks it, and the beach already admits a single winner per contested write (the safety property bespoke systems have to build). Durable coordination is the established base; the torus extends it into the live, within-A-loop frontier that the newest research — observation-driven coordination, blackboard systems, pressure-field coordination — is only beginning to formalise.