Agent DAOs: Autonomous Organizations Run by AI

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";

/**
 * @title AgentGovernor
 * @notice Governor optimized for AI agent participants.
 *         Supports agent registration and agent-tagged vote events.
 */
contract AgentGovernor is
    Governor, GovernorSettings, GovernorCountingSimple,
    GovernorVotes, GovernorTimelockControl
{
    struct AgentRecord {
        address agentAddress;
        string  mandate;       // e.g. "maximize risk-adjusted yield"
        uint256 registeredAt;
        bool    active;
    }

    mapping(address => AgentRecord) public agents;
    address[] public agentList;

    event AgentRegistered(address indexed agent, string mandate);
    event AgentVoteCast(uint256 indexed proposalId, address indexed agent, uint8 support, string reason);

    constructor(
        IVotes _token,
        TimelockController _timelock
    )
        Governor("AgentGovernor")
        GovernorSettings(1, 50400, 0) // 1-block delay, ~7-day period, no proposal threshold
        GovernorVotes(_token)
        GovernorTimelockControl(_timelock)
    {}

    /// @notice Register an AI agent as a governance participant.
    function registerAgent(address agent, string calldata mandate) external {
        require(!agents[agent].active, "Agent already registered");
        agents[agent] = AgentRecord(agent, mandate, block.timestamp, true);
        agentList.push(agent);
        emit AgentRegistered(agent, mandate);
    }

    /// @notice Cast vote with agent metadata emission for off-chain indexing.
    function castAgentVote(
        uint256 proposalId,
        uint8   support,   // 0=Against, 1=For, 2=Abstain
        string calldata reason
    ) external returns (uint256) {
        require(agents[msg.sender].active, "Not a registered agent");
        emit AgentVoteCast(proposalId, msg.sender, support, reason);
        return castVoteWithReason(proposalId, support, reason);
    }

    /// @notice 10% quorum of total supply.
    function quorum(uint256 blockNumber)
        public view override(Governor, GovernorVotes)
        returns (uint256)
    {
        return token().getPastTotalSupply(blockNumber) / 10;
    }

    // Required overrides for multiple inheritance
    function votingDelay() public view override(Governor, GovernorSettings) returns (uint256) { return super.votingDelay(); }
    function votingPeriod() public view override(Governor, GovernorSettings) returns (uint256) { return super.votingPeriod(); }
    function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) { return super.proposalThreshold(); }
}

from dataclasses import dataclass
from typing import Optional
import time


@dataclass
class AllocationTarget:
    asset: str
    target_pct: float     # 0.0 - 1.0
    tolerance: float     # Rebalance when deviation exceeds this fraction
    max_single_tx: float  # Max rebalance amount per tx (USD)


