Demos Beta Mainnet: everything that's live, in plain English

The interbank settlement problem hasn't moved meaningfully in fifty years.

Two banks in different jurisdictions still rely on correspondent banking — a chain of intermediary banks that each take a cut and add a delay. SWIFT moves the messages; the actual settlement happens through nostro/vostro accounts that have to be funded in advance. The system tolerates 1–3 day settlement times because the alternative — every bank trusting every other bank's database — is unworkable.

Demos replaces the trust assumption with cryptographic proof. A payment from Bank A to Bank B can include attested balance state from both sides, settle atomically on either bank's preferred ledger (a public chain, a private rail, a CBDC network), and produce an audit trail both regulators can verify independently. The intermediary banks become optional. Settlement collapses from days to seconds. The compliance evidence improves rather than degrades.

The same person is KYC'd by their bank, their broker, their crypto exchange, their fintech app, and their employer's payroll provider — independently, repeatedly, expensively.

Each institution spends real money verifying the same passport against the same database, then keeps a copy of the documents in a system that's a target for every breach actor on the planet. The customer experiences this as form-filling friction. The institution experiences it as a per-customer cost line measured in tens to hundreds of dollars.

With Demos, KYC becomes a credential. A regulated identity provider runs the check once and issues a signed attestation. Every other institution that needs the same fact verifies the attestation cryptographically — no document exchange, no copy of the passport, no fresh attack surface. Selective disclosure means the bank gets "verified resident of country X over 18" without seeing the birthdate or address. The customer onboards in seconds. The institution gets stronger compliance evidence than the document copy gave them.

Audits today are sample-based because verifying every transaction is impossible.

External auditors look at a slice of the ledger, vouch for it, and the rest is taken on faith. Regulators receive periodic reports that the institution itself prepares. The system relies on the assumption that material misstatement would show up in the sample — an assumption that has failed catastrophically more than once.

Onchain workflows on Demos produce per-transaction cryptographic evidence by default. Regulators get continuous assurance instead of quarterly reports. Auditors verify mathematically rather than statistically. FHE means the bank can prove it ran the right calculation on the right data without revealing the underlying customer information. Compliance becomes a property of the system, not a department.

National payment infrastructure has been a one-vendor question for fifty years.

Every government that runs its own real-time gross settlement system (RTGS) — Fedwire, TARGET2, CHAPS — depends on bespoke legacy infrastructure that was state-of-the-art in the 1980s. Modernizing them is a decade-long project per country. Most governments accept the constraint because the alternative is taking on a generational technology risk.

Demos changes the option set. A sovereign settlement layer can be built on the same primitives that already run on Beta Mainnet: post-quantum signing, deterministic finality, FHE-protected balances, cryptographic audit. Cross-border interbank flows settle through native bridges rather than correspondent chains. The system is auditable by the central bank, private to commercial banks, and resistant to attacks that don't yet exist. This is what "modernized RTGS" looks like when the design starts from primitives, not from patching the existing system.

National digital ID programs have collided with privacy regulation in every country that has tried them.

