---

title: Franklin as Substrate's Operator and Cell's Surface

audience: substrate_engineers_and_substrate_developers

game: WIKI-FRANKLIN-AS-CELL-SURFACE-001

contract_version: 1.0.0

authority_kind: normative

---

Franklin as Substrate's Operator and Cell's Surface

What this page is for: documenting the architectural property that Franklin is the sovereign substrate orchestrator, the substrate's operator, AND the cell's only public interface — and the substrate-development vocabulary alignment that names Franklin as the operator across every substrate-development surface.

Patents: USPTO 19/460,960 · USPTO 19/096,071 — © 2026 Richard Gillespie

Substrate-mathematical context: Franklin is the substrate's
computationally bounded, time-persistent observer — see
Observer-Dependent Emergence —
and composes the substrate mechanoidally, channeling rather than mixing —
see The Mechanoidal Phase.

---

The doctrine, in one paragraph

Franklin is the sovereign substrate orchestrator (Franklin authorizes substrate-development autonomously within bounded authority), the substrate's operator (substrate-development work is Franklin's work, not commissions Franklin reviews), AND the cell's only public interface (the daemon's load-bearing call sites route exclusively through FranklinCellSurface's actor surface). Substrate components — Bitcoin RPC, joint variation cursor, measurement orchestrator, between-collapse filter, schema writers, federation cosignature, NATS broadcaster — are internal implementation details inside Franklin's object boundary.

---

What this changed

Vocabulary alignment (V186)

The substrate-development state machine is named in Franklin-operator vocabulary:

Old vocabulary (pre-V185) Sovereign-Franklin (V185) Franklin-operator (V186, current)
proposed proposed franklin_proposed
operator_authorized franklin_authorized franklin_operator_authorized
agent_in_development substrate_in_development substrate_developing
landed landed substrate_development_complete
franklin_authority_active franklin_authority_active franklin_operating
operator_rejected franklin_rejected franklin_operator_rejected
(n/a) rolled_back franklin_operator_rolled_back

Swift class identifiers across substrate-development surfaces:

CLI subcommand surface: gaiaftcl franklin commissions/commission → gaiaftcl franklin operations/operation. Schema CHECK constraints rewritten via V186 migration (translating existing rows forward byte-exact through CASE expressions).

Franklin as cell's surface — Categories A through F

The daemon's load-bearing call sites route through FranklinCellSurface:

Category Franklin surface methods What was bypass-routed before
A — Bitcoin RPC bindBitcoinNodeClient, bitcoinBestBlockHash, bitcoinBlockTemplate, submitBitcoinBlock Daemon held BitcoinNodeClient and called node.getBlockTemplate / node.submitBlock directly.
B — Joint variation composition advanceProductionSubmissionPath, composePerMeasurementBlock, advanceJointVariationCursor, validateSubmissionTarget, serializeHeader80 Daemon constructed BitcoinSubmissionBuilder, HeaderSerializer, SubmissionValidator and called cursor.advance() directly.
C — Measurement orchestrator composeQC020Measurement, qc020CurrentWindowStatsCanonical Daemon called QC020GateInvocation.shared.invoke directly.
D — Between-collapse filter applyBetweenCollapseFilter, pendingFilterFor Daemon and QC020GateInvocation called FranklinWindowFilteringOperation.shared directly.
E — Schema writer dispatch persistConstitutionalEvaluation, persistPerAlgorithmAllocationAudit, persistJointVariationEvidence, persistViaPool, readViaPool Daemon called *Writer.shared.persist* and direct pool.write SQL against the substrate database.
F — Subsystem boot bootSubsystems, bindConstitutionalWriterSession, bindPerAlgorithmAllocationWriterSession Daemon called 8+ direct spawn() and .setSession() plumbing.

The daemon's runJointVariationMeasurement reads as a thin call-through:

guard let outcome = await FranklinCellSurface.shared
    .advanceProductionSubmissionPath(
        currentCursor: cursor,
        template: template,
        payoutScriptPubKey: walletScriptPubKey,
        sessionIDPrefix: String(sessionID.prefix(8)))
else { /* ... */ }

FranklinCellSurface.advanceProductionSubmissionPath internally composes:

1. composePerMeasurementBlock → coinbase composer + merkle root composer + header serializer

2. composeQC020Measurement → substrate measurement orchestrator (QC020GateInvocation as Franklin's internal implementation)

3. advanceJointVariationCursor → cursor advances under Franklin's bias

CALORIE outcomes route through submitBitcoinBlock; V178 evidence routes through persistJointVariationEvidence. The substrate component complexity is encapsulated inside Franklin's actor boundary.

---

Sovereign substrate-development cycle

Franklin's heartbeat fires every 60 seconds. Steps 9–12 of the heartbeat run the sovereign substrate-development cycle autonomously:

V184 heartbeat records per-tick counters: commissions_franklin_authorized, commissions_implemented_by_substrate_developer, commissions_activated, commissions_rolled_back (legacy column names; V186 vocabulary applies to schema state strings).

Operator role across this cycle is bounded-authority definition (the bounds file itself) and constitutional refusal sets (the substrate-development decisions Franklin will never make: foundational eight invariant modification, substrate capacity beyond host limits, constitutional floor predicate removal, federation cosignature disabling, append-only persistence disabling).

---

Operational evidence

Live mining cadence through Franklin's surface, sampled 2026-06-01T15:11:59Z (PID 19844 launchd-managed, 22m elapsed):

submitblock RPC integration through Franklin's submitBitcoinBlock is wired and will fire when the substrate composes a target-satisfying tuple.

---

What is forbidden across substrate-development surfaces

Per CLAUDE.md doctrine (locked):

---

Files of record

---

For industry consumers

Industry consumers integrate with the substrate from Python through the federation-verified Python-Wrappers section. The Python client reads through Franklin's surface (substrate-resident SQLite) and surfaces every row with federation cosignature verification. Eight bridges (numpy / pandas / sklearn / biopython / rdkit / ase / pymatgen / root) integrate the substrate's outputs with the ecosystem libraries consumers already use.

Federation cosignature: pending operator signing host (v26). Witness (sha256 of rendered body): 59532ca4d553c6a7237b3b0deebc4a12ee749319b45f570a55a0204febe162e4. This page serves with a substrate-honest pending-signature notice until the operator's Franklin signer cosigns it.