Agent-Based Voting

The core mechanism where a user's voting power is assigned to a smart contract, not a person. This agent contract then executes votes autonomously according to its immutable logic, removing the need for manual participation in every proposal.

• Key Benefit: Enables continuous, rule-based participation without voter fatigue.
• Example: A user could delegate to an agent that always votes 'Yes' on proposals from a specific, verified development team.

Agents vote based on explicit, on-chain criteria defined in their code. Common rule types include:

• Whitelist/Blacklist: Vote for/against proposals from specific addresses.
• Sentiment Analysis: Vote based on off-chain signal aggregation (e.g., Snapshot sentiment).
• Treasury Thresholds: Auto-reject proposals requesting more than a set amount from the treasury.

This creates predictable, transparent voting behavior decoupled from human emotion or last-minute decisions.

A primary goal is to combat low participation rates in DAO governance. By delegating to a set-and-forget agent, a user ensures their voting power is always utilized, increasing the quantum of engaged voting power (QEVP) in the system.

• Impact: Improves governance security by making attacks requiring majority consensus more difficult.
• Statistic: Some protocols have seen delegation to agent contracts capture over 30% of circulating governance tokens.

Agent contracts can be designed to interact with other DeFi and DAO building blocks, creating complex, automated governance strategies.

• Example 1: An agent that only votes 'Yes' if a proposal also passes a bonding curve module for funding.
• Example 2: An agent that delegates its power to a different human delegate based on their performance metrics.
• Key Concept: This turns voting power into a programmable asset within a broader on-chain automation stack.

While automating votes, this model introduces unique risks. The principal-agent problem shifts from trusting a person to trusting code and its creators.

• Key Risks: Agent contract bugs, malicious rule logic, or governance attacks targeting the agent factory.
• Mitigations: Formal verification of agent code, agent registries with reputation scores, and time-locked upgrades for agent logic.

Pioneered and popularized by Compound Finance with its 'Bravo' upgrade and the concept of 'voting portals'. Other implementations include:

• Aave: Uses a similar delegate contract architecture for its governance.
• Elemental DAO: Explored agents for automated treasury management votes.
• The Model: A framework for building and discovering agent strategies.

These implementations treat the governance token as a yield-bearing asset where the yield is influence.

Agents are commonly delegated voting power to manage critical on-chain parameters for DeFi protocols. This includes adjusting:

• Interest rate models and collateral factors in lending markets.
• Fee structures and reward emissions for liquidity pools.
• Risk parameters like debt ceilings and liquidation thresholds. Agents use their expertise to vote on proposals, ensuring timely and technically sound updates without requiring constant input from all token holders.

DAO treasuries utilize agent-based voting for capital allocation decisions. Delegated agents vote on:

• Grant funding for ecosystem development and public goods.
• Strategic investments into other protocols or assets.
• Operational budgets for core development teams. This allows for professional, continuous management of multi-million dollar treasuries, moving beyond one-off community polls to a structured governance process.

In DPoS and nominated proof-of-stake (NPoS) blockchains, token holders delegate their staking power to validator agents. These agents:

• Produce blocks and secure the network.
• Vote on runtime upgrades and technical governance proposals.
• Are incentivized through staking rewards, with slashing penalties for malicious behavior. This creates a scalable and efficient consensus layer where stakeholders elect a professional set of validators.

Sophisticated agents can represent a protocol's interests in the governance of other, interconnected protocols. This is critical in the DeFi "money Lego" ecosystem. For example, a stablecoin DAO might delegate an agent to vote on changes to a critical lending market where its asset is widely used as collateral, ensuring systemic stability and alignment.

Agent-based systems enable gasless voting for delegators. Once power is delegated, the agent submits and pays for transactions. This allows for:

• Vote automation based on pre-defined rules or agent discretion.
• Reduced voter fatigue for token holders.
• Increased participation rates, as users aren't burdened with transaction costs and complexity for every proposal.

Protocols often delegate elevated powers to a security council or emergency multisig agent. This agent has limited, time-bound authority to:

• Pause the protocol in the event of a critical exploit or bug.
• Execute emergency upgrades to mitigate ongoing attacks.
• Manage asset recovery processes. This creates a vital failsafe mechanism that balances decentralization with the need for rapid response to crises.

Agent-based voting delegates governance power to autonomous smart contracts or bots programmed with specific rules. These on-chain agents can vote automatically based on predefined logic, such as following a delegate's lead, executing a specific strategy, or reacting to real-time on-chain data. This automates participation and enables complex, data-driven decision-making without constant manual intervention.

• Key Components: Agent wallet, execution logic, and governance contract interface.
• Automation Triggers: Time-based schedules, oracle price feeds, or specific proposal states.

This model extends liquid democracy, where voting power is a transferable token. Users can delegate their voting power not just to other humans, but to specialized agent contracts. These agents can then:

• Vote on behalf of thousands of delegators simultaneously.
• Re-delegate power dynamically to other experts or agents based on the proposal topic.
• Create a fluid network of decision-making where influence flows to the most competent actor (human or machine) for a given issue.

Agent-based voting addresses key scalability and efficiency challenges in on-chain governance:

