Decentralized Value

Demo

About

Most funding systems turn many dimensions of value into one weighted score. That looks objective, but the weights already encode one definition of what “better” means. A solution can create an important new tradeoff and still receive no support simply because it does not maximize the organizer’s chosen score. Value Decentralization replaces one ranking with multiple independent funding decisions. Every submission is tested under the same published rules. Solutions that fail required conditions are rejected first. For valid solutions, each result stays separate instead of being averaged into one number. Different funders can then create Value Pools that support the kind of progress they care about—such as efficiency, resilience, fairness, or a genuinely new tradeoff. The same solution can be valuable to several pools, and the system does not need to declare one universal winner. The product makes this visible through interactive Arenas. Participants submit code, strategies, or decision rules; the system runs reproducible evaluations, shows what each solution improves and what it sacrifices, identifies non-dominated alternatives, and calculates rewards separately for each Value Pool. One Arena executes compiled Solidity bytecode and measures the tradeoff between calldata gas and decoder execution gas. Other Arenas apply the same protocol to multi-objective strategies, zero-knowledge proofs, and AI decision policies. The individual problems change, but the funding model stays the same. Ethereum is the settlement layer, not a magic judge. Evaluation can remain domain-specific and offchain, while final allocations and payments become publicly auditable and difficult to rewrite. We completed a real Sepolia demonstration that committed an allocation and executed a reward payment. Our ambition is much larger than building a better competition platform. We want any community to be able to define a value, make it measurable and verifiable, attach independent capital to it, and create sustained demand around improving it. If that demand persists, new builders, evaluators, standards, companies, and eventually entirely new industries can form around values that markets previously ignored. Ethereum decentralized who can own and transact. Value Decentralization asks the next question: can we decentralize what gets funded?

How it's made

We built Value Decentralization as a verifiable evaluation layer for problems where “better” cannot honestly be reduced to one number. The core is our own deterministic multi-objective evaluation engine. Each metric remains independent and can be either minimized or maximized. Invalid solutions are removed by Hard Constraints before comparison. Valid results are normalized against published bounds, placed on a Pareto Frontier, and measured by exact hypervolume and exclusive frontier contribution across up to six dimensions. Reward calculations use deterministic integer arithmetic and stable tie-breaking, so changing submission order cannot change the result. What makes the system Web3-native is not simply that rewards are sent through a smart contract. We built an evidence chain around the evaluation itself. Every evaluation environment is versioned. Dataset, constraints, metrics, evaluator settings, submitted artifact, and measured outcomes are canonicalized and connected through Keccak-256 hashes. If the benchmark changes, the Context Hash changes. If a submission or measurement changes, the Result Hash changes. This makes an offchain evaluation reproducible and tamper-evident before Ethereum is used to finalize the outcome. For our Ethereum-native benchmark, we do not use mocked gas numbers. Ethereum Calldata Compression compiles real Solidity codecs and executes their runtime bytecode inside an EthereumJS Cancun EVM. The evaluator checks output correctness, verifies malformed-input rejection, measures calldata gas and decoder execution gas independently, and then calculates the resulting Pareto contribution. This lets us evaluate competing Ethereum implementations from executable evidence rather than self-reported benchmark numbers. We also built a real privacy primitive with Semaphore V4. Secret Gate creates a disposable identity locally and generates a zero-knowledge membership proof inside a browser Web Worker. The private identity never needs to leave the device. The server verifies the proof and atomically rejects reuse of the same nullifier. This demonstrates how future competitions can prove eligibility or one-use participation without turning identity data into public onchain state. A second unusual problem appears when AI Agents become participants: LLM execution is non-deterministic, but evaluation must be reproducible. In Rescue Room, an OpenAI Agents SDK Commander sees only the current public state and returns structured Actions. We do not treat hidden model reasoning as evidence. Instead, every Action is recorded against the exact Public View Hash that produced it. The recorded Action sequence is then replayed through a deterministic state machine. The model may make a different decision on another run, but the submitted behavior always reproduces the same outcome and Result Hash. These components share the same evidence model. A Solidity optimization, a zero-knowledge interaction, a deterministic strategy, or an AI policy can all become an Artifact evaluated under a fixed Context and compared without inventing one universal score. Ethereum is used at the boundary where trust should stop. Our Solidity settlement contract commits a final allocation, prevents duplicate allocation and payment, checks available reward reserves, and exposes the final transfer publicly. We demonstrated the complete commitment and reward path on Sepolia. The blockchain does not pretend to prove that an offchain metric is socially correct; it proves what result was committed and what was actually paid. The sponsor technologies extend this architecture rather than define it. ENSv2 adds fine-grained identity and permission management for evaluators and protocol actors. Bazantic makes the evaluation API discoverable and usable by autonomous Agents. Chainlink CRE Confidential Workflows are being explored as the Hidden Final boundary, so committed private scenarios can evaluate frozen submissions before those scenarios are revealed for public reproduction. The application layer uses Next.js, TypeScript, React and Vercel, with Upstash Redis for durable competition state and Privy for account and wallet UX. Solidity contracts are tested with Foundry and accessed through viem. The result is not just another leaderboard or optimization dashboard. It is reusable infrastructure for open competitions, protocol engineering, AI Agent evaluation, grants, procurement, and other systems where several legitimate definitions of progress must remain visible at the same time. The technical idea is simple to state but difficult to implement: measure different values independently, make the evidence reproducible, preserve real tradeoffs, and use Web3 to make the rules, identities, results, and final commitments harder for any single operator to rewrite.