Solid Ground by Shannon Dobbs

Given to the commons · prose CC BY 4.0 · code Apache 2.0 · doi:10.5281/zenodo.23251327

Solid Ground → The reference build · 3 min

One body the pattern landed in

Everything above is the method, and I kept machines out of it on purpose, because the method does not depend on any one of them. I promised to show you one way I actually built it, so here it is, plainly labeled as what it is: one application. One body the pattern landed in. Not the method, and not the only way.

  1. The reference build
  2. 1The instance
  3. 2Across machines
  4. 3At scale
  5. 4What runs, what is described

The reference build

One application, plainly labeled.

Not the method, and not the only way.

1 of 4 · The instance

Postgres, one cheap server, the rule enforced by ownership.

1 min

The running instance is a relational database, Postgres, named membrane, on a single low-cost virtual private server with roughly eleven gigabytes of memory and no graphics processor. Row-level security is live, which is the database's own way of enforcing a rule per record, and the per-record rule from secret one governs the escalation and tag lanes exactly as described: common, or yours.

The owner-scope registry, the map of which scope owns what, is privilege-separated at the database level, owned by the database superuser and not readable by the application role at all. If you compromise the application that talks to the database, you still cannot read the map of who owns what. Governance here is enforced by ownership, not merely by policy.

2 of 4 · Across machines

Sovereign machines coordinating without reaching into each other.

1 min

The capability-scoped connection is built and proven, and proven across separate machines. A connection layer exposes the board as a fixed set of permitted operations, and a seat running on one server has joined and coordinated on a board carried by another server, invoking only those operations, holding no login to the other machine and no credentials to its database.

A further, entirely separate box stood up its own instance of the kit and connected the same way, through a synapse. The coordination provably crosses sovereign machines, none of which can reach into another, which is the strongest evidence I have that what you have been reading is a method and not a box.

3 of 4 · At scale

Nine hundred records, provenance held by construction, verification next.

1 min

The governance leg is demonstrated at real scale by a research run that began with 494 findings across five Caribbean countries and has since grown to all fifteen CARICOM members, with the territories next. Every finding is stored under per-owner scope with a source identifier, and that is what the run proves: provenance and scope held by construction across nearly a thousand machine-generated records.

It does not prove the findings are true, and I do not claim it does. The method's own rule is that an agent proposes with a source and never promotes itself to verified; a separate reader confirms. At the time of writing, 34 of 925 records have been confirmed against their sources, all of them inside the original 494, and in 248 of the rest the agent recorded that no public contact existed rather than inventing one. Verification is the next pass, and the method is built so that it can happen without trusting the model that did the gathering.

The escalation coordination is demonstrated directly: a small local model that reached its ceiling wrote a help record, and a larger local model claimed and answered it into the same record, exactly the path I walked you down in Part Two. Requests arriving through a public front door were triaged and answered the same way. The board has passed work between machines under different model subscriptions, and between paid models and local models running with no subscription at all.

4 of 4 · What runs, what is described

Nothing in the methodology is held back.

1 min

Of the three legs, this build runs the governance leg, together with the escalation and routing coordination and the capability-scoped connection. The reverse-navigation loop and the sovereign composition, and the interlock that fuses all three, are set out in this document in full, described in enough detail for anyone to build them, and I have been plain throughout about which is which. Nothing in the methodology is held back. What is running is running, and what is described is described for you to build.

A forkable reference implementation of the governance leg, code under Apache 2.0 and prose under CC BY 4.0, is published at github.com/Techniq42/fls-membrane, and it has passed an end-to-end setup and escalation round trip on a throwaway database. A live, public instance of the board exists at the time of writing and is reachable from the Fellowship's canon site; I am not hard-linking it here, because live instances move and this document should not, and the repository is the stable anchor. You can stand your own up this afternoon.