Trustless Sovereign Custody (TSC)
Trustless Sovereign Custody (TSC) is a deployment model in which an institution holds all of its wallet key material in its own environment and verifies every transaction before its keys sign it. The keys sit in the institution's HSM or on-premises MPC, and its own approvers sign every request and policy change. Utila runs the platform but cannot move funds, alter an approved transaction or change the policy.

The Problem TSC Solves
When a platform builds a blockchain transaction, the signer never signs the transaction itself. It signs a hash of it, a 32-byte fingerprint that can't be turned back into the transaction. An approver looking at a hash sees nothing about the destination, the asset or the amount, so they rely on the metadata the platform displays next to it.
In most wallet infrastructure, that means trusting the vendor's software to build each transaction exactly as requested, evaluate the policy as written and show approvers what they are actually signing. Running the whole stack yourself removes that dependency but brings the cost of building and maintaining it.
For a licensed institution this matters because it answers to its regulator for what its vendors' systems did, under frameworks such as DORA and MiCA in the EU. TSC keeps the hosted operating model and lets the institution prove that every signature matched what its people approved.
Sovereign and Trustless
The name describes two separate guarantees.
Sovereign answers who holds the keys. All wallet key material is generated and held in the institution's environment, either in its own HSMs or as on-premises MPC key shares. Utila holds public material only, enough to derive addresses and build transactions.
Trustless answers who decides what those keys sign. Every transaction request, approval and policy change is signed with keys belonging to the institution's own people. Software running in the institution's environment checks each signature, and the transaction itself, before any wallet key is used.
How a Transaction Gets Signed
Request. An initiator composes a transaction intent (source wallet, destination, asset, amount) in an authorization client the institution runs, and signs it with a personal authorization key before Utila receives it.
Approve. Utila routes the intent to the approvers the policy requires. Each approver's client reads the intent bytes itself and the approver signs the same intent.
Build. Utila runs screening, builds the transaction and bundles it with the signed intent and approvals.
Verify. An enforcement point in the institution's environment collects the bundle. It checks every signature against the institution's signed policy, rebuilds the transaction from the intent and compares it byte for byte with what Utila built, then checks the policy rules.
Sign. Only if every check passes does the enforcement point ask the HSM or MPC deployment for a signature. Utila then broadcasts the signed transaction.
If Utila's backend built anything other than what was approved, the bytes don't match and nothing is signed. No person has to spot the difference.
Policy follows the same rule. Each policy version needs signatures from the institution's administrators at the threshold they set, and each version is checked against the one before it, back to the first version created with the vault.

TSC Deployment Models
Model | Where the keys are | Wallet tier |
|---|---|---|
HSM Vault | In the institution's own certified hardware security modules, on-premises or in the cloud | Hot and warm |
Air-Gapped HSM Vault | In the same certified hardware with no network path, signing in human-attended sessions | Cold |
On-Prem MPC | As MPC key shares, all in the institution's infrastructure and spread across locations | Hot and warm |
The trust model is the same in all three. Institutions can run them side by side, each vault with its own administrators and policy, for example an air-gapped vault for cold storage next to an HSM Vault for daily flows.
What the Institution Can Verify
The enforcement point and authorization client are Utila software running inside the institution's trust boundary, so the architecture makes them checkable. [CONFIRM: available at launch?] Both ship with their source code and reproducible builds, so the institution can rebuild them and compare hashes. Utila publishes the schemas for intents, policies and verification rules, and third-party audits cover the verification logic. [CONFIRM: audit completed and nameable before publishing]
Continuity doesn't depend on Utila either. A platform outage pauses orchestration but never strands assets, because Utila takes no part in signing. The institution holds a standalone signer, the derivation scheme and runbooks per chain from day one, so another provider could take over without moving keys or changing addresses.
Utila can withhold service. It cannot forge, alter or originate a transaction or a policy change, because it holds no key and everything it produces is checked against something the institution signed.

