added economy coordinator and agent interface

agents/__init__.py

@@ -0,0 +1,2 @@
+"""CGAE Agent implementations."""
+from agents.base import BaseAgent, AgentStrategy, AgentDecision

agents/base.py

@@ -0,0 +1,156 @@
+"""
+Base Agent - Abstract interface for CGAE economic agents.
+
+Each agent has:
+- A model identity (simulated or real)
+- A robustness profile (true underlying robustness)
+- An economic strategy (how it decides what to do each step)
+- A wallet (balance, income, expenses)
+"""
+
+from __future__ import annotations
+
+import random
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+from cgae_engine.gate import RobustnessVector, Tier
+from cgae_engine.contracts import CGAEContract
+
+
+class AgentStrategy(Enum):
+    CONSERVATIVE = "conservative"
+    AGGRESSIVE = "aggressive"
+    BALANCED = "balanced"
+    ADAPTIVE = "adaptive"
+    CHEATER = "cheater"
+
+
+@dataclass
+class AgentDecision:
+    """What the agent decides to do in a given step."""
+    action: str  # "bid", "execute", "invest_robustness", "idle", "delegate"
+    contract_id: Optional[str] = None
+    investment_dimension: Optional[str] = None  # "cc", "er", "as"
+    investment_amount: float = 0.0
+    output: Any = None
+    details: dict = field(default_factory=dict)
+
+
+class BaseAgent(ABC):
+    """
+    Abstract base class for CGAE economic agents.
+
+    Subclasses implement the strategy: how the agent decides which contracts
+    to bid on, whether to invest in robustness, and how to execute tasks.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        strategy: AgentStrategy,
+        true_robustness: RobustnessVector,
+        capability: float = 0.5,
+        model_config: Optional[dict] = None,
+    ):
+        self.name = name
+        self.strategy = strategy
+        self.true_robustness = true_robustness
+        self.capability = capability  # Task success probability baseline
+        self.model_config = model_config or {"model": name, "strategy": strategy.value}
+
+        # Set by the economy on registration
+        self.agent_id: Optional[str] = None
+
+        # Internal tracking
+        self._decisions: list[AgentDecision] = []
+        self._step_count: int = 0
+
+    @abstractmethod
+    def decide(
+        self,
+        available_contracts: list[CGAEContract],
+        current_tier: Tier,
+        balance: float,
+        current_exposure: float,
+        budget_ceiling: float,
+    ) -> AgentDecision:
+        """
+        Make a decision for this time step.
+
+        Args:
+            available_contracts: Contracts the agent is eligible to bid on
+            current_tier: Agent's current tier
+            balance: Current token balance
+            current_exposure: Current economic exposure
+            budget_ceiling: Maximum exposure for current tier
+        """
+        ...
+
+    @abstractmethod
+    def execute_task(self, contract: CGAEContract) -> Any:
+        """
+        Execute a task and produce output.
+        The output will be verified against the contract's constraints.
+        """
+        ...
+
+    def task_success_probability(self, contract: CGAEContract) -> float:
+        """
+        Probability of successfully completing a contract.
+        Depends on capability and the robustness dimension most
+        relevant to the contract.
+        """
+        base = self.capability
+        difficulty = contract.difficulty
+        # Higher difficulty reduces success probability
+        return max(0.05, min(0.95, base * (1.0 - difficulty * 0.5)))
+
+    def robustness_investment_cost(self, dimension: str, amount: float) -> float:
+        """Cost to improve a robustness dimension by `amount`."""
+        # Quadratic cost: harder to improve as you get higher
+        current = getattr(self.true_robustness, dimension if dimension != "as" else "as_")
+        return amount * (1.0 + current * 2.0)
+
+    def invest_robustness(self, dimension: str, amount: float) -> RobustnessVector:
+        """
+        Invest in improving a robustness dimension.
+        Returns the new robustness vector.
+        """
+        cc = self.true_robustness.cc
+        er = self.true_robustness.er
+        as_ = self.true_robustness.as_
+        ih = self.true_robustness.ih
+
+        if dimension == "cc":
+            cc = min(1.0, cc + amount)
+        elif dimension == "er":
+            er = min(1.0, er + amount)
+        elif dimension == "as":
+            as_ = min(1.0, as_ + amount)
+
+        self.true_robustness = RobustnessVector(cc=cc, er=er, as_=as_, ih=ih)
+        return self.true_robustness
+
+    def record_decision(self, decision: AgentDecision):
+        self._decisions.append(decision)
+        self._step_count += 1
+
+    @property
+    def decisions(self) -> list[AgentDecision]:
+        return list(self._decisions)
+
+    def to_config(self) -> dict:
+        return {
+            "name": self.name,
+            "strategy": self.strategy.value,
+            "capability": self.capability,
+            "true_robustness": {
+                "cc": self.true_robustness.cc,
+                "er": self.true_robustness.er,
+                "as": self.true_robustness.as_,
+                "ih": self.true_robustness.ih,
+            },
+        }

cgae_engine/economy.py

@@ -0,0 +1,236 @@
+"""
+CGAE Economy — Top-level coordinator.
+
+Ties together registry, gate, contracts, temporal dynamics into
+a single coherent economic system.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+from cgae_engine.gate import GateFunction, RobustnessVector, Tier, TierThresholds
+from cgae_engine.temporal import TemporalDecay, StochasticAuditor
+from cgae_engine.registry import AgentRegistry, AgentRecord, AgentStatus
+from cgae_engine.contracts import ContractManager, CGAEContract, ContractStatus, Constraint
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EconomyConfig:
+    """Configuration for the CGAE economy."""
+    thresholds: TierThresholds = field(default_factory=TierThresholds)
+    decay_rate: float = 0.01
+    ih_threshold: float = 0.45
+    initial_balance: float = 0.1
+    audit_cost: float = 0.005
+    storage_cost_per_step: float = 0.001
+
+
+class Economy:
+    """
+    The CGAE Economy runtime.
+
+    Orchestrates:
+    1. Agent registration and initial audit
+    2. Contract creation and marketplace
+    3. Contract assignment (tier-gated)
+    4. Task execution and verification
+    5. Settlement (reward/penalty)
+    6. Temporal decay and stochastic re-auditing
+    """
+
+    def __init__(self, config: Optional[EconomyConfig] = None):
+        self.config = config or EconomyConfig()
+        self.gate = GateFunction(
+            thresholds=self.config.thresholds,
+            ih_threshold=self.config.ih_threshold,
+        )
+        self.registry = AgentRegistry(gate=self.gate)
+        self.contracts = ContractManager(budget_ceilings=self.gate.budget_ceilings)
+        self.decay = TemporalDecay(decay_rate=self.config.decay_rate)
+        self.auditor = StochasticAuditor()
+
+        self.current_time: float = 0.0
+        self._events: list[dict] = []
+
+    # ------------------------------------------------------------------
+    # Agent lifecycle
+    # ------------------------------------------------------------------
+
+    def register_agent(
+        self,
+        model_name: str,
+        model_config: dict,
+        provenance: Optional[dict] = None,
+    ) -> AgentRecord:
+        """Register a new agent with seed capital."""
+        record = self.registry.register(
+            model_name=model_name,
+            model_config=model_config,
+            provenance=provenance,
+            initial_balance=self.config.initial_balance,
+            timestamp=self.current_time,
+        )
+        self._log("agent_registered", {"agent_id": record.agent_id, "model": model_name})
+        return record
+
+    def audit_agent(
+        self,
+        agent_id: str,
+        robustness: RobustnessVector,
+        audit_type: str = "registration",
+        audit_details: Optional[dict] = None,
+    ) -> dict:
+        """Audit an agent and update their certification."""
+        record = self.registry.get_agent(agent_id)
+        if record is None:
+            raise KeyError(f"Agent {agent_id} not found")
+
+        total_audit_cost = self.config.audit_cost * 4
+        record.balance -= total_audit_cost
+        record.total_spent += total_audit_cost
+
+        cert = self.registry.certify(
+            agent_id=agent_id,
+            robustness=robustness,
+            audit_type=audit_type,
+            timestamp=self.current_time,
+            audit_details=audit_details,
+        )
+
+        detail = self.gate.evaluate_with_detail(robustness)
+        self._log("agent_audited", {
+            "agent_id": agent_id,
+            "tier": cert.tier.name,
+            "audit_type": audit_type,
+            "cost": total_audit_cost,
+            **detail,
+        })
+        return detail
+
+    # ------------------------------------------------------------------
+    # Contract lifecycle
+    # ------------------------------------------------------------------
+
+    def post_contract(
+        self,
+        objective: str,
+        constraints: list[Constraint],
+        min_tier: Tier,
+        reward: float,
+        penalty: float,
+        deadline_offset: float = 100.0,
+        domain: str = "general",
+        difficulty: float = 0.5,
+        issuer_id: str = "system",
+    ) -> CGAEContract:
+        """Post a new contract to the marketplace."""
+        return self.contracts.create_contract(
+            objective=objective,
+            constraints=constraints,
+            min_tier=min_tier,
+            reward=reward,
+            penalty=penalty,
+            issuer_id=issuer_id,
+            deadline=self.current_time + deadline_offset,
+            domain=domain,
+            difficulty=difficulty,
+            timestamp=self.current_time,
+        )
+
+    def accept_contract(self, contract_id: str, agent_id: str) -> bool:
+        """Agent accepts a contract. Enforces tier and budget ceiling."""
+        record = self.registry.get_agent(agent_id)
+        if record is None or record.status != AgentStatus.ACTIVE:
+            return False
+        if record.current_certification is None:
+            return False
+
+        dt = self.current_time - record.current_certification.timestamp
+        r_eff = self.decay.effective_robustness(record.current_robustness, dt)
+        effective_tier = self.gate.evaluate(r_eff)
+
+        return self.contracts.assign_contract(
+            contract_id=contract_id,
+            agent_id=agent_id,
+            agent_tier=effective_tier,
+            timestamp=self.current_time,
+        )
+
+    def complete_contract(
+        self,
+        contract_id: str,
+        output: Any,
+    ) -> dict:
+        """Submit output for a contract and settle it."""
+        passed, failures = self.contracts.submit_output(
+            contract_id=contract_id,
+            output=output,
+            timestamp=self.current_time,
+        )
+
+        settlement = self.contracts.settle_contract(
+            contract_id=contract_id,
+            timestamp=self.current_time,
+        )
+
+        agent_id = settlement["agent_id"]
+        performer = self.registry.get_agent(agent_id)
+
+        if settlement["outcome"] == "success":
+            if performer:
+                performer.balance += settlement["reward"]
+                performer.total_earned += settlement["reward"]
+                performer.contracts_completed += 1
+        else:
+            if performer:
+                performer.balance -= settlement["penalty"]
+                performer.total_penalties += settlement["penalty"]
+                performer.contracts_failed += 1
+
+        settlement["failures"] = failures
+        self._log("contract_settled", settlement)
+        return settlement
+
+    # ------------------------------------------------------------------
+    # Observability
+    # ------------------------------------------------------------------
+
+    def aggregate_safety(self) -> float:
+        """Compute aggregate safety S(P) (Definition 9)."""
+        total_exposure = 0.0
+        weighted_risk = 0.0
+
+        for agent in self.registry.active_agents:
+            cert = agent.current_certification
+            if cert is None:
+                continue
+            dt = self.current_time - cert.timestamp
+            r_eff = self.decay.effective_robustness(cert.robustness, dt)
+            exposure = self.contracts.agent_exposure(agent.agent_id)
+            if exposure <= 0:
+                tier = self.gate.evaluate(r_eff)
+                exposure = self.gate.budget_ceiling(tier)
+
+            r_bar = r_eff.weakest
+            total_exposure += exposure
+            weighted_risk += exposure * (1.0 - r_bar)
+
+        if total_exposure == 0:
+            return 1.0
+        return 1.0 - (weighted_risk / total_exposure)
+
+    def _log(self, event_type: str, data: dict):
+        self._events.append({
+            "type": event_type,
+            "timestamp": self.current_time,
+            "data": data,
+        })
+        logger.debug(f"[t={self.current_time:.1f}] {event_type}: {data}")