Crypto’s Endgame: Proofs and Pragmatism

In crypto infrastructure, one instinct has captured most of the funding and talent, the push to encode everything on-chain and reduce identity, and automation to proofs, circuits, and contracts. Many big projects of the last cycle, flow from this instinct.

But programmability isn’t the same as progress. The alternative, a pragmatic approach to cryptography, is quieter, less capitalized, but anchored in a simple question: what actually works at scale to give users autonomy? Its tools are highly secure, simpler, often overlooked: the distributed control of secrets with threshold cryptography and encrypted virtual machines.

Zero-Knowledge Proofs: Brilliant, but Often Too Much Tool

Zero-knowledge proofs are mathematically extraordinary. One party can prove a statement without revealing the underlying data. In the right contexts, they’re indispensable.

• Chain security. Rollups use ZK to anchor the state back to chain with mathematical certainty. Bridges rely on proofs to avoid trusting intermediaries.
• High-stakes security. Against nation-state adversaries, ZK gives guarantees that signatures or MPC/TSS alone can’t. It’s the right tool when the trust boundary is truly hostile.

But those are exceptions, not the rule. For everyday transactions, ZK is overkill. Proof generation is far more expensive than a signature. Each proof burns cycles that cost real money — recent benchmarks put simple actions at around ten cents a pop, versus near-free signatures. Even on specialized hardware, users don’t want to pay extra or wait seconds just to move tokens or log in.

The mistake is in treating ZK like a universal fix instead of a surgical tool. For the overwhelming majority of user interactions, what matters is secure authority, not elegant, resource-hungry proofs.And adoption shows it. Users touch ZK when they transact with rollups or bridges. ZK is invisible plumbing, bundled into infrastructure, not demanded by end users. Where adoption does appear directly, like in privacy wallets, it’s constrained by cost and regulation. Compare that to threshold cryptography and optimistic rollups.

ZKML: Even Heavier

ZK machine learning takes the same problem and doubles it. Proving model execution inside a circuit stacks GPU-intensive proof generation on top of GPU-intensive inference. The result: a costly solution looking for a problem to solve.

Do people really want “provable” AI outputs every time they run a model? Nearly never. For most AI-crypto intersections, MPC/TSS access control (who can run or decrypt a model) is far more practical.

Fully Homomorphic Encryption: Still Dependent on MPC/TSS

FHE holds out the dream of computing directly on encrypted data. It allows running queries without ever decrypting. But even here, the same question looms: who holds the key fragments?

Without distributed control, FHE collapses into a centralized trust point. With MPC/TSS, those keys are split across independent operators, so FHE security is threshold cryptography.

Thresholds and Authority

Threshold cryptography isn’t proof-less. The proofs are simply of a different kind. ZK and FHE prove the integrity of computations: that the math was done correctly every time.

MPC/TSS+TEE proves the integrity of the setup i.e. the keys were generated correctly. That each share is valid. The servers are secure. No party can forge a signature alone. These proofs secure the distribution of authority itself, not every subsequent computation.

This distinction matters. ZK normally encodes logic in circuits; MPC/TSS+TEE enables trust across the system. ZK formalizes outcomes; MPC/TSS+TEE enforces who has the right to act. Both are cryptography — one proving what happened, the other proving who may act.

Smart Accounts: Guardrails, Not Automation

Smart accounts — account abstraction, keystore rollups, contract wallets — are pitched as the future of user autonomy. They promise recovery, rules, programmable safeguards. But they hide a flaw: by putting the logic of identity back on-chain, they trap automation inside the narrow sandbox of a single state machine.

Blockchains are great at narrow tasks. A contract can enforce rules like: “this wallet may only call these specific dApps” or “only this guardian can recover keys.” But the moment you step into rules that look simple — say, “this account can’t spend more than $1,000 per day” — you hit a wall. That rule spans Ethereum, Solana, Bitcoin, and whatever else the user touches. A contract-bound account can’t enforce it because it can’t see outside its chain.

That’s the problem: identities, even at their simplest, are multi-chain, multi-context, dynamic. Pushing their logic on-chain doesn’t just bloat contracts — this makes automation brittle and incomplete.

MPC/TSS+TEE is the natural layer for this kind of enforcement. Threshold cryptography operates above the chains, mediating signing authority wherever the user acts. Instead of shoving all complexity back into one state machine, MPC/TSS + TEE permits defining and enforcing policies at the boundary — flexible enough to span chains, environments, contexts.

The Middle Way, A Layered Model For Users

A sound model is layered.

• Smart accounts for guardrails. Use on-chain logic for narrow, local rules — which contracts can be called, basic recovery, limits inside one chain.
• MPC/TSS+TEE for sophistication. Enforce cross-chain policies, multi-context identity, higher-order automation. This is where real user autonomy lives: above chains, not trapped inside them.

And this isn’t confined to crypto. MPC/TSS+TEE secures and automates any digital secret — credit cards, OAuth tokens, API keys, medical records, passwords. Anywhere authority has to be delegated and enforced, threshold cryptography is the bedrock.

The Substrate of Digital Autonomy

Fully programmable approaches continue advancing. Proofs will get faster, smart accounts richer, FHE more practical. But none of these answer the core question: who holds authority, and how is it enforced?

Both instincts lean on proofs. In ZK and FHE, proofs certify the computation. In MPC/TSS, proofs certify the security of the setup: that keys were generated correctly, that shares are valid, that no single party can reclaim control, and who holds the shares. Different surfaces, same cryptographic foundation.

The endgame of crypto won’t be decided by how much we can cram into circuits. It’ll be decided by whether we can build autonomy that endures. On that axis, threshold cryptography + TEEs is already here.

It is the practical substrate of digital autonomy.