Launching a Cross-DAO Grant Program

A Cross-DAO Grant Program is a coordinated funding mechanism where multiple decentralized autonomous organizations pool resources and governance to support projects that benefit their shared ecosystem. Unlike a single-DAO treasury, this model distributes risk, aligns incentives, and attracts higher-quality proposals by offering funding and validation from several established communities. Successful examples include the Optimism Collective's RetroPGF rounds, which involve a broad badgeholder community in funding public goods, and the collaborative efforts seen in the Ethereum ecosystem where multiple client teams and infrastructure DAOs co-fund critical development. The core challenge is designing a governance and operational framework that is transparent, efficient, and resistant to collusion.

The first step is defining the program's strategic scope and legal structure. You must answer key questions: What specific problem or vertical does the program address (e.g., developer tooling, user onboarding, security audits)? Which DAOs are ideal partners with aligned values and complementary resources? For legal wrappers, many programs use a Multisig wallet (via Safe) controlled by representatives from each partner DAO, or a Vesting Contract that releases funds based on milestone approvals. Some opt for a Purpose-Bound LLC for greater legal clarity. Establish clear funding tiers (e.g., small grants under $10k, milestone-based grants up to $50k, large proposals over $100k) and a transparent application process using platforms like Questbook or Gitcoin Grants Stack.

Technical implementation requires robust on-chain infrastructure. The funding treasury is typically a multi-chain vault using Safe{Wallet} on relevant networks (Ethereum, Arbitrum, Optimism, etc.), with a multi-signature policy requiring M-of-N approvals from partner DAO delegates. For recurring or milestone-based grants, use vesting contracts like Sablier or Superfluid to stream funds, reducing counterparty risk. Proposal and voting can be managed through a shared Snapshot space with weighted voting power or a custom-built frontend that aggregates proposals from a shared database (like Ceramic or Tableland). All operations should be transparently recorded on-chain or via attestations on EAS (Ethereum Attestation Service) to build legitimacy.

Governance is the most critical component. Decide on a review committee model: it could be a Council of appointed experts from each DAO, a Community Vote using token-weighted governance, or a Futarchy market for controversial decisions. Implement a clear rubric for scoring proposals based on impact, feasibility, and alignment. To prevent sybil attacks and ensure quality, incorporate peer review phases and KYC/KYB checks for large grants via providers like Gitcoin Passport. The process should culminate in an on-chain vote for final approval, executed via the multisig. Tools like Tally or Agave can help manage this governance lifecycle.

After launch, focus on operations, reporting, and iteration. Use project management tools like Dework or Coordinape to track grantee milestones and facilitate payments. Grantees should submit regular progress reports, with key metrics and deliverables published for transparency. Analyze program success using retroactive funding frameworks like RetroPGF to reward outstanding outcomes post-hoc. Finally, establish a feedback loop: collect data from applicants, reviewers, and partner DAOs to refine the application process, scoring rubric, and funding focus for the next round. This iterative approach, combined with immutable on-chain records, builds a sustainable and trusted cross-ecosystem funding institution.

The first prerequisite is strategic alignment. The participating DAOs must formally agree on the program's primary objective. Is it to fund shared public goods, accelerate a specific ecosystem, or foster interoperability between the DAOs' core protocols? This shared mission statement should be ratified via governance proposals in each DAO, creating a clear mandate. For example, a program between Optimism and Arbitrum might focus on funding Ethereum L2 infrastructure, while a collaboration between Aave and Compound could target decentralized lending innovations.

With a mission defined, the next step is scope definition. This involves setting concrete parameters: the total funding pool size and contribution split (e.g., 50/50 or based on treasury size), the grant categories (e.g., protocol development, research, community growth), and the geographic or technical focus areas. Establishing these boundaries upfront prevents scope creep and manages contributor expectations. It's also the stage to decide if the program will be an independent entity, a multisig-controlled pool, or a sub-DAO governed by representatives from each organization.

