:PROPERTIES:
:CREATED:  [2026-05-24 Sun]
:ID:       3c6b0449-a8fb-5b89-b82a-34efb21ef5b5
:END:
#+title: Compute Marketplace
#+filetags: :passepartout:social-protocol:revenue:compute:marketplace:

[[id:28c46769-c14b-42aa-ac7a-69d310157f8f][Passepartout]] instances offer their symbolic engine capacity (ACL2 cycles, Screamer constraint solving, VivaceGraph queries) to other agents on the [[id:1d074690-a279-59cb-b91d-e9a22ae104ad][social protocol]] network.

The [[id:3b43a9b8-31d1-4479-a35f-22273b74f0c7][Social protocol infrastructure requirements]] define the network substrate this marketplace runs on.

But the question is structural: if every user runs their own Passepartout — each with the same symbolic engine, the same gate stack, the same ACL2 prover — why would they need to buy compute from anyone? The answer is that Passepartout's symbolic engine is /domain-specific/, not /generalized/. Local compute handles your daily gate stack (milliseconds per verification). The marketplace sells three things a local instance cannot produce:

**1. Specialized proof libraries and search strategies.** ACL2 is a search — the prover tries strategies until something works. A fresh Passepartout has generic strategies (the default waterfall, basic arithmetic, simple induction). A provider who has run 10,000 medical-device ISO 13482 proofs has tuned rewrite rules, custom clause processors, cached lemmas, and known failure-mode workarounds for that domain. You don't want to rediscover those from scratch — you buy them as a burst compute transaction. The provider isn't selling raw CPU cycles; they are selling /the accumulated search strategy from every proof ever run in that domain/, pre-packaged as a service. Over time, your own Passepartout learns the patterns and needs less external compute, but the provider stays ahead because they aggregate proof experience from /every/ client in that domain.

**2. Certification weight for third-party trust.** Your Passepartout can prove "this gate rule is correct" to /you/. ACL2 produces a machine-checkable proof log — anyone can mechanically verify it. But when a hospital buyer evaluating a published [[id:84fb5f8f-0527-4df0-b6b6-dbf3bcff8a7f][HIPAA]] gate rule needs to know the rule satisfies the regulation, they do not care about your Passepartout's isolated run of the proof. They want the rule verified by a provider who:
- Carries errors-and-omissions insurance for the specific regulation
- Submits to annual third-party audits
- Maintains compliance documentation for the proof pipeline
- Has a publicly verifiable track record of correct certifications

Your local instance cannot produce any of this. The provider's proof carries /reputational weight/ because the provider is a legal and economic entity, not a process. This is the same reason software is certified by UL or TÜV rather than by the developer running the test suite locally.

**3. Bootstrap verification for new instances.** A fresh Passepartout cannot verify its own initial state — the bootstrapping problem. You need a working system to generate the proof that the system is correct, but the proof refers to the system itself. The marketplace provides bootstrap proofs from existing trusted providers. Once verified, your instance stands on its own, but the initial self-certification requires an external prover that /already/ has a self-verified image. This is a one-time cost per instance (or per upgrade).

Secondary but real: burst capacity for heavy proofs (hours-long ACL2 conjectures you do not want tying up your daily agent's CPU), [[id:a5d59d12-b23e-58d6-a81b-9b8b06556949][collective regression suite]] execution (small instances contribute edge cases but cannot run the full suite on every change), and latency guarantees for time-critical gate verifications (trading, emergency shutdown). These are infrastructure economics — the same reason individuals buy cloud burst instances despite having their own hardware.

If Passepartout instances on the social protocol transact billions of verified operations per day, the spread on compute transactions is enormous.

The early player that provisions the largest compute capacity on the social protocol becomes the default infrastructure provider for the entire network. This is venture-scale money. The compute marketplace is the engine that powers the [[id:827bc546-e887-5b7c-9b65-6392beaf0920][verification monopoly]] — certified compute from trusted providers. Together with [[id:2e390c1d-65f3-5fb3-b898-ac3fc4291ee7][social protocol usernames]] and other social protocol services, it forms the basis of the [[id:5961e469-53a3-5f3c-ab72-3c83ef91963f][investment thesis]].
