How Interfold Works

Some systems become fragile when too much is visible.

A sealed-bid auction can run publicly, but visible bids change how participants behave. A public vote can produce a tally, but traceable votes are easier to pressure, buy, or punish. Institutions can collaborate through shared data pools, but doing so often increases legal, strategic, and operational risk.

These systems all depend on the same structure: private inputs, a process for combining them, and a shared outcome others can rely on. The bids, votes, records, preferences, or signals may be useful precisely because they remain private, but the result still has to be produced, verified, and released. The question is whether the process can produce a trusted result without concentrating control where the result is formed.

The Interfold is a distributed network for confidential coordination. It allows independent parties to produce shared, verifiable outcomes from private inputs without pooling data, relying on trusted hardware, or giving one operator unilateral control over execution.

What is confidential coordination?

Confidential coordination describes systems where private inputs produce shared, verifiable outcomes without pooling data or relying on a single operator. The deeper question is not only who can see the data, but who controls the process.

The Interfoldgnosis guild

In short: private inputs enter an E3 (Encrypted Execution Environment), ciphernodes enforce threshold conditions, verification makes the computation checkable, and only the permitted result is released.

The system is easiest to understand through three elements: E3s, ciphernodes, and the five-phase flow that moves a computation from request to release.

What Interfold changes

The Interfold distributes execution authority across a network.

Most systems resolve sensitive coordination by placing one operator or environment in a privileged position: An exchange clears the auction. An administrator counts the votes. A platform runs the matching process. A data provider receives the records. A compute provider, enclave, or hosted runtime runs the analysis.

That model can work. Public auctions, transparent votes, shared data pools, and hosted execution environments are all useful in the right context. But they introduce predictable risks: strategic adaptation, coercion, information leakage, operator advantage, or concentrated control over release.

Encryption can protect inputs, but it does not automatically distribute control over how outcomes are produced. The issue is who controls the process that turns private inputs into a shared result.

Even when inputs are encrypted and execution is secured, control can still concentrate in the environment where the outcome is formed:

The Interfold separates that control across protocol-defined roles. Encrypted inputs enter a bounded execution surface. Independent operators enforce threshold conditions. Computation produces a result and a verifiable claim of correctness. Release requires distributed participation rather than unilateral control.

The cryptography matters, but it is not what defines the system. FHE, MPC, and ZKPs help make the system possible, but they do not, by themselves, define who controls execution, verification, or release.

Interfold’s core design question is the full path from private input to shared result:

• who accepts inputs
• how computation is run
• how execution is verified
• who controls decryption
• who releases the result

The Interfold restructures that path with distributed authority.

E3s: ephemeral execution surfaces

An E3, or Encrypted Execution Environment, is an ephemeral, bounded execution surface created for one specific computation. It is not a permanent vault, a standing data pool, or a single trusted machine. It appears for a defined process – an auction, ballot, matching round, model evaluation, or analysis task – and closes when that process is complete.

Within that window, the E3 receives encrypted inputs, runs defined program logic, supports verification, and enables threshold-governed release. The program might describe auction clearing rules, vote tallying logic, matching criteria, statistical aggregation, or another confidential coordination function.

The important point is boundedness.

A permanent execution environment (e.g. a Trusted Execution Environment) accumulates authority over time. It can become the place where state persists, access patterns repeat, and control over future outcomes quietly centralizes.

An E3 is ephemeral by design. It exists for one computation, carries that computation through its lifecycle, releases the permitted result, and closes. The released result, proof, or anchored lifecycle event may remain available for verification, but the authority-bearing execution surface does not persist beyond the process it was created for.

An E3 is the bounded surface where confidential coordination occurs: private inputs become a shared result without becoming a permanent pool of data.

Ciphernodes: distributed enforcement

An E3 does not enforce itself.

If bounded execution surfaces existed without distributed enforcement, control would simply move elsewhere in the system. The operator that controlled setup, decryption, or release would become the new point of trust.

In the Interfold, that enforcement layer is carried by ciphernodes.