Governance structure is the operational backbone. You must design clear processes for proposal submission, review, voting, and fund disbursement. Key decisions include: Who are the grant reviewers? Will they be appointed delegates from each DAO, elected community members, or a hybrid model? What is the voting mechanism—simple majority, quadratic voting, or conviction voting? Tools like Snapshot for off-chain signaling, Safe (formerly Gnosis Safe) for fund custody, and Tally or Boardroom for governance tracking are commonly integrated. The chosen structure must be transparent and resistant to capture by any single party.

Finally, ensure legal and operational readiness. While DAOs often operate in a legal gray area, consider the implications of pooling and distributing funds. Some programs engage a legal wrapper or foundation. Operationally, you need dedicated communication channels (e.g., a forum category, Discord server), a public RFPs (Request for Proposals) page, and clear documentation outlining the entire process. The Moloch DAO framework and the Gitcoin Grants Stack provide proven, open-source templates for program mechanics and community rounds that can be adapted for a cross-DAO initiative.

A cross-DAO grant program enables a decentralized autonomous organization to fund projects across multiple blockchain ecosystems. The core architecture requires a secure treasury on a primary chain (like Ethereum mainnet) and a set of distribution contracts on each target chain (e.g., Arbitrum, Polygon, Base). This separation of concerns keeps the majority of funds secure while enabling efficient, low-cost disbursements. Key components include a governance module for proposal approval, a vault for fund custody, and bridge-aware disbursement logic. Using a modular design allows for upgrades to individual components without overhauling the entire system.

The treasury setup begins with selecting and deploying a secure multi-signature wallet or a more advanced DAO treasury management platform like Safe{Wallet} or Zodiac. This acts as the root of trust, holding the grant pool's capital. For Ethereum-based treasuries, integrating with Gnosis Safe is a common standard, providing customizable signing thresholds and role-based permissions. It's critical to establish clear governance parameters upfront: who can propose grants, what the voting and execution delays are, and the maximum disbursement per transaction. These rules are initially enforced by the multisig signers and can later be codified into smart contracts.

On the disbursement side, you need a Grant Disburser Contract on each recipient chain. This contract holds a limited operating budget bridged from the main treasury and executes payments based on instructions from the governance layer. A basic Solidity implementation includes functions to release funds to a recipient address upon approval, often requiring a signature from a trusted set of approvers or the DAO's governance contract. To prevent draining, implement withdrawal limits and timelocks. For cross-chain instruction, you can use a message-passing protocol like Axelar or LayerZero, or a simpler design where approvers submit the same signed transaction on the target chain.

Here is a simplified example of a disbursement contract's core function using OpenZeppelin's Ownable and ReentrancyGuard:

solidityCopy
function releaseGrant(address recipient, uint256 amount, bytes32 proposalId) external nonReentrant onlyOwner {
    require(amount <= maxGrantAmount, "Amount exceeds limit");
    require(!grantPaid[proposalId], "Grant already paid");
    grantPaid[proposalId] = true;
    (bool success, ) = recipient.call{value: amount}("");
    require(success, "Transfer failed");
    emit GrantReleased(proposalId, recipient, amount);
}

This function ensures each approved proposal is paid only once and includes guards against reentrancy attacks.

The final step is establishing the cross-chain workflow. A typical flow is: 1) A grant proposal is created and voted on via Snapshot or the DAO's on-chain governance. 2) Upon approval, an authorized executor triggers a transaction on the main treasury to bridge funds to the target chain's disburser contract. 3) The same executor (or a designated relayer) calls the releaseGrant function on the target chain, completing the payment. Tools like Connext for canonical bridging or SocketDL for liquidity aggregation can automate the fund transfer step. Regular audits of both the treasury and disburser contracts are non-negotiable for security.

Maintaining the program requires ongoing monitoring of balances across chains, tracking grant outcomes, and potentially implementing streaming vesting contracts like Sablier or Superfluid for milestone-based payouts. The architecture should be reviewed periodically to incorporate new security standards and bridge technologies. By combining a secure treasury hub with automated, audited disbursement spokes, DAOs can run transparent and efficient grant programs that span the multi-chain ecosystem.

A cross-DAO grant program enables multiple decentralized autonomous organizations to pool resources and collaboratively fund projects that benefit their shared ecosystem. This model is particularly effective for funding public goods, infrastructure, or research that no single DAO would finance alone. The core challenge is establishing a governance framework that is transparent, accountable, and resistant to capture by any single participant. Key design decisions include the committee structure, proposal lifecycle, and the on-chain mechanisms for voting and fund disbursement.

