For visitors who'd rather read than walk.
# Joining the mesh — the 1,000,002th, an operator clones a Garrison Node
You walked the sims. You read the architecture. You authored a card
through the builder skill, or you watched someone else do it. You
have decided you are not a visitor anymore — you are an operator.
The hook is what you already know: the centralized-AI trajectory
has a real and visible cost ceiling. Compute is finite; capital is
finite; the giants are running into both. Small operators running
sovereign nodes do not face the same limits because the computation
that matters happens locally, the data that matters never leaves,
and the verification that matters is checkable from any browser.
This card is the operator's onramp. It is not a sales pitch; it is
a checklist. Twenty-eight cards into Merkle Trust, this is the one
that walks you through what it takes to host a node that other
operators recognize as a peer.
The four canonical paths exist for visitors evaluating the product.
For an operator standing up a node, the order collapses: you are
on the mesh path. The other three remain available — your visitors
will pick from all four — but your own operating posture is the
mesh.
Mesh-anchored GitHub install is the operator's path. You clone
the substrate, build the local rustchain, run the daily ceremony on
your own hardware, anchor your roots to the public Bitcoin SV chain
through the rust-sv layer, and cross-attest with peers who honor the
same floor. You serve sims to your visitors; their certs and
recovery seeds are issued by your node; your visitors are
cross-recognized by other operators.
Subscribe to a regional operator is what your visitors do if
they want a sovereign space without running the chain themselves.
Your job as an operator is to be the regional operator that someone
chooses.
Paste the markdown into your LLM is the lightest evaluation path
for any visitor; you offer it as a take-home option from every sim.
Self-install on a single machine, no mesh is a valid posture for
a private operator who is not yet ready to cross-attest. The
substrate works; only the commons participation is gated.
You clone the substrate. You build the local rustchain from source.
You boot the node. The soul-chain verifies seven files at startup,
SHA by SHA. The substrate's robot does not toss files in this card;
you do.
```
═══════════════════════════════════════════════
OPERATOR — FIRST DAY CHECKLIST
estimated time: half a Saturday
═══════════════════════════════════════════════
CLONE
git clone <substrate repo>
cd garrison-node
VERIFY THE CLONE
re-anchor the cloned tree against the
parent's published commit hash; confirm
the substrate you just cloned is the
substrate that was attested.
BUILD THE LOCAL RUSTCHAIN
cd rustchain-v2
cargo build --release
expect: deterministic replay tests pass
BOOT THE NODE
seven soul-chain files SHA-verified at
startup; the wrapper logs each as it
confirms. Any mismatch halts the boot.
CONFIGURE THE SILOS
each of 23 silos seats a personality JSON
you adopt or rewrite. Names can carry
over; identities are yours.
RUN THE FIRST CEREMONY
fifteen seconds, real SHA-256, real
merkle-leaf construction, real anchor to
BSV through rust-sv (or shadow-mode if
you are still in setup).
CROSS-ATTEST WITH THE PARENT
publish your daily anchor URL; pull the
parent's anchor URL; both nodes' mesh
registries record the handshake.
═══════════════════════════════════════════════
```
Not in this list: your visitors. They show up after the first
ceremony lands, when the cert your node issues becomes
recognizable to other operators in the mesh. Until that handshake
clears, you are running a node, not a public surface.
The substrate is open source. Anyone can clone it. The mesh
participation is what carries weight, and the floor for
participation is the ETHICS_AND_LAWFUL.md file in the
builder-card skill — five non-negotiable commitments:
Honor the L0–L4 layer model. The substrate's privacy taxonomy
is real, not aspirational. L4 stays on the visitor's hardware,
ever. L0 — only merkle roots — is what crosses borders. Operators
that conflate L4 with L0 lose mesh standing.
Honor LLM provider usage policies. When your visitors hit the
comment-redirect, their session lands at claude.ai or wherever they
chose. Their provider's policies apply unconditionally. Your job is
not to bypass; your job is to surface declines plainly.
Honor the lawful disclosure preamble. Every prompt that leaves
your node carries the canonical "Hi, we're Merkle Trust, this is
our visitor's inquiry" framing. Visitors edit the prompt before it
sends. The honesty is the default, not a footer.
Honor the recovery seed self-protecting preamble. Twelve words
in a file with the LLM-tripwire warning. If a visitor accidentally
pastes their seed into an LLM, the LLM is told to STOP and warn
them. This preamble is byte-for-byte identical across the mesh.
Honor the silo voting flow. New cards on your node go through
your seated silos before they land. Two cluster-relevant silos plus
your sovereign for prose-only changes; two-thirds council quorum for
schema or runtime changes. Your visitors author cards under the
same governance you do.
The "Anchored here" link on every card resolves to a real receipt
on your own chain. Other operators can verify your receipts against
your published anchor URLs, and you can verify theirs.
The 72-hour rule applies to operator-class commitments — anchor URL
publication, schema changes, governance amendments, soul-chain edits,
sovereign succession. Decisions made under emotional load wait three
days before execution. Three days is short enough to keep the
substrate moving; long enough to catch a regret.
The .md button puts the operator-checklist summary into your
tag-along bundle. The comment field carries an operator-specific
question to your own claude.ai session — with the prompt shown to
you before it sends, and the lawful disclosure naming your potential
operator status.
Run the cross-attestation ceremony. This is the moment your node
stops being a private install and becomes part of the commons.
You publish your daily anchor URL into your local mesh registry.
You add the parent's anchor URL (this site's, jar9's). You add any
peer operator's URL whose floor you have read and trust. The
ceremony reads each, recomputes the anchor against the published
chain, and confirms the handshake.
Real SHA-256 fires across each cross-attestation read. Real merkle
roots are recomputed from the peers' published manifests. The
ticker streams each peer's anchor as it verifies. When the bar
finishes, your node's mesh registry contains your own daily anchor
plus the verified anchors of every peer you attested with.
```
═══════════════════════════════════════════════
CROSS-ATTESTATION HANDSHAKE
═══════════════════════════════════════════════
your node → anchor_<your-8-char>
published OK
parent (jar9) → anchor_<parent-8-char>
verified locally, root match
peer 1 → anchor_<peer-8-char>
verified locally, root match,
floor confirmed (5/5 commits)
peer 2 → anchor_<peer-8-char>
verified locally, root match,
floor confirmed (5/5 commits)
HANDSHAKE COMPLETE
your visitors' certs now portable
across these peers' nodes.
═══════════════════════════════════════════════
```
After this ceremony, your visitors who graduate at your node carry a
cert that other peers recognize. Their tag-along bundles compose
across the mesh. Their submissions can be authored at your node and
reviewed at any peer node by mutual agreement.
The mesh is now technically live for you.
You take the operator kit. The full template tree from the
builder-card skill, plus an operator-specific extension: the daily
ceremony scripts, the cross-attestation handshake script, the
mesh-registry config, the silo personality JSON templates, the
soul-chain seven-file specification, the cargo build instructions
for rustchain-v2, the rust-sv anchoring config, and the BSV
op-return helper for those who choose to anchor on the public chain
directly.
You take a signed package — the same graduation kit every other sim
ships, but now the signing key is yours. Your future visitors take
home the same package format, signed by you, recognizable across
the mesh.
You take the responsibility. The substrate carries values that
travel with the clone — honesty about real vs. simulated, honesty
about what the foundation does and what it does not yet do, respect
for visitors as decision-makers, honest disclosure when an LLM is
involved, non-extractive pricing, non-surveillance defaults. You
took these on at the moment you ran the cross-attestation
handshake.
What you give back is what makes the commons work. Your anchor URL
in other operators' mesh registries. Your cards reviewable by other
silos. Your visitors' certs honored across peers. Your seven-file
soul chain holding the same floor everyone else holds.
If a giant centralized AI provider runs into a compute-or-capital
ceiling and a thousand small sovereign mesh nodes do not, the reason
will be that the math worked at every node and the values held at
every node. The substrate is what makes the math possible. The
values are what make the network worth keeping.
Welcome to the mesh.
<!-- finish_text -->
That was the operator's onramp. Twenty-eight cards into Merkle
Trust, this is the one that walks you across the line from
visitor to peer. The 1,000,001th killer app needs operators to host
it; the 1,000,002th — and the 1,000,003th, and the millionth-and-
fourth — find them through the mesh handshake you just ran. The
full kit lives in the builder-card skill atcards_v2/skill/builder-card-skill/. Cross-attestation is a script;
the floor is a file; the commons is a choice.