Ciphernodes are independent operators in the Interfold network. For each computation, protocol rules form a committee from the broader operator set. Committee formation is network-governed rather than handpicked by a central operator.

That committee participates in threshold-governed processes for the relevant E3, including:

• distributed key generation
• threshold decryption
• coordination around the E3 lifecycle
• enforcement of network rules

Ciphernodes do not become trusted intermediaries. Their role is to make unilateral control impossible under the protocol’s threshold conditions. No single ciphernode can expose private inputs, decrypt outputs, determine results, control release, or alter defined computation logic on its own.

This is the distinction between distributing work and distributing execution. A system can spread computation across many servers while control remains with one operator. That is not enough for confidential coordination.

What matters is whether any single party can control the full path from input submission to release.

The Interfold separates that path.

From request to release: Interfold in 5 phases

The easiest way to understand the Interfold is to follow a computation from request to result.

Consider a sealed-bid auction. The coordinator needs a winner or clearing price, but the bids themselves should remain private. The same lifecycle applies to ballots, matching, AI evaluation, and institutional analysis, but an auction makes the sequence easy to see.

The execution pattern is consistent:

The Interfold contracts coordinate the lifecycle between requesters, ciphernodes, data providers, compute providers, and outcome release. The E3 is the bounded execution surface for the computation, while the contracts coordinate how each phase is requested, formed, verified, and completed.

1. Request: An auction coordinator requests an E3 for a specific auction. The request defines the auction rules, the computation to be run, and the conditions under which the result should be produced.
2. Ciphernode selection: The network selects ciphernodes to form a committee for that E3. The committee participates in threshold-governed setup, including shared public key publication, so encrypted inputs can be submitted without giving any single operator control over decryption or release.
3. Input window: Bidders submit encrypted bids to the E3. The bids can participate in the auction computation without becoming visible to other bidders, the coordinator, or any single operator.
4. Execution: The E3 program runs over the encrypted bids. The program specifies how bids are evaluated and what result is permitted, such as a winner, clearing price, or allocation. The compute process produces a ciphertext output and can be checked against the auction rules without exposing the private bids underneath.
5. Threshold decryption: Once the required verification and threshold conditions are satisfied, the permitted result can be released. Only what the auction is meant to reveal becomes shared: the winning bid, winning bidder, clearing price, or other defined result.

After release, the E3 closes. What remains is the released result and, where applicable, proof or anchored lifecycle events that allow the process to be verfied.

The application changes. The execution pattern does not.

Why the ciphernode network is the system

The network is not an accessory to the Interfold. It is what prevents the system from collapsing back into custodial execution. If one operator controls input admission, runtime, verification, decryption, and release, then encryption may reduce what that operator can see, but it does not remove that operator’s control over the outcome path.

The Interfold uses a different structure. Each part of the system has a role:

• E3s bound the computation.
• Ciphernodes distribute enforcement.
• Ciphernode committees make authority computation-specific.
• Threshold conditions govern release.
• Verification makes results legible beyond the party that produced them.

Together, these mechanisms allow private inputs to become shared outcomes without passing through one trusted execution authority, opening a broad design space for confidential coordination: sealed-bid auctions, secret ballots, collaborative analysis, multi-agent coordination, and other systems where private information needs to produce a public or shared result.

The Interfold does not eliminate institutions, governance, or real-world complexity. It changes the execution condition beneath them: shared outcomes can be produced without concentrating authority where the outcome is formed.

That matters because visibility is not neutral. Public or receipt-generating versions of auctions, votes, matching, and data coordination can be useful, but they expose systems to different classes of attack. Private or receipt-free versions can be more resilient because participants have less information to exploit, prove, sell, or coerce.

Confidential coordination is not only about hiding information. It is about changing who has authority when private inputs become shared outcomes.

The Interfold implements that model as a distributed network: private inputs enter bounded encrypted execution, ciphernodes enforce threshold conditions, verification makes the result checkable, and only the permitted result is released.

The result is a new execution pattern: private inputs, verifiable outcomes, and no single operator in control of the process.

Participate in the Interfold network
A distributed network for confidential coordination.