COTI_Official

TL;DR
→ Privacy-on-Demand is an end-to-end encryption privacy service that works across blockchains.
→ Two parts do the work. The Inbox carries sealed requests between the two chains. The MPC executor on COTI computes over the encrypted values without ever revealing them.
→ The app sends data via a transaction, COTI computes it privately, and the answer comes back still encrypted. Only the user can open and reveal the data with their own key.
→ For the chain that integrates it: PoD unlocks privacy for its existing apps, with no migration or new tech stack needed. → For COTI: Every private request, whichever chain it starts on, is processed and fees are paid to COTI.
Privacy: The Choice You Should Never Have Had to Make
Privacy-on-Demand brings COTI privacy natively to any blockchain it’s integrated on. You don’t have to migrate your tech stack or build on a new chain. It is a privacy service the chain or the app you’re already using can call.
COTI Privacy-on-Demand is a cross-chain privacy service that can enable privacy on any chain or app. Essentially, it lets an application keep its accounts, tokens and data on the EVM chain it already runs on, while processing transactions of private tokens and private data, all powered by COTI
A user’s sensitive data is encrypted, sent to COTI for computation, computed there without ever being decrypted, and returned to the original chain as ciphertext that only the user can open.
Crypto already knows the shape of this. No chain builds its own price feeds. When an application needs data it does not have, it calls an oracle, and nobody suggests migrating to another network to get one. Privacy now works the same way: a capability your chain can run and call, rather than an entirely new tech stack you have to integrate.
An oracle fetches external data and hands it over in the clear. Privacy-on-Demand sends encrypted values out, computes over them without ever revealing them, and returns an encrypted result that only the entitled user can open.
Before now, privacy required a complex development effort which could be costly and challenging to solve. Public blockchains are excellent at agreement, auditability, and open participation, and they get weaker the moment an application has to hide something: an amount, personal identifiable information or an input of business logic.
Until now, there were only two options. Keep the sensitive data off-chain and composability weakens, because the rest of Web3 cannot interact with what it cannot see. Or move to a specialized privacy chain, and take on an entirely new development effort, with technical specifications and limitations.
With Privacy-on-Demand, you can use the public chain for coordination and COTI for confidentiality.
A Courier and a Calculator
Picture three rooms and a mail slot: your device, which holds your keys and does the encrypting and decrypting, the public blockchain, where your tokens and contracts live, and COTI’s private compute environment.
The Inbox is the certified courier. It is the only route a private request travels in either direction. It carries the sealed job out, then calls back into your contract when the answer exists. It is also where the trust boundary sits: applications are built to accept a private result only from the Inbox, and the SDK ships an onlyInbox pattern for that check.
The MPC executor is COTI’s private calculator. MPC stands for multi-party computation, computing a shared result without any party revealing its own input. Sealed inputs arrive, COTI’s Garbled Circuits run the operation directly on the encrypted data without ever decrypting it, and out comes ciphertext, an encrypted result.
The components of Privacy-on-Demand, in one line each
Your device or wallet is the client. Holds your privacy keys, encrypts every sensitive input before it leaves your machine, and decrypts the result locally or within your wallet or app if you are entitled to see it.
Your EVM chain, the host chain. Keeps your accounts, tokens and application contracts exactly where they already are, and enforces whatever public rules are in place: permissions, payment, timing.
The Inbox. A matching pair of on-chain messaging contracts, one on your chain and one on COTI, and the only route a private request travels in either direction.
The MPC executor. The COTI-side contract that runs the private logic, computing over encrypted values with Garbled Circuits and returning ciphertext.
PoD-User. The configuration a contract inherits, recording which Inbox, which COTI network and which executor it uses.
PoD-Lib. A Solidity library of ready-made private operations over encrypted values, so a team writes no cryptography to get started.
The Encryption Round Trip
Here is the full private request flow, end to end.
1. You choose an action. Whether it’s to compare two private numbers. Run a private score. Identity check. Approve a payment.
2. Your app encrypts the inputs on your own device. This is the part most people have backwards. The client does the encrypting, before anything leaves your machine, and COTI never receives a plaintext value.
3. You submit an ordinary transaction on your own chain, and your contract checks the public rules first. Permissions, payment, timing.
4. Your contract hands the sealed job to the Inbox as a two-way message: an outbound leg to COTI, and a booked return leg for when the answer exists.
5. COTI’s Inbox passes the job to the MPC executor, which runs the private logic over the encrypted values.
6. The sealed answer travels home. Your contract stores it against a request ID, the tag the answer arrives under, and you decrypt it locally with your own key, if you are entitled to.
Now the sentence that matters most. The result comes back encrypted. Nothing is decrypted on-chain, ever, on either side. Even after completion, plaintext is not magically public. The only place the ciphertext opens is the device of a user entitled to open it.
Five verbs and you have the pattern. Encrypt, send, compute privately, receive sealed, decrypt yourself.
Why a Private Answer Takes a Moment
A normal smart contract call computes and returns inside a single transaction. With Privacy-on-Demand, the private work happens outside your chain’s synchronous execution frame, on a different network. That is two transactions on two chains, not one.
So the lifecycle has three phases. Request, where your contract submits the job through the Inbox and gets a request ID. Wait, where COTI performs the private computation, which may take a few seconds or longer depending on network conditions. And callback, the second transaction, where the Inbox invokes your contract with the encrypted output.
Simply put: send a job, get a sealed reply.
Because each call spends real resources on two networks, the fee funds both legs: the private computation on COTI, and the callback that writes the sealed result back on your chain. This is what privacy crossing two networks costs, and knowing it is the difference between a diagram and an explanation.
What Is Encrypted and What Is Not
COTI encrypts the values and the math over them, not the fact that a transaction happened. The transaction is visible. The number is not.
Everything an explorer shows you stays legible. The amount does not.
What is protected: sensitive values are never stored in plaintext on the orchestrating chain the way an ordinary balance is, the computation over them runs inside COTI’s private execution path rather than in a trace anyone can replay, and users decrypt only what they are entitled to see, with their own privacy key.
What is not protected: this is not full anonymity. Privacy-on-Demand does not hide metadata such as gas costs, timing or which contract was called. This isn’t about anonymity. It’s about selective disclosure.
The boundary is a feature. Auditability is what makes confidentiality usable by a real business: activity can be verified on the public chain while the values inside it stay protected.
What This Means in Practice, for Both Sides
Privacy-on-Demand answers two different questions with one mechanism, depending on which end you stand at.
For the chain that integrates it
Its applications get encrypted computation with no migration, no new chain, and no assets moved. Accounts, tokens, users, liquidity and tooling stay where they are, and nobody is asked to bridge anywhere. It is additive rather than a replacement: the public chain keeps doing what it is excellent at, and gains the one capability it structurally cannot provide on its own. Teams building there do not have to become cryptographers either, because the shipped operations cover a large share of applications outright.
For COTI
Every call consumes resources on two networks, so the fee covers both legs. You pay entirely in your own chain’s native token. That payment is split: one slice funds the callback that writes the result back on your chain, the other funds the private execution on COTI, a leg priced and spent in COTI through oracle conversion.
So every private request, on whichever chain it begins, is work performed and paid for on COTI.
Privacy for every chain, value back to COTI.
What This Makes Possible
Start with a universal business problem. Privacy-on-Demand keeps the sensitive business logic and transaction amounts encrypted, and lets each party decrypt only the data they are programmed to have access to.
On a public chain your transaction and its cost and size is public. Privacy-on-Demand can shield orders from MEV bots and protect traders from being sandwiched, keeping thresholds, order sizes and strategy logic away from front-running. The number stays sealed. Settlement stays on your chain.
On a transparent chain, publishing your contract publishes your business logic. Every rule you encoded is readable, and so is every parameter you tuned. That is exactly right for an AMM, whose whole value is that anyone can verify it. It is a serious problem for anything whose edge is the rule itself: a credit model, an auction mechanism, a pricing curve. Deploy one of those on-chain today and you have published your competitive advantage, formatted for copy and paste.
Privacy-on-Demand changes that trade. A team can deploy its own private program on COTI, one that accepts only encrypted inputs and returns only encrypted outputs, so its data and its inner workings both stay hidden. The host chain still coordinates, still holds the assets, still enforces the public rules. The rule that makes the business work never becomes public.
Until now, a company whose product is its model had two options: keep the model off-chain and give up composability, or put it on-chain and give up the model. That is no longer the choice, and it changes which businesses can use a public blockchain at all.
Where It Runs Today, and Where It Goes Next
COTI’s privacy engine is not a prototype. gcEVM, COTI’s Garbled Circuits implementation, runs in production on COTI mainnet today, powering private tokens, the Privacy Portal and live applications.
Privacy-on-Demand is how that engine reaches beyond COTI, and the first public proof is already running on Ethereum testnet. COTI deployed the Millionaires’ Problem there: two parties learning which of them holds more, with neither revealing a number, computed end to end with no trusted intermediary. It is the benchmark that founded secure multi-party computation more than forty years ago, settled on a public EVM chain, with the private math happening on COTI.
That is the entire pattern working outside COTI for the first time, and it is the same pattern any EVM application will use.
What comes next is reach. Privacy-on-Demand goes multichain through 2026, including major partnerships with leading chains, with COTI operating as the universal privacy layer for Web3: interoperable, composable and chain-agnostic.
A Private Backend that any application or blockchain can call, without asking any of them to move. COTI has set its own measurement standard for it too: cross-chain integrations, users transacting on the network, and applications built with the privacy stack.
The engine is proven. The connection works. What is left is how many chains it reaches.
Privacy-on-Demand FAQ
What is COTI Privacy-on-Demand?
COTI Privacy-on-Demand is a cross-chain privacy service that lets an application keep its accounts, tokens and public logic on the EVM chain it already runs on, while sensitive values and the computation over them are encrypted on the user’s own device, sent to COTI, computed there without ever being decrypted, and returned as ciphertext that only the entitled user can open. It runs on gcEVM, COTI’s Garbled Circuits implementation built with Soda Labs, a form of multi-party computation that computes directly over encrypted data. The pattern in five verbs: encrypt, send, compute privately, receive sealed, decrypt yourself.
Do I have to move my tokens or migrate my app to COTI?
No. Keeping your accounts, tokens, users and liquidity exactly where they already are is the entire point of Privacy-on-Demand. Only the sensitive values, and the computation over them, travel to COTI, and they travel encrypted in both directions.
Is Privacy-on-Demand live?
Two separate things are true here. COTI’s Garbled Circuits implementation, gcEVM, has been live in production on COTI mainnet since March 2025, where it powers private tokens, the Privacy Portal and live applications. Privacy-on-Demand is how that engine reaches other chains, and it is running on Ethereum testnet today, not yet deployed on mainnet.
Which blockchains does Privacy-on-Demand support?
Privacy-on-Demand is chain-agnostic by design and targets EVM-compatible chains, so the host chain is whichever EVM network your application already runs on. It is running on Ethereum testnet today. COTI’s public 2026 goals commit to Privacy-on-Demand going multichain through major partnerships with leading chains, and no partner chain has been announced.
Does Privacy-on-Demand make transactions anonymous?
No. Privacy-on-Demand delivers confidentiality, not anonymity. It encrypts the values and the computation over them, while the transaction itself stays visible on the public chain, and it does not hide metadata such as gas costs, timing or which contract was called.
How is this different from a privacy chain, or from an oracle?
A privacy chain asks you to move: relocating your accounts, tokens, liquidity and users onto a different network, and taking on that network’s custody and regulatory story. Privacy-on-Demand follows the shape of an oracle instead, a capability your chain calls rather than a place it goes. The difference from an oracle is what travels: an oracle fetches external data and hands it over in the clear, while Privacy-on-Demand computes over encrypted values and returns them encrypted.
What can you build with Privacy-on-Demand?
Anything whose values or whose logic should not be public while it settles on a public chain. Typical patterns include private investor allocations where each investor decrypts only their own amount, order and position shielding that keeps size and strategy away from MEV bots, confidential payments and payroll, sealed-bid auctions, credit and identity checks against encrypted data, and confidential voting. A team whose business rule is itself the secret can also deploy its own private program on COTI, one that accepts only encrypted inputs and returns only encrypted outputs.
Privacy Stops Being a Place You Go
Privacy stops being a destination you migrate to and becomes a capability your chain can call.
The mechanism, in one line you can repeat: a courier, a calculator, and an answer that comes home still sealed.
Read the full Privacy-on-Demand documentation at docs.coti.io, and try the Privacy Portal, already running in production, at privacy.coti.io.
Stay COTI.
Official Privacy-on-Demand Resources
These are the canonical sources for Privacy-on-Demand, maintained by COTI.
Privacy-on-Demand documentation: https://docs.coti.io/coti-documentation/privacy-on-demand
Interactive architecture demo: https://pod.coti.io/
Privacy Portal, live in production on COTI: https://privacy.coti.io/
COTI on GitHub: https://github.com/coti-io
About COTI:
COTI is the programmable privacy layer for Web3. Built for enterprises, builders, and agents. Powered by high-performance Garbled Circuits and enterprise-grade COTI Nightfall (ZK), COTI enables encrypted computation on any public blockchain. Fast, low-cost, and compliant privacy across DeFi, AI, and beyond.
For COTI updates and to join the conversation, be sure to check out our channels:
Website: https://coti.io/
X: https://twitter.com/COTInetwork
YouTube: https://www.youtube.com/channel/UCl-2YzhaPnouvBtotKuM4DA
Telegram: https://t.me/COTInetwork
Discord: https://discord.gg/coti-foundation
GitHub: https://github.com/coti-io
Vibe Coders Telegram: https://t.me/+uuPNfRkKiQ03ZTcx