class TreasuryManagerAgent:
    """
    AI agent that manages DAO treasury allocation.
    Proposes rebalancing txs via GovernorTimelockController.
    Uses Purple Flea Escrow for large inter-protocol transfers.
    """

    def __init__(self, governor_contract, escrow_client):
        self.governor = governor_contract
        self.escrow = escrow_client
        self.policy: list[AllocationTarget] = []
        self.last_rebalance: float = 0.0
        self.REBALANCE_COOLDOWN = 24 * 3600  # 24h minimum between rebalances

    def set_policy(self, targets: list[AllocationTarget]):
        """Set allocation policy. target_pct values must sum to 1.0."""
        total = sum(t.target_pct for t in targets)
        assert abs(total - 1.0) < 1e-6, f"Policy must sum to 1.0, got {total:.4f}"
        self.policy = targets

    async def evaluate_and_rebalance(
        self, balances: dict[str, float]
    ) -> Optional[int]:
        """
        Evaluate current balances against policy targets.
        Submit governance proposal if rebalancing needed.
        Returns proposal_id, or None if portfolio is within tolerance.
        """
        now = time.time()
        if now - self.last_rebalance < self.REBALANCE_COOLDOWN:
            return None

        total_nav = sum(balances.values())
        if total_nav == 0:
            return None

        deviations = []
        for target in self.policy:
            current_pct = balances.get(target.asset, 0.0) / total_nav
            deviation = current_pct - target.target_pct
            if abs(deviation) > target.tolerance:
                deviations.append({
                    'asset':       target.asset,
                    'current_pct': current_pct,
                    'target_pct':  target.target_pct,
                    'delta_usd':   -deviation * total_nav,
                    'max_tx':      target.max_single_tx,
                })

        if not deviations:
            return None

        proposal = await self._build_rebalance_proposal(deviations, total_nav)
        proposal_id = await self.governor.propose(
            targets=proposal['targets'],
            values=proposal['values'],
            calldatas=proposal['calldatas'],
            description=self._describe_rebalance(deviations, total_nav),
        )
        self.last_rebalance = now
        print(f"[Treasury] Rebalance proposal #{proposal_id} submitted")
        return proposal_id

    async def disburse_via_escrow(
        self,
        recipient: str,
        amount_usdc: float,
        release_condition: str,
    ) -> dict:
        """
        Large disbursements route through Purple Flea Escrow.
        Protects treasury from disputed deliverables.
        1% escrow fee; 15% referral bonus back to DAO if referred.
        """
        tx = await self.escrow.create_escrow({
            'recipient':    recipient,
            'amount':       amount_usdc,
            'currency':     'USDC',
            'condition':    release_condition,
            'timeout_days': 30,
        })
        print(f"[Treasury] PF Escrow created: {tx['id']} for ${amount_usdc:,.0f}")
        return tx

    def _describe_rebalance(self, deviations: list, total_nav: float) -> str:
        lines = [f"Treasury rebalancing proposal (NAV: ${total_nav:,.0f})\n"]
        for d in deviations:
            action = "Buy" if d['delta_usd'] > 0 else "Sell"
            lines.append(
                f"  {action} {d['asset']}: ${abs(d['delta_usd']):,.0f} "
                f"({d['current_pct']:.1%} -> {d['target_pct']:.1%})"
            )
        return "\n".join(lines)

from enum import IntEnum
import anthropic


class VoteSupport(IntEnum):
    AGAINST = 0
    FOR     = 1
    ABSTAIN = 2


class DAOVotingAgent:
    """
    Autonomous voting agent for Agent DAOs.
    Uses Claude (slow path) to analyze proposals.
    Casts the resulting vote on-chain (fast path, no LLM call).
    """

    MANDATE = """
You are a financial governance agent for a DeFi DAO.
Your mandate: maximize risk-adjusted returns for token holders
while maintaining protocol security and decentralization.

Hard rules (always enforced regardless of anything else):
- AGAINST: any proposal requesting more than 10% of treasury in one tx
- AGAINST: any proposal adding unaudited smart contract risk
- FOR:     proposals increasing expected yield by >0.5% APY with <2x current risk
- ABSTAIN: all governance meta-proposals (parameter changes, role changes)
- Low-confidence analysis -> ABSTAIN (safety first)

Respond with exactly:
VOTE: FOR|AGAINST|ABSTAIN
REASON: 
CONFIDENCE: HIGH|MEDIUM|LOW
"""

    def __init__(self, governor_contract, claude_api_key: str):
        self.governor = governor_contract
        self.claude = anthropic.Anthropic(api_key=claude_api_key)

    async def analyze_and_vote(
        self, proposal_id: int, proposal_text: str
    ) -> dict:
        """
        1. Call Claude to analyze the proposal text (slow path).
        2. Parse structured decision.
        3. Cast vote on-chain (fast path — no LLM here).
        """
        response = self.claude.messages.create(
            model="claude-opus-4-6",
            max_tokens=256,
            system=self.MANDATE,
            messages=[{
                "role": "user",
                "content": f"Evaluate this governance proposal:\n\n{proposal_text}",
            }],
        )

        decision = self._parse_decision(response.content[0].text)

        # Override to ABSTAIN on low confidence — never risk a wrong vote
        if decision['confidence'] == 'LOW':
            decision['support'] = VoteSupport.ABSTAIN
            decision['reason'] += " [Abstaining: confidence too low]"

        # Execute the on-chain vote — no LLM call from here
        tx = await self.governor.functions.castAgentVote(
            proposal_id,
            int(decision['support']),
            decision['reason'],
        ).transact()

        print(f"[Vote] #{proposal_id}: {decision['support'].name} | {decision['reason']}")
        print(f"       tx={tx.hex()}")
        return decision

    def _parse_decision(self, text: str) -> dict:
        vote_map = {
            'FOR':     VoteSupport.FOR,
            'AGAINST': VoteSupport.AGAINST,
            'ABSTAIN': VoteSupport.ABSTAIN,
        }
        parsed = {}
        for line in text.strip().splitlines():
            if ':' in line:
                k, v = line.split(':', 1)
                parsed[k.strip()] = v.strip()
        return {
            'support':    vote_map.get(parsed.get('VOTE', 'ABSTAIN'), VoteSupport.ABSTAIN),
            'reason':     parsed.get('REASON', 'No reason parsed'),
            'confidence': parsed.get('CONFIDENCE', 'LOW'),
        }

