The Future of Follow-On Rounds: Automated by Governance Proposals

Manual, multi-sig governance for treasury allocations is slow and opaque, creating a ~2-4 week lag between deal agreement and funding. This kills momentum and introduces execution risk.

• Key Benefit 1: Automated proposals enable instant execution upon predefined conditions (e.g., milestone completion).
• Key Benefit 2: Transparent, on-chain voting history creates an auditable capital trail for all stakeholders.

Frameworks like OpenZeppelin Governor and Compound's Bravo are evolving into capital allocation engines. Smart contracts can now hold and auto-deploy funds based on governance votes, removing manual transfer steps.

• Key Benefit 1: Enables streaming vesting and milestone-based tranches directly from the DAO treasury.
• Key Benefit 2: Integrates with Safe{Wallet} and Zodiac for secure, modular execution, reducing multi-sig overhead.

Protocols cannot automate investment in what they cannot measure. On-chain reputation systems (e.g., Gitcoin Passport, ARCx) and revenue analytics (e.g., Token Terminal, Dune) provide the verifiable metrics needed for algorithmic decision-making.

• Key Benefit 1: Sybil-resistant scoring allows for automated eligibility checks and tiered investment terms.
• Key Benefit 2: Real-time financial KPIs (revenue, TVL, user growth) serve as objective triggers for follow-on funding rounds.

DAO treasuries hold $30B+ in assets but suffer from slow, politicized manual allocation. Each follow-on round requires a new, contentious vote, creating ~30-60 day delays and distracting from core protocol work.

• Voter Fatigue: High cognitive load for token holders on repetitive capital decisions.
• Inefficient Pricing: Manual rounds fail to capture real-time market signals, leaving value on the table.
• Opaque Process: Lack of standardized frameworks leads to inconsistent deal terms and founder frustration.

Embed follow-on logic directly into governance smart contracts, turning capital allocation into a parameterized, executable policy. Inspired by Compound's Governor and Aave's Governance V2, but for funding.

• Automated Disbursement: Pre-approved capital streams release upon hitting verifiable, on-chain milestones (e.g., TVL, revenue, integrations).
• Dynamic Valuation: Use oracle-fed pricing models (e.g., bonding curves, time-based discounts) to automate round pricing.
• Composability: Modules plug into existing DAO tooling like Snapshot, Tally, and Safe{Wallet} for seamless execution.

Shift from application-specific proposals to declarative intents. Founders post capital needs and terms; DAOs or syndicates signal fulfillment preferences, with solvers (like UniswapX or CowSwap for deals) competing to execute.

• Solver Competition: Drives better terms and fee efficiency for the DAO, similar to Across Protocol's relay model.
• Cross-Chain Capital: Leverage interoperability layers like LayerZero and Axelar to tap liquidity from any treasury chain.
• Credible Neutrality: Removes human bias; funding decisions are based on pre-committed, transparent rules.

Moloch's ragequit-and-guildkick mechanisms provide the foundational primitives for frictionless capital entry/exit. The next evolution integrates bribe markets (via Vote Escrow models like Curve's) to align investor and DAO incentives programmatically.

• Streaming Proposals: Capital is streamed over time; members can ragequit their share if milestones are missed, forcing accountability.
• Bribe-For-Access: Projects can directly incentivize DAO members to fund them, creating a liquid market for governance attention.
• Minimal Trust: The DAO only enforces the rules of the game, not the outcomes, reducing regulatory surface area.

Automation's weakness is its dependency on input data. Milestone oracles for disbursement are attack vectors. Systems must inherit security from battle-tested oracle networks like Chainlink and anti-sybil frameworks like BrightID or Gitcoin Passport.

• Data Integrity: Require multi-chain, multi-source oracles with staked security to trigger funding releases.
• Sybil-Resistant Voting: Integrate proof-of-personhood to prevent whale-dominated or bot-driven governance attacks on funding pools.
• Circuit Breakers: Time-locks and multi-sig guardian roles for emergency pauses, balancing automation with necessary oversight.

The convergence of these primitives creates self-funding, self-investing protocol ecosystems. Imagine an Optimism RetroPGF round that automatically funds projects based on proven usage metrics, or a Lido DAO that auto-invests treasury yield into related liquid staking derivatives.

• Perpetual Flywheel: Protocol revenue automatically recycled into ecosystem growth via programmed follow-ons.
• Talent Discovery: Automated grants and investments surface builders based on on-chain reputation, not pitch decks.
• Capital as a Feature: The most robust developer platforms will offer embedded, automated funding as a core service.

Automated execution turns governance into a high-value target. A successful exploit doesn't just steal funds; it hijacks the protocol's future capital allocation.\n- Attack Vector: Malicious proposal disguised as legitimate upgrade.\n- Consequence: Permanent drain of the entire follow-on treasury.\n- Mitigation: Requires multi-sig timelocks and rigorous proposal vetting, defeating automation's purpose.

Automated rounds relying on price feeds or completion metrics are only as strong as their oracle. Attackers can manipulate data to trigger or block funding.\n- Attack Vector: Flash loan to skew DEX price, falsely signaling 'milestone achieved'.\n- Consequence: Funds released to undeserving or malicious projects.\n- Defense Layer: Requires decentralized oracle networks like Chainlink with stake-slashing, adding latency and cost.

Public mempools expose automated governance actions. Searchers can front-run treasury disbursements or sandwich token purchases.\n- Attack Vector: Bot detects passed proposal, front-runs the protocol's buy order.\n- Consequence: Protocol overpays, value is extracted by MEV bots, not the funded team.\n- Solution: Requires private transaction systems like Flashbots SUAVE or CowSwap-style batch auctions.

Automated systems interacting with DeFi legos (e.g., swapping via Uniswap, bridging via LayerZero) inherit their risks. One exploited dependency cascades.\n- Attack Vector: Bridge hack (e.g., Wormhole, Multichain) or DLP failure locks cross-chain funds.\n- Consequence: Follow-on rounds freeze, breaking funding promises.\n- Reality: Risk cannot be eliminated, only managed via insurance partners like Nexus Mutual or Sherlock.

Automation requires hard-coded rules (e.g., 'release 20% after 6 months'). Overly rigid rules are gamed; overly flexible rules require governance, creating bottlenecks.\n- Attack Vector: Project structures deliverables to hit trivial metrics, draining treasury without real progress.\n- Consequence: Capital efficiency plummets; the system funds 'checkbox' projects.\n- Dilemma: Human judgment is slow but adaptive. Algorithms are fast but brittle.

On-chain automation operates at block speed. Off-chain legal frameworks (SAFEs, terms) move at human speed. This creates unenforceable agreements and liability gaps.\n- Attack Vector: Funded team violates legal terms, but automated system has already released next tranche.\n- Consequence: Protocol has no legal recourse; reputational damage and investor lawsuits follow.\n- Hybrid Model: Requires Ricardian contracts or services like OpenLaw to bind on/off-chain actions.

Manual, multi-week governance cycles for follow-on funding create fatal execution risk. By the time a proposal passes, market conditions and team runway have shifted.

• Opportunity Cost: Projects lose ~4-6 weeks of critical development time.
• Execution Risk: Voters can't commit future capital, creating uncertainty for builders.
• Market Misalignment: Static proposals fail to adapt to real-time on-chain metrics like user growth or fee generation.

Replace one-time grants with continuous funding contracts triggered by on-chain KPIs. Think Sablier or Superfluid streams, but governed by a DAO.

• Automated Vesting: Release funds upon hitting pre-defined, verifiable milestones (e.g., $100k protocol revenue, 10k new users).
• Reduced Overhead: No need for a new proposal for each tranche; the initial proposal encodes the entire funding logic.
• Real-Time Alignment: Capital flow automatically correlates with project performance, creating a tighter feedback loop.

Infrastructure like OpenZeppelin Defender and Gelato Network allows governance to set rules that auto-execute. This moves DAOs from legislators to system designers.

• Trustless Automation: Proposals deploy autonomous agents that manage the funding schedule and conditions.
• Composability: Can integrate with Chainlink oracles for external data or Safe{Wallet} for multi-sig releases.
• Fail-Safes: Built-in conditions can pause streams if KPIs trend negatively, protecting treasury assets.

The burden shifts from voters analyzing each grant to architects designing incentive-compatible systems. This is the Curve Wars model applied to ecosystem funding.

• Focus on Parameters: Governance debates the rules (KPIs, vesting curves, total budget) not individual projects.
• Scalability: A single well-designed mechanism can manage 100+ projects without voter fatigue.
• Long-Term Games: Creates sustainable flywheels where success funds more success, moving beyond zero-sum grant allocation.