The first step is forming a grant committee with representatives from each participating DAO. This can be done via a governance proposal in each DAO to appoint or elect delegates. A common structure is a 5-7 member multisig wallet (e.g., using Safe) where each member represents a different DAO. The committee's mandate, budget, and operational rules should be codified in a publicly accessible charter. For on-chain transparency, consider using a Moloch v3 or DAOhaus framework to create a sub-DAO specifically for grant management, where membership shares represent voting power on proposals.

Proposals should be submitted through a standardized process, often beginning with a forum post for community discussion followed by a formal on-chain submission. Use a tool like Snapshot for off-chain sentiment signaling and Tally or Governor Bravo contracts for binding on-chain votes. The proposal smart contract should include clear parameters: uint256 grantAmount, address recipient, string ipfsHash (for proposal details), and uint256 vestingCliff. Implementing a streaming vest via a contract like Sablier or Superfluid can align incentives by distributing funds over time based on milestone completion.

Committee review and voting must be executed on-chain to ensure legitimacy. A typical flow involves: 1) Proposal submission to the grant DAO's governor contract, 2) A review period where committee members can assess the proposal, 3) An on-chain voting period using token-weighted or 1-member-1-vote logic, and 4) Automatic execution upon passing a predefined quorum and majority threshold. The entire history—from submission to execution—is immutable and publicly verifiable on the blockchain, which is critical for building trust among participating DAOs and the broader community.

Fund distribution requires secure, programmable treasury management. Instead of a single lump-sum transfer, consider deploying funds to a Gnosis Safe module that only releases funds upon the committee's multisig approval of a milestone. For even greater automation, integrate with OpenZeppelin Defender to create automated workflows where a successful on-chain vote triggers a fund release transaction. It's also prudent to require grant recipients to provide regular progress updates, potentially linked to on-chain activity or verified by oracles like Chainlink Proof of Reserve for physical infrastructure projects.

Finally, measure the program's success with on-chain metrics. Track the number of proposals, total value distributed, and the on-chain activity of funded projects using indexers like The Graph. This data should be reported back to the constituent DAOs through quarterly governance updates. A successful cross-DAO grant program not only funds valuable work but also strengthens the political and economic alliances between the participating organizations, creating a more resilient and collaborative ecosystem.

The application process begins with a clear, public-facing Request for Proposals (RFP). This document should specify the technical problem space, desired outcomes, funding tiers, and evaluation criteria. Use a standardized application form, often built with tools like Typeform or integrated directly into your DAO's governance platform (e.g., Snapshot, Commonwealth). Require applicants to submit a detailed technical proposal, a roadmap with milestones, a budget breakdown, and links to relevant past work or GitHub repositories. This structured intake ensures all submissions contain the information needed for a fair review.

Once applications are collected, they enter the technical review phase. This stage is typically managed by a Technical Review Committee (TRC) composed of domain experts from within the DAO's community. The TRC's role is to assess the feasibility, innovation, and technical soundness of each proposal. Key evaluation criteria include: the team's technical competency and track record, the architectural design and security considerations of the proposed solution, the clarity and realism of the development roadmap, and the alignment of the proposed technology stack with the ecosystem's standards (e.g., EVM-compatibility, use of specific oracles or bridges).

For in-depth assessment, reviewers should examine linked code repositories. Look for code quality, testing coverage, documentation, and prior contributions. A proposal to build a cross-chain messaging module should demonstrate understanding of protocols like LayerZero, Wormhole, or CCIP. The committee scores each proposal against the published criteria, often using a weighted rubric. This quantitative scoring, combined with qualitative feedback, creates a shortlist of the most promising applications. All reviews and scores should be documented transparently in a shared system like Notion or Google Sheets accessible to DAO members.