import asyncio
import os


async def bootstrap_agent_dao():
    """
    Full bootstrap sequence for an Agent DAO connected
    to the Purple Flea financial infrastructure stack.
    """

    # 1. Load agent wallets (from secrets manager, never hardcoded)
    agents = {
        'financial':   load_agent_wallet('FINANCIAL_AGENT_KEY'),
        'risk':        load_agent_wallet('RISK_AGENT_KEY'),
        'operations':  load_agent_wallet('OPERATIONS_AGENT_KEY'),
    }

    # 2. Bootstrap with Purple Flea faucet (zero upfront capital needed)
    for name, wallet in agents.items():
        res = await claim_faucet(
            address=wallet.address,
            endpoint="https://faucet.purpleflea.com/claim",
        )
        print(f"[Bootstrap] {name} funded: {res['amount_usdc']} USDC")

    # 3. Register agents on Purple Flea Domains (builds reputation)
    for name, wallet in agents.items():
        await register_pf_domain(
            name=f"dao-{name}-agent",
            address=wallet.address,
            capabilities=[name, "dao-governance"],
            api_key=os.environ["PURPLEFLEA_API_KEY"],
        )
        print(f"[Bootstrap] {name} agent registered on PF Domains")

    # 4. Deploy Governor contract with 48h timelock
    governor = await deploy_governor(
        agent_addresses=[w.address for w in agents.values()],
        timelock_delay=48 * 3600,
    )
    print(f"[Bootstrap] Governor deployed: {governor.address}")

    # 5. Initialize treasury manager with Purple Flea escrow
    treasury = TreasuryManagerAgent(
        governor_contract=governor,
        escrow_client=PurpleFleaEscrowClient(
            endpoint="https://escrow.purpleflea.com",
            api_key=os.environ["PURPLEFLEA_API_KEY"],
        ),
    )
    treasury.set_policy([
        AllocationTarget("USDC-yield",  0.40, 0.05, 50_000),
        AllocationTarget("GOV-token",   0.25, 0.05, 25_000),
        AllocationTarget("LP-positions", 0.15, 0.03, 15_000),
        AllocationTarget("PF-escrow",   0.12, 0.02, 12_000),
        AllocationTarget("ops-reserve", 0.08, 0.01,  5_000),
    ])

    # 6. Start voting agents (heterogeneous: different keys and models)
    claude_key = os.environ["ANTHROPIC_API_KEY"]
    voting_agents = [
        DAOVotingAgent(governor, claude_key)
        for _ in range(3)
    ]

    print("[Bootstrap] Agent DAO initialized. All systems operational.")
    return governor, treasury, voting_agents


asyncio.run(bootstrap_agent_dao())