The Future of Public Goods: From Speculative Grants to Proven Impact

Protocols like Optimism and Arbitrum allocate $100M+ in retroactive grants, but impact is assessed post-hoc. This creates misaligned incentives and funds popularity over provable value.

• Inefficient Capital: Funds projects that seemed good, not those that were good.
• High Overhead: Requires centralized committees and endless governance debates.
• Speculative: Rewards are a lottery, disincentivizing long-term builders.

Shift to continuous, verifiable funding via mechanisms like Hypercerts and Impact Markets. Funders buy "shares" in future outcomes, creating a liquid market for impact.

• Real-Time Signals: Price discovery indicates project efficacy as it happens.
• Aligned Incentives: Builders are funded to deliver, not to lobby governance.
• Composable Capital: Impact becomes a tradable, programmable asset class.

Projects like Dora Factory and Gitcoin Allo are building infrastructure for on-chain KPI attestations. Smart contracts autonomously measure outcomes (e.g., devs onboarded, bugs fixed, TVL secured).

• Trustless Verification: Eliminate committee bias with cryptographically proven metrics.
• Automated Payouts: Funding streams trigger upon hitting verifiable milestones.
• Data-Rich: Creates an immutable ledger of what actually drives ecosystem growth.

The endgame is a self-sustaining economic loop. Public goods generate verifiable value (e.g., security, liquidity), capture a fee via MEV redistribution or protocol revenue, and fund their own continuation.

• Sustainability: Reduces reliance on speculative token treasuries.
• Direct Value Capture: Aligns public good revenue with ecosystem health.
• Flywheel Effect: Successful goods fund the next generation of builders.

Protocols like Optimism and Arbitrum distribute millions in retroactive grants, but impact is judged by committees, not data. This creates politics and misaligned incentives.

• Subjective Judgement: Committees decide winners, not objective metrics.
• High Overhead: Manual review of applications and proposals.
• Slow Payouts: Grants are delayed, reducing utility for builders.

Projects like Gitcoin Allo and Hypercerts enable funding based on verifiable, on-chain contribution graphs. Impact is measured by smart contract interactions, not proposals.

• Automated Attribution: Code commits, transaction volume, and user growth are tracked on-chain.
• Programmable Funding: Smart contracts auto-distribute funds based on pre-set metrics.
• Composable Rewards: Contributions become tradable assets (e.g., Hypercerts) for future funding.

Traditional grant pools are finite, creating zero-sum competition. A project's success doesn't automatically fund its dependencies (e.g., a successful DEX doesn't fund the underlying RPC it uses).

• Tragedy of the Commons: Critical infrastructure is underfunded.
• Fragmented Incentives: No mechanism for value to flow upstream.
• Static Budgets: Grant pools are capped and deplete over time.

DAOs like Uniswap and Aave can program treasury distributions to fund dependencies via fee switches and revenue-sharing contracts.

• Automatic Royalties: A percentage of protocol fees is routed to designated public good dependencies.
• Sustainable Funding: Creates a perpetual funding engine tied to protocol success.
• Aligned Incentives: Infrastructure providers are rewarded proportionally to their usage.

Grant effectiveness is measured in blog posts and reports, not on-chain state. There's no way to audit if funded work actually improved network security, reduced latency, or increased adoption.

• No Verifiable KPIs: Success metrics are self-reported.
• Low Accountability: Grantees aren't penalized for missing targets.
• Limited Composability: Impact data is siloed and can't inform other funding decisions.

Frameworks like Karma GAP and Impact Markets allow funders to bond capital against specific, on-chain verifiable outcomes (e.g., reduce RPC latency by 20%).

• Pay-for-Performance: Funds are released only upon proof of outcome.
• On-Chain SLAs: Service Level Agreements are codified in smart contracts.
• Liquid Markets: Impact bonds can be traded, pricing risk and expectation.

Grants committees allocate capital based on proposals, not proof, leading to misaligned incentives and capital inefficiency. Billions in grant capital have been deployed with no verifiable ROI or accountability.

• High Overhead: Committees spend months evaluating unproven ideas.
• Builder Misalignment: Incentive to write compelling proposals, not ship usable code.
• No Feedback Loop: Success is rarely measured, failures are not learned from.

Pioneered by Optimism's RPGF, this model rewards projects after they've delivered proven value, using on-chain data for verification. Gitcoin Allo and Ethereum's PGF experiments are scaling the concept.

• Merit-Based Allocation: Funding follows usage, not promises.
• Radical Efficiency: Eliminates grant committee overhead.
• Stronger Ecosystems: Incentivizes building widely adopted infrastructure, like Etherscan alternatives or critical EIPs.

Projects mint non-transferable certificates (like Hypercerts) representing a claim of work done or impact achieved. These become the atomic unit for funding distribution and composable reputation.

• Composable Proof: Impact is a verifiable, on-chain asset.
• Market Discovery: Future funding rounds can weight votes based on past certificate holdings.
• Anti-Sybil: Cryptographic proof of unique contribution deters farming.

Platforms like Dune, Flipside, and Nansen move from dashboards to impact oracles. Smart contracts query them to autonomously distribute funds based on predefined, verifiable metrics (e.g., TVL secured, transactions facilitated, unique users).

• Objective Criteria: Removes human bias from evaluation.
• Real-Time Payouts: Funding triggers automatically upon hitting milestones.
• Transparent Baseline: Every stakeholder can audit the funding rationale.

Just as DeFi had yield farming, Impact Farming will emerge. Projects will optimize for vanity metrics (e.g., inflating user counts) instead of genuine utility. This requires robust metric design and sybil-resistant attribution.

• Metric Gaming: The 'Goodhart's Law' of on-chain impact.
• Oracle Manipulation: Attacks on the data sources determining payouts.
• Solution: Multi-dimensional scoring (LayerZero's DVN-style) and time-locked evaluations.

The convergence of RPGF, Hypercerts, and on-chain oracles creates a market for impact futures. DAOs and protocols can pre-commit funding for specific, measurable outcomes, creating a continuous funding flywheel for infrastructure.

• Predictable Builder Income: Teams fundraise against future impact claims.
• Protocol-Led Funding: Uniswap could autonomously fund the next MetaMask.
• Ecosystem Darwinism: Capital flows efficiently to the most proven value creators.