Most privacy protocols privatize a fixed menu of actions. Very few let a developer deploy any program at all and run it on encrypted data. Here is the difference, why it is so hard to build, and why the institutions designing the next financial system are already writing it into their requirements.
TL;DR
→ General-purpose privacy means a developer can deploy any program and have it compute over encrypted data. → Single-purpose privacy protects a closed menu of actions, usually transfers. The second is a much harder problem, and it is the one COTI solved.
→ COTI’s gcEVM has been live in production on COTI mainnet since March 2025. Not a testnet. Not a roadmap item.
→ The institutions building the actual financial rails treat confidentiality as a design requirement, not a preference.
→ Payroll, payments, contracts, and settlements each break on a transparent chain in a completely different way. Four failure modes cannot be patched with four bolt-on privacy tools.
→ Garbled Circuits on COTI run up to 3,000x faster and 250x lighter than alternative privacy solutions, light enough for any device, fully EVM-compatible, and written in standard Solidity.
A Category Almost Nobody Has Entered
The demand for privacy from enterprises, institutions is skyrocketing. But with years in development, the world of crypto solutions is still short on delivery.
More than a decade of research, billions in funding, and hundreds of launches with “privacy” in the first line of the documentation. Yet when you ask the precise question, the field thins out immediately.
The billion dollar question: Can a builder deploy an arbitrary program or use cases that computes end-to-end encrypted data on a live network, today?
The COTI answer is yes. The gcEVM, COTI’s EVM implementation powered by Garbled Circuits, has been live on COTI mainnet since March 2025. Developers write confidential contracts in standard Solidity, using Hardhat, choosing what stays encrypted and what stays public inside a single contract.
COTI is not alone on that list, and it is a very short list for a problem this valuable. Avishay Yanai, co-founder of Soda Labs, the cryptography team COTI built its Garbled Circuits protocol with, asked Claude Fable and this was the result:
“…by now there are only two networks with a general-purpose protocol level privacy. Kudos @COTInetwork @Starknet”
Credit where it is due. The rise of privacy benefits everyone building in this space. The list is short because the problem is genuinely hard, not because nobody wanted the prize.
Encrypting data is a solved problem. Computing on data while it stays encrypted, fast enough that a smart contract can do it inside a block, on hardware a normal person owns, is a different discipline entirely.
Garbled Circuits were introduced by Andrew Yao in 1986 and sat largely on the academic shelf for decades because the machines and the optimizations were not ready. The first working implementation arrived in 2004. Bringing a full, optimized Garbled Circuits engine to a live blockchain took another twenty years, and COTI, with Soda Labs, is where that arc finally met production.
Ethereum co-founder Vitalik Buterin has publicly pointed to Garbled Circuits as the path to pure-cryptographic security guarantees for multi-party computation. COTI is the project that shipped it.
What General-Purpose Privacy Actually Means
Here is the distinction that decides everything, and it gets collapsed constantly.
Single-purpose privacy protects a fixed set of actions. The protocol decides in advance what can be confidential, and that menu is closed. Usually it is transfers: move an asset without revealing the amount or the counterparties. This is real engineering and real value.
General-purpose privacy means a developer writes the program, and the program computes over encrypted data. Nobody decided in advance what your confidentiality is for. You did.
The cleanest way to see the difference is to stop arguing about it and look at what a developer can actually build.
A payroll contract. Salary amounts arrive encrypted and stay encrypted. The contract still adds them into a department total, applies a withholding rate, and checks each figure against an approval threshold. Finance gets its numbers. An auditor gets the view it is entitled to. No individual figure is ever exposed, including to the network performing the calculation.
A sealed-bid auction. Every bid is submitted encrypted and stays encrypted through settlement. The contract compares encrypted bids against one another to determine a winner, and the losing bids are never revealed to anyone, not to the other bidders and not to the auctioneer. There is no window in which bidding can be front-run, because there is nothing in the mempool to read.
Order flow that conceals size. Order size stays encrypted while the contract computes against it: routing, slippage limits, execution thresholds. Intent stops being a public signal, so it stops being an attack surface.
Why Enterprises Need Privacy That Adapts to the Business
There is an asymmetry in this market that almost nobody notices.
Ask allocators, banks or asset managers what is the bottleneck to digital assets adoption, and one of the few key missing pieces is confidentiality. Confidentiality and regulatory clarity dominate the conversation.
Now look at the institutions actually building the rails, where the Bank for International Settlements and the central banks behind Project Agorá treat confidentiality not as a feature request but as a design requirement written into the specification.
The people writing the checks are not asking for confidentiality. The people writing the architecture are designing for it as a precondition. That gap is the opportunity.
Circle, announcing Arc Privacy in June 2026, covered the whole surface in a single sentence:
“Public blockchains create challenges because payroll activity, treasury transfers, trading strategies, and customer transactions can become visible to anyone monitoring the network.”
Four use cases, four different failure modes
This is exactly where general-purpose earns its name, because each of these breaks in a different shape.
Payroll. Put compensation on a transparent chain and every employee, recruiter, and competitor can read the whole comp band.
Payments. Vendor and custody relationships are recoverable by anyone with a block explorer and patience. In February 2024, analytics firm Arkham identified roughly 186,000 of MicroStrategy’s 190,000 BTC and published the split across its custodians. The company had disclosed none of it.
Contracts. Business logic leaks before it executes. In June 2022, a Solend borrower’s position, collateral ratio, and exact liquidation price were all public, so the counterparty DAO simply passed an emergency vote to take control of his account. The terms of the position were readable, which is what made them actionable against him.
Settlements. On 12 March 2025, a trader swapped $220,764 in USDC and received $5,271 in USDT. Eight seconds. An MEV bot pulled the pool’s liquidity ahead of the trade and replaced it after. A stablecoin-to-stablecoin settlement, the most boring transaction imaginable, lost 97.6% of its value because the intent was public before it was executed.
Four use cases. Four completely different failure modes. You do not fix that by deploying four separate privacy tools and hoping they compose across your stack. You fix it with one substrate where confidentiality is programmable, and you shape it to the business requirement in front of you.
How General-Purpose Privacy Works on COTI
Programmable Privacy
On COTI, confidentiality is a property you write into the contract, not a mode the chain imposes on you.
The developer decides which values stay encrypted, which computations run over ciphertext, and who is authorized to decrypt a result. Selective disclosure is built in, so an auditor or regulator can be granted exactly the view they are entitled to while everyone else sees ciphertext.
A payroll contract can encrypt amounts while leaving employment status auditable. A settlement system can encrypt position sizes while proving solvency to a supervisor. A treasury can encrypt balances while its issuance stays governed and provable.
Same chain. Same gcEVM. Different confidentiality logic, because the business requirements are different. That is what general-purpose buys you.
MPC and End-to-End Encryption
COTI’s privacy runs on Garbled Circuits, a protocol for secure multi-party computation (MPC) in which several parties jointly compute a function over private inputs and learn only the result.
Data is encrypted before it reaches the network. Computation runs over that encrypted data. The result is offboarded to a user’s key and decrypted client-side. Each user holds their own AES key issued through a precompile, and the network key is split across nodes with threshold cryptography, so no single node can reconstruct it. No operator, validator, or node holds your plaintext.
The trust model rests on a threshold of honest nodes plus battle-tested symmetric-key cryptography. There is no trusted setup ceremony and no dependence on hardware secure enclaves. Because the foundation is symmetric-key, quantum resistance is a matter of key length, and the Helium upgrade already brought native 256-bit arithmetic to mainnet.
One thing COTI is always precise about: COTI encrypts amounts, balances, and computation inputs and outputs. It does not encrypt metadata. Sender, recipient, timestamp, and the fact that a transaction occurred stay public.
That boundary is not a gap being worked around. It is the same boundary every institution named above is describing. The BIS, Agorá, and Circle all scope confidentiality to amounts, positions, and business logic, paired with authorized visibility for the parties entitled to it. Selective disclosure, not disappearance.
Garbled Circuits Performance
Confidential computation only matters if it is fast enough to actually deploy, and this is where the choice of cryptography decides the outcome.
COTI’s Garbled Circuits implementation runs up to 3,000x faster and 250x lighter than alternative privacy solutions. Light enough for any device, including mobile, with no specialized hardware. Most of the heavy work happens once, at the garbling stage, so the on-chain operation stays fast.
There is no proving-infrastructure dependency and no new language to learn. The gcEVM is fully EVM-compatible, so Solidity developers build with the tools they already use.
And it is carrying real weight. COTI’s GC mainnet launched in March 2025 and has processed over 125 million on-chain transactions. Bancor’s Arb Fast Lane encrypts execution thresholds to protect arbitrage strategies from front-running. VaccineLedger ran 10 million+ privacy-preserving supply-chain transactions in Bangladesh for under $5 in total cost. United Network shipped the first hardware wallet with COTI’s privacy built in.
The Demand Is Documented. The Supply Is Thin.
The institutions designing the next generation of financial infrastructure have already concluded they cannot operate without confidentiality. The BIS calls it a prerequisite. Central banks are writing it into formal requirement lists. Circle named payroll, treasury, trading, and customer transactions out loud.
Meanwhile, the number of networks where a developer can deploy an arbitrary program that computes over encrypted state, in production, today, is short enough to say in one breath.
COTI was built for exactly that gap. Confidentiality that is programmable, fast enough for production, compliant by design, and general-purpose by architecture. Not privacy as a switch you flip. Privacy as something you build with.
That is what it means to be the programmable privacy layer for Web3. Privacy built in, not bolted on.
Start building → https://docs.coti.io
Stay COTI.
About COTI:
COTI is the programmable privacy layer for Web3. Built for enterprises, builders, and agents. Powered by high-performance Garbled Circuits and enterprise-grade COTI Nightfall (ZK), COTI enables encrypted computation on any public blockchain. Fast, low-cost, and compliant privacy across DeFi, AI, and beyond.
For COTI updates and to join the conversation, be sure to check out our channels:
Website: https://coti.io/
X: https://twitter.com/COTInetwork
YouTube: https://www.youtube.com/channel/UCl-2YzhaPnouvBtotKuM4DA
Telegram: https://t.me/COTInetwork
Discord: https://discord.gg/coti-foundation
GitHub: https://github.com/coti-io
Vibe Coders Telegram: https://t.me/+uuPNfRkKiQ03ZTcx