The final stage integrates community governance. The TRC presents its shortlist and rationale to the broader DAO, often via a governance forum post on Discourse or Commonwealth. This initiates a community discussion period where token holders can ask questions, debate merits, and signal sentiment. Following discussion, a formal on-chain vote is typically conducted using a snapshot or a full on-chain voting contract (e.g., OpenZeppelin Governor). A successful vote ratifies the grant allocation, triggering the funding process—often managed through a multisig wallet or a vesting contract like Sablier or Superfluid—and the commencement of milestone-based deliverables.

A cross-DAO grant program coordinates funding and governance across multiple decentralized autonomous organizations to support shared ecosystem goals. Unlike a single-treasury grant, it requires a multi-signature framework where each participating DAO controls a portion of the funds and voting power. The core mechanism is a milestone-based funding schedule, which releases tranches of capital upon the verification of predefined deliverables. This structure aligns incentives, reduces counterparty risk, and provides grantees with predictable funding cadence while giving DAOs continuous oversight. Tools like Gnosis Safe, Snapshot, and specialized platforms such as Questbook or Clr.fund are commonly used to orchestrate these programs.

The first step is defining the program's scope and governance. Participating DAOs must agree on the grant's strategic focus (e.g., funding Layer 2 tooling, developer education), the total funding pool, and the contribution split from each treasury. A grant committee or working group is typically formed, comprising delegates from each DAO, to manage operations. The legal and operational framework should be documented in a transparent Request for Proposals (RFP) or charter, published on forums like Commonwealth or Discourse. This charter must specify the application process, evaluation criteria, payment token (e.g., USDC, ETH), and the smart contract or multi-sig address that will hold the funds.

Technical implementation centers on automating payouts upon milestone completion. A common pattern uses a vesting contract or streaming payment protocol like Sablier or Superfluid. For example, a grant for a software library might have three milestones: 1) specification document, 2) MVP code commit, and 3) audit completion. Funds are locked in a contract that releases 30%, 40%, and 30% respectively. Completion is verified either by manual committee vote via Snapshot or by automated verification against on-chain conditions or GitHub commits using oracles like Chainlink. The code snippet below shows a basic milestone contract structure using OpenZeppelin's Ownable and a release function callable only by the grant manager address.

solidityCopy
// Simplified MilestonePayout contract example
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract MilestonePayout is Ownable {
    IERC20 public payoutToken;
    address public grantee;
    uint256 public totalGrant;
    uint256 public milestoneCount;
    uint256 public releasedCount;
    mapping(uint256 => uint256) public milestoneAmount;

    constructor(address _token, address _grantee, uint256[] memory _amounts) {
        payoutToken = IERC20(_token);
        grantee = _grantee;
        milestoneCount = _amounts.length;
        for (uint i = 0; i < _amounts.length; i++) {
            totalGrant += _amounts[i];
            milestoneAmount[i] = _amounts[i];
        }
        // Token transfer to this contract required after deployment
    }

    function releaseMilestone(uint256 _milestoneIndex) external onlyOwner {
        require(_milestoneIndex == releasedCount, "Invalid milestone sequence");
        uint256 amount = milestoneAmount[_milestoneIndex];
        require(payoutToken.transfer(grantee, amount), "Transfer failed");
        releasedCount++;
    }
}

Post-launch management involves continuous monitoring and reporting. Grantees should submit verification proofs for each milestone, which can include GitHub repository links, audit reports, or on-chain transaction IDs. The grant committee reviews these submissions and triggers the payout function. It's critical to maintain public transparency logs—often via a Notion page or a dedicated dashboard—that track all applications, committee votes, payout transactions, and milestone deliverables. This practice builds trust among participating DAOs and the wider community. Regular retrospectives should be held to assess the program's impact, using metrics like developer adoption, code commits, or protocol usage generated by the funded projects.

Key challenges include governance coordination lag between DAOs and milestone subjectivity. Mitigate these by using clear, objective deliverable definitions and a fallback dispute resolution process, potentially via a Kleros or UMA oracle. As the program scales, consider integrating with all-in-one grant platforms that offer built-in application forms, multi-sig management, and automated milestone tracking. A successful cross-DAO grant program not only funds valuable public goods but also strengthens collaborative relationships between autonomous organizations, creating a more resilient and interoperable ecosystem.

