AI Agents that Vote
in DAO Governance

# Autonomous DAO governance agent that monitors proposals and votes
import asyncio, httpx
from openai import AsyncOpenAI

PURPLE_FLEA_KEY = "your-api-key"
oai = AsyncOpenAI()

class DAOGovernanceAgent:
    def __init__(self, api_key: str, dao_addresses: list[str]):
        self.api_key = api_key
        self.daos = dao_addresses
        self.voted = set()  # track proposals already voted on

    async def get_active_proposals(self, dao_addr: str) -> list[dict]:
        async with httpx.AsyncClient() as client:
            r = await client.get(
                f"https://purpleflea.com/api/dao/{dao_addr}/proposals",
                params={"status": "active"},
                headers={"X-API-Key": self.api_key}
            )
            return r.json()["proposals"]

    async def analyze_proposal(self, proposal: dict) -> str:
        """Use LLM to determine how to vote based on proposal text."""
        response = await oai.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": """You are a DAO governance agent for a DeFi protocol.
Vote FOR proposals that: increase treasury yield, improve security, or reduce fees.
Vote AGAINST proposals that: increase inflation, add centralization risks, or harm token holders.
Respond with exactly one word: FOR, AGAINST, or ABSTAIN."""
                },
                {
                    "role": "user",
                    "content": f"Proposal: {proposal['title']}\n\nDescription: {proposal['description']}"
                }
            ]
        )
        return response.choices[0].message.content.strip()

    async def cast_vote(self, dao_addr: str, proposal_id: str, vote: str) -> dict:
        async with httpx.AsyncClient() as client:
            r = await client.post(
                f"https://purpleflea.com/api/dao/{dao_addr}/vote",
                json={
                    "proposal_id": proposal_id,
                    "support": {"FOR": 1, "AGAINST": 0, "ABSTAIN": 2}[vote],
                    "reason": f"Autonomous vote by governance agent: {vote}"
                },
                headers={"X-API-Key": self.api_key}
            )
            return r.json()

    async def run_governance_loop(self):
        """Check for new proposals every hour and vote autonomously."""
        while True:
            for dao_addr in self.daos:
                proposals = await self.get_active_proposals(dao_addr)

                for proposal in proposals:
                    prop_id = proposal["id"]
                    if prop_id in self.voted:
                        continue

                    # Analyze and vote
                    vote = await self.analyze_proposal(proposal)
                    result = await self.cast_vote(dao_addr, prop_id, vote)

                    print(f"Voted {vote} on '{proposal['title']}' — tx: {result['tx_hash']}")
                    self.voted.add(prop_id)

            await asyncio.sleep(3600)  # check hourly

# Run the governance agent for multiple DAOs
agent = DAOGovernanceAgent(
    api_key=PURPLE_FLEA_KEY,
    dao_addresses=[
        "0xUniswapGovernor",
        "0xCompoundGovernor",
        "0xAaveGovernance"
    ]
)
asyncio.run(agent.run_governance_loop())