India's Aadhaar onboarded over a billion people but has been the subject of repeated constitutional challenges over privacy. The EU's eIDAS framework is technically capable but adopted unevenly. The UK abandoned its national ID card scheme. Most attempts at national identity infrastructure either collect too much data (privacy collapse) or fail to verify uniqueness reliably (the system's only real job).

Demos 8004 / CCI plus ZK Identity solve both. The state can issue credentials that prove uniqueness without exposing the underlying identity to any service that doesn't strictly need it. Citizens can prove citizenship, age, residency, or eligibility for a benefit without surrendering their full record. The state retains the integrity of its registry. The citizen retains control of their data. The constitutional tension dissolves because the technology no longer forces a tradeoff.

Consensus design is what determines whether a system can host real economic activity.

Visa processes around 65,000 transactions per second at peak. Most blockchains struggle to clear a few thousand. The gap isn't an inconvenience — it's the reason serious institutional payment workloads have stayed on legacy rails. PoR-BFT plus dynamic sharding is engineered specifically to close that gap without recreating the centralization that makes Visa Visa.

The reputation-weighted validator selection also addresses something most chains have ignored: operator quality matters as much as operator count. A network of 10,000 validators where the most reliable 200 do most of the consensus work outperforms a network of 200 validators where each is interchangeable, because the system can afford to trust the proven operators with more responsibility while keeping the long tail as backup. This is how every other reliability-critical infrastructure system actually works — power grids, BGP routing, internet exchanges — and it's how Demos works too.

"Harvest now, decrypt later" is already happening, and most institutions have no plan.

State actors and well-funded private adversaries are already collecting encrypted traffic, banking data, and signed transactions on the assumption that they'll be able to decrypt all of it once a sufficiently powerful quantum computer exists. The U.S. National Security Agency, the U.K. NCSC, and the EU's ENISA have all issued formal guidance to migrate to post-quantum cryptography before the threat materializes — because by the time it does, your historical data is already compromised.

Most blockchains will require a hard fork to switch algorithms — a coordinated upgrade that historically takes years and risks splitting the network. Most banks will require a multi-year migration of their HSM infrastructure. Demos shipped post-quantum protection as a default; the dual-sign design means even a successful break of one of the two algorithms doesn't compromise existing assets. For institutions that operate on 30-year regulatory horizons (mortgage securitization, pension funds, sovereign debt), this is the only cryptographic foundation that survives the planning window.

The IPFS pinning problem has quietly broken most "fully onchain" applications.

An NFT that points to an IPFS hash where the image lives stops being an NFT the moment that pinning service goes down — and they go down. Centralized backend services storing what should be onchain state turn every dApp into a "decentralized" frontend with a regular SaaS company underneath. The decentralization claim collapses on first inspection.

Native onchain storage closes the loophole. A decentralized identity registry can actually live onchain. A reputation system has nowhere else to point. A game's leaderboard isn't dependent on the studio's AWS bill being paid. For institutional deployments, this matters even more: an audit trail that depends on a third-party storage provider isn't an audit trail, it's a delegation. With Demos, the verifiable record and the data are the same artifact. Regulators audit one thing instead of two.

The four access modes also map directly onto how real organizations think about data: internal-only (private), admin-controlled (deployer), partner-shared (whitelist), and public-record. No application has only one of these — every real system has a mix. Most chains force a choice. Demos lets the developer pick per dataset, which is how it works in every database in production today.

Patient data sharing is the canonical "privacy or composability" problem.

HIPAA in the US, GDPR in Europe, and equivalent frameworks elsewhere all enforce a basic principle: patient data should not leave its trust domain. But meaningful clinical AI, multi-site research studies, and even basic care coordination require analyzing data across institutions. The compromise has historically been de-identification — a process that provably fails at scale, because the same individual's records across multiple datasets can be re-identified through correlation.

FHE on Demos lets a research institution run a study across data from twelve hospitals without any hospital revealing a single record. The hospitals encrypt their data, the study contract operates on the ciphertext, and the result is a verified statistical output — the patients' raw records never leave their respective EHR systems. This is the only way to make genuine multi-site research compatible with regulatory privacy regimes, and it's running today.

Every electronic voting system ever deployed has had to choose between "ballots are secret" and "the count is verifiable."

Mail-in ballots use signature matching that doesn't actually verify, machine voting produces results that can't be independently audited, blockchain voting (the few times it's been tried) puts ballots on a public ledger and pretends that's privacy. None of these satisfy the actual requirements: every voter casts exactly one ballot, no one knows how anyone else voted, the count is verifiable by anyone who cares to check.

FHE plus ZK Identity satisfies all three. ZK Identity proves the voter is registered and unique without revealing which registered voter they are. The encrypted ballot is counted homomorphically — the contract sums the votes without ever decrypting any single ballot. The final tally is decrypted and published. Anyone can verify the math. No one can identify any individual vote. This isn't a research project; it's the same primitives running on Beta Mainnet today.

Sealed-bid auctions exist because revealing bids changes behavior. Sealed-bid auctions on regular databases require trusting the auctioneer.

Government procurement, M&A processes, art auctions, and competitive RFPs all need bids to stay sealed until the deadline. The current system trusts a third party — an auction house, a procurement office, a notary — to honor the seal. Sometimes they don't, and the result is corruption, leaked bids, and rigged outcomes that cost taxpayers and shareholders billions per year.

L2PS plus FHE eliminates the trusted auctioneer. Bids are encrypted at submission, computed against each other under encryption (highest wins, lowest cost wins, whatever the rule is), and only the winning result is decrypted. The auction contract proves it ran the rule correctly without ever seeing any losing bid. The integrity of the process is mathematical, not institutional.

Cross-chain bridges are the single most-attacked component in crypto, with over $2.5 billion stolen from bridge exploits over the past several years.

The reason is structural: a traditional bridge is a smart contract on one chain holding assets, and a smart contract on another chain minting wrapped versions. Compromise either side and you can mint unlimited wrapped tokens on the destination chain or drain the locked tokens on the source. Every bridge is its own attack surface, and most bridges are smaller and less audited than the chains they connect.

Native cross-chain execution on Demos doesn't lock and mint. Workflows execute against the source and destination chains directly, with the bank-grade signature scheme protecting each step and no "wrapped asset" honeypot for attackers to drain. When external bridges are needed (because some chains have no native compatibility), the Firewall layer monitors them in real time and routes around any bridge showing exploit signatures — before users notice. The same infrastructure that handles routine cross-chain transfers also defends them.

The reason most enterprise integration projects fail is not technical complexity. It's that every integration is bespoke.

A mid-sized company has 50–200 SaaS systems, each with its own API, auth model, data schema, and rate-limiting. Connecting them is a permanent backlog. Integration platforms (MuleSoft, Boomi, Workato) exist specifically to manage this complexity, and they're billion-dollar businesses because the problem is genuinely hard. Every connector has to be written, maintained, versioned, and re-tested every time either system updates.

MScript reframes integration as a signed JSON workflow. The schema is the workflow. The audit trail is automatic. Updates to either system don't break the integration if the schema didn't change. For workflows that span enterprise systems, payment rails, and blockchain settlement — a category that includes most modern fintech — the complexity collapses to a single readable artifact. This is what a real "API economy" looks like once the verification problem is solved.

The "oracle problem" has been the quiet ceiling on every serious financial application of smart contracts.

If a smart contract needs to know whether a flight was delayed, what the dollar-yen rate is, or whether a hurricane hit a specific zip code, it has to ask a trusted external party. The major oracle networks (Chainlink and others) function by aggregating reports from multiple data providers and consensus-voting on the answer. This works, but it adds cost, latency, and a fundamental assumption that the oracle network itself isn't compromised. Insurance contracts, derivatives, and any application that depends on real-world state hits this ceiling quickly.

DAHR replaces the trusted-oracle pattern with directly verified Web2 access. The contract calls the airline's API, the FX provider's endpoint, or the weather service directly, with cryptographic attestation that the response is genuine. No middleman to trust, no aggregation latency, no oracle network to pay. For institutional applications, TLSNotary adds court-grade evidentiary value — a proof from a TLS session is something a regulator or a judge can verify independently, which is something an oracle's word has never been.

Diploma fraud, fake licenses, and forged employment history cost employers billions per year and ruin lives when fakes go undetected.

Verifying that a candidate has the degree they claim, the license they list, or the employment history on their resume is currently a phone-call-and-trust process. Background-check companies exist as a $5 billion industry largely to manually verify these claims one at a time. The verification is expensive, slow, and still gets fooled regularly because the underlying data is held by institutions that don't expose verifiable attestations.

TLSNotary lets the issuing institution's existing portal become a source of cryptographic proof. The candidate logs into their university's transcript portal, generates a TLSNotary proof of the page that says "BS Computer Science, 2018," and submits the proof. The verifier checks it cryptographically — no phone call, no manual confirmation, no $50 background-check fee. The university doesn't have to build new infrastructure; their existing TLS-protected portal becomes the credential issuer.

AI-generated content is rapidly making it impossible to verify any claim made online.

A photo, a video, a transcript, a screenshot — all can be faked convincingly. The traditional response (digital signatures on the source) only works if the source signs everything, which they don't, and if the consumer can verify the signature, which they usually can't. The deeper problem is that there's no efficient way to prove "this content really came from that system" at internet scale.

TLSNotary changes the default. Anything served over HTTPS — which is most of the web — can produce a TLSNotary proof on demand. A journalist citing a source can attach a TLSNotary proof of the page they read. A bank statement can be verified without asking the bank. A court submission can include cryptographic evidence of what an API returned at a specific moment. The infrastructure already exists; Demos exposes it as a primitive any application can call.

The internet was built without identity, and we've been paying the cost ever since.

Bot networks distort elections. Sock puppets manipulate review platforms. AI-generated personas overwhelm comment sections. Every social platform spends enormous resources on Sybil detection — trying to figure out which accounts are real people. Solutions like real-name policies and government-ID verification trade one problem for another: now there's a database of real names linked to online activity, and that database is a target.

ZK Identity solves the Sybil problem without creating the surveillance problem. A user proves they're a unique human with no double-registration. The platform never learns who they are. Every "one human, one vote" or "one human, one account" requirement — from social platforms to airdrops to public consultations — can be satisfied without exposing any identifying information. This is the primitive that lets the internet have meaningful uniqueness without becoming a surveillance state.

Right now, when an AI agent does something wrong, there's no shared way to know which agent did it or whether to trust the next one.

The fragmented agent ecosystem (every AI vendor with their own auth, their own logs, their own claims about safety) means accountability resets every time a new agent shows up. Bad actors can spin up new agents under new identities. Good actors can't carry their reputation across platforms. The result is a low-trust environment where every agent interaction has to be approached as if it were the first.

Onchain reputation that humans and agents share fixes this. A logistics agent that has reliably executed 50,000 shipments has a reputation that any other agent — or human — can verify before transacting. A new agent has to earn its reputation, which is exactly how it works for humans. Bad actors can be flagged once, and the flag follows them. The protocol-level identity layer turns the agent ecosystem from "trust nobody" to "trust verifiable performance."

Your eBay seller rating, your Airbnb host score, your Uber driver star count, your Upwork freelancer history — none of them are yours.

Every platform you've built a reputation on owns that reputation. Switching costs are high specifically because your reputation doesn't move with you. New platforms struggle to bootstrap because they have to recreate trust from zero. Users who depend on platform reputation for their livelihood are at the mercy of the platform's policies and account decisions.

Cross-Context Identity makes reputation portable. You build it once, you own it, you can carry it to any platform that wants to verify it. The platform still controls its own rules, but it doesn't control your verifiable history. New platforms can offer a discount to users with established reputation from elsewhere — which means they can compete on quality of service rather than network effects. The asymmetry shifts back toward the user.