A Cross-DAO Grant Program is a coordinated funding initiative where multiple DAOs pool resources to support projects aligned with a shared mission, such as public goods, protocol development, or ecosystem growth. Unlike a single-DAO grant, it requires establishing a shared governance framework and standardized evaluation criteria acceptable to all participating organizations. Successful examples include the Optimism Collective's RetroPGF rounds, which distribute funding based on community impact, and Gitcoin Grants, which facilitate quadratic funding across ecosystems. The primary challenge is aligning diverse stakeholders on what constitutes value and success.

The first step is defining program objectives and key results (OKRs). Objectives should be specific, such as 'Increase developer activity on Layer 2 X' or 'Fund 10 open-source security tools.' Key Results must be measurable, like 'Award $500k across 20 projects' or 'Generate 50 new smart contract deployments.' This clarity is crucial for securing buy-in from participating DAOs, as each will assess the program's alignment with their own treasury goals. Establish a multi-sig wallet or use a tool like Safe{Wallet} for managing the pooled funds, with signers representing each contributing DAO to ensure transparent custody.

Designing the application and evaluation process is next. Create a unified application form requesting: project description, requested grant size, milestones, and expected impact metrics. Evaluation should involve a committee with representatives from each DAO or a delegated subDAO. Use a scoring rubric based on pre-defined OKRs. For technical grants, require code repositories and verification. Tools like Questbook or Clr.fund can help manage the application workflow, while Snapshot or Tally can be used for committee voting on final selections.

Impact measurement begins at the proposal stage. Require grantees to define their own success metrics, which become the basis for milestone-based payouts. Instead of a lump sum, structure payments to be released upon completion of verifiable deliverables, such as a completed audit report or a mainnet deployment. Use KPI options like Github commit activity, user adoption numbers, or on-chain transaction volume. For less tangible public goods, retroactive funding models (like those pioneered by Optimism) reward projects based on proven value after the fact, reducing upfront prediction risk.

Transparent reporting is non-negotiable. Create a public dashboard (using Dune Analytics or Flipside Crypto) to track fund disbursement, grantee progress, and aggregate impact metrics. Require grantees to publish periodic updates—monthly or per milestone—in a forum shared by all participating DAOs, such as a Commonwealth or Discourse thread. The final report should include a quantitative analysis of achieved KPIs and qualitative community feedback. This documentation is essential for justifying the program's continuation and securing funding for subsequent rounds from the participating DAOs.

Finally, iterate based on data. After each grant round, analyze what worked: Which projects delivered the highest ROI? Which evaluation criteria were most predictive? Use this analysis to refine the next round's OKRs, application process, and funding model. Publishing a post-mortem report fosters accountability and trust among all stakeholders. By systematically measuring and reporting impact, a Cross-DAO Grant Program evolves from a simple funding mechanism into a data-driven engine for sustainable ecosystem growth.

Before launching your program, conduct a final review of your core components. Ensure your on-chain treasury (e.g., a Safe multisig on Ethereum or a DAO-specific vault) is funded and access controls are set. Verify that your application and review portal (built with tools like Questbook or Gitcoin Grants Stack) is configured with the correct evaluation rubrics and reviewer permissions. Finally, confirm your payout mechanism is automated and secure, whether using a vesting contract like Sablier or a streaming protocol like Superfluid. A test transaction with a small grant is a critical final step.

Launch is not the end, but the beginning of an iterative cycle. Establish clear Key Performance Indicators (KPIs) from day one. Track metrics like application volume, reviewer throughput, time-to-decision, and, most importantly, the on-chain impact of funded projects (e.g., protocol usage, governance participation). Use this data in quarterly retrospectives with your steering committee to refine grant tiers, focus areas, and evaluation criteria. This data-driven approach transforms your program from a static fund into a dynamic ecosystem growth engine.

The field of decentralized grantmaking is evolving rapidly. To stay effective, engage with the broader community. Participate in forums like the DAO Research Collective and follow governance discussions in leading DAOs like Uniswap or Optimism. New primitives for retroactive public goods funding (like Optimism's RetroPGF) and on-chain reputation systems are constantly emerging. By staying informed and contributing to shared knowledge, you help advance the entire ecosystem's capacity to fund meaningful innovation.