Compute Contracts
A Compute Contract is how Palliora turns an agreement into something that can actually be executed.
It describes not just what parties agree on, but how data is accessed, how computation is performed, who is allowed to see the results, and how everyone involved is rewarded. In Palliora, contracts are not passive records. They actively coordinate real computation on real data.
The problem Compute Contracts solve
Traditional smart contracts are good at enforcing simple rules on-chain, but they struggle with real-world workloads. They cannot handle large datasets, private inputs, or complex computation without either exposing data or becoming impractical.
Off-chain agreements solve the scalability problem, but they reintroduce trust. Once computation happens outside the chain, there is no strong guarantee that it was done correctly, privately, or according to the original agreement.
Compute Contracts close this gap. They allow parties to agree on off-chain computation while keeping execution accountable, verifiable, and aligned with the original agreement.
How a Compute Contract works
At a high level, a Compute Contract defines the full lifecycle of a computation:
Inputs: what data is involved and where it lives
Computation: what should be executed
Confidentiality: who can see what, and under what constraints
Roles: who executes, who verifies, who can retrieve outputs
Incentives: how rewards are distributed and under what conditions
Once agreed, the contract is recorded immutably. Guardians then enforce it step by step, coordinating data access, computation, and verification exactly as specified. Each action is tied back to the contract, so execution and rewards remain linked to what was originally agreed.
The contract itself does not perform computation. It acts as the shared source of truth that coordinates all actors involved.
Trust and guarantees
Compute Contracts do not assume trust between participants. They rely on a combination of cryptography, verification, and economic incentives:
Data can remain encrypted
Computation can be verified
Actors are rewarded only if they follow the contract
This allows parties to collaborate without trusting each other directly, as long as they trust the protocol and its incentives.
Compute Contracts are flexible. They can support different confidentiality levels, verification strategies, and economic arrangements depending on the use case.
What a Compute Contract is not
A Compute Contract is not:
A traditional smart contract that runs entirely on-chain
A legal agreement written in natural language
A loose workflow description that cannot be executed
It is precise enough to be enforced by the protocol, but flexible enough to support real-world data and computation.
It does not remove responsibility from participants. It defines responsibilities clearly and enforces them through the system.
How Compute Contracts fit into Palliora
Compute Contracts sit at the heart of Palliora:
They define the rules
Guardians enforce them
Data Availability ensures inputs and outputs exist
Calculators and verifiers execute and validate the work
Without Compute Contracts, Palliora would be a collection of components. With them, it becomes a coordinated system for trusted computation.
When you need to care about Compute Contracts
If you are simply using an app built on Palliora, you may never need to think about Compute Contracts directly. They operate behind the scenes.
If you are building on Palliora, designing workflows, or monetising data or models, understanding Compute Contracts becomes essential. They are the mechanism that turns intent into enforceable execution.
Last updated