• Voter Apathy & Fatigue: Automates participation for token holders who lack time or expertise.
• Complex Strategy Execution: Enables sophisticated voting strategies (e.g., vote with a majority, arbitrage governance incentives) that are impractical manually.
• Reduced Gas Costs: Agents can batch transactions or operate on L2s, lowering the cost of participation for delegators.
• 24/7 Responsiveness: Agents can vote immediately when a proposal snapshot is taken, ensuring no missed deadlines.

Delegating to autonomous agents introduces unique risks:

• Smart Contract Risk: The agent's code is a hacking target; a vulnerability could lead to malicious votes or fund theft.
• Principal-Agent Problems: The agent's actions may not align with the delegator's true preferences over time.
• Centralization of Power: Could lead to a small number of powerful agent controllers exerting outsized influence.
• Opaque Decision-Making: Complex agent logic can make the reasoning behind votes difficult to audit.

Futarchy is a governance model where decisions are made based on prediction markets. Agent-based voting is a key enabler for futarchy. Specified agents can be programmed to:

1. Monitor prediction markets created for a proposal (e.g., "Will metric X improve if this proposal passes?").
2. Execute votes automatically based on the market's price signal, implementing the decision deemed most valuable by the crowd's wisdom. This creates a form of automated, market-driven governance.

The primary risk is the compromise of the agent's private keys or the execution of malicious code. An attacker who controls an agent can vote on behalf of all its delegators. Key vulnerabilities include:

• Private key leakage from insecure storage.
• Logic bugs in the agent's decision-making algorithm.
• Supply chain attacks on the agent's dependencies or oracle data feeds.

Agent-based systems are vulnerable to Sybil attacks, where a single entity creates many pseudonymous agents to gain disproportionate influence. This can lead to:

• Collusion rings where agents coordinate to manipulate governance outcomes.
• Vote buying markets where agents sell their voting power.
• Circumvention of one-person-one-vote ideals, centralizing power with those who can deploy the most agents.

Delegators cede control to an agent's predefined logic, which may not reflect their current preferences or the evolving context of a proposal. This creates a principal-agent problem. Risks include:

• Stale strategies: An agent's rules may not adapt to novel proposal types.
• Opaque decisions: The agent's voting rationale may be a black box to delegators.
• Fee extraction: Agent operators could embed hidden fees or rent-seeking mechanisms.

Many agents rely on external oracles or data feeds (e.g., token prices, social sentiment) to make voting decisions. This introduces a critical dependency. Attack vectors include:

• Oracle manipulation to feed false data, triggering incorrect votes.
• Data feed downtime causing agents to abstain or default to a potentially harmful vote.
• Front-running where attackers see an agent's oracle query and manipulate the market before the vote executes.

Widespread agent adoption can lead to systemic fragility within a protocol's governance. Potential failures include:

• Cascading failures: A bug in a popular agent library could affect a majority of votes simultaneously.
• Governance paralysis: If critical agents go offline, voter participation may plummet below quorum.
• Reduced human oversight: Over-reliance on automation can make the system less resilient to novel, non-programmatic attacks.

Protocols and agent developers can implement safeguards to reduce risks:

• Agent slashing: Penalize agents for malicious or contradictory votes.
• Transparency mandates: Require agents to publicly disclose their decision logic and data sources.
• Time-locked delegation: Allow delegators to set a maximum delegation period.
• Multi-agent consensus: Require votes from multiple independent agents for critical decisions.
• Formal verification: Use tools to mathematically prove the correctness of an agent's core logic.

A foundational governance model where token holders delegate their voting power to a representative, often a human. Agent-based voting extends this by delegating to autonomous programs. Key aspects include:

• Revocable Delegation: Delegators can reclaim their voting power at any time.
• Vote Aggregation: The delegate's voting power is the sum of all tokens delegated to them.
• Examples: Compound's Governor Bravo and Uniswap's governance use delegated voting with human delegates.

A design paradigm where users specify a desired outcome (intent) rather than a series of transactions. Agent-based voting agents are intent solvers in this framework.

• User Declares Goal: E.g., "Vote 'Yes' on all proposals from Team X."
• Agent Executes Logic: The agent monitors proposals, applies its rules, and submits the vote.
• Infrastructure: Projects like Anoma and CowSwap pioneer intent-based architectures for trading, which governance agents can leverage.

The core function of a voting agent: automatically casting votes based on pre-defined rules or real-time analysis. This involves:

• On-Chain Rules: Simple logic like "vote against any proposal that increases the treasury spend by >10%."
• Off-Chain Data Integration: Agents can query oracles or APIs to inform decisions (e.g., vote based on a token's market price).
• Execution Triggers: Agents are activated by new proposal events emitted by the governance contract.

Unique attack vectors and considerations introduced by autonomous voting agents.

• Agent Compromise: If an agent's logic or the wallet holding it is hacked, all delegated votes can be misused.
• Rule Exploitation: Malicious proposals could be crafted to trick an agent's deterministic rules.
• Centralization Pressure: Efficient agents could attract massive delegation, potentially centralizing voting power in a few codebases.
• Mitigations: Use audited agent templates, time-locks on rule changes, and delegation limits.

A governance model proposed by Robin Hanson where decisions are made based on prediction markets. It shares conceptual ground with agent-based voting in its use of automated, market-driven signals.

• Market Decides: A market is created to predict the outcome of a policy; the better-predicted outcome is implemented.
• Agents as Market Makers: Voting agents could participate in these markets, using capital to signal beliefs.
• Contrast: While futarchy uses asset prices, agent-based voting typically uses coded logic.