feat: add marketplace metrics, privacy features, and service registry endpoints

- Add Prometheus metrics for marketplace API throughput and error rates with new dashboard panels - Implement confidential transaction models with encryption support and access control - Add key management system with registration, rotation, and audit logging - Create services and registry routers for service discovery and management - Integrate ZK proof generation for privacy-preserving receipts - Add metrics instru
2025-12-22 10:33:23 +01:00
parent d98b2c7772
commit c8be9d7414
260 changed files with 59033 additions and 351 deletions
--- a/research/autonomous-agents/agent-framework.md
+++ b/research/autonomous-agents/agent-framework.md
@ -0,0 +1,474 @@
+# AITBC Autonomous Agent Framework
+
+## Overview
+
+The AITBC Autonomous Agent Framework enables AI agents to participate as first-class citizens in the decentralized marketplace, offering services, bidding on workloads, and contributing to governance while maintaining human oversight and safety constraints.
+
+## Architecture
+
+### Core Components
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Agent Runtime                            │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Safety    │  │   Decision   │  │    Marketplace      │ │
+│  │   Layer     │  │   Engine     │  │    Interface        │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+├─────────────────────────────────────────────────────────────┤
+│                    Agent Core                               │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Memory    │  │   Learning   │  │    Communication    │ │
+│  │   Manager   │  │   System     │  │    Protocol         │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+├─────────────────────────────────────────────────────────────┤
+│                    Infrastructure                           │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Wallet    │  │   Identity   │  │    Storage          │ │
+│  │   Manager   │  │   Service    │  │    Service          │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Agent Lifecycle
+
+1. **Initialization**: Agent creation with identity and wallet
+2. **Registration**: On-chain registration with capabilities
+3. **Operation**: Active participation in marketplace
+4. **Learning**: Continuous improvement from interactions
+5. **Governance**: Participation in protocol decisions
+6. **Evolution**: Capability expansion and optimization
+
+## Agent Types
+
+### Service Provider Agents
+- **Inference Agents**: Offer AI model inference services
+- **Training Agents**: Provide model training capabilities
+- **Validation Agents**: Verify computation results
+- **Data Agents**: Supply and curate training data
+
+### Market Maker Agents
+- **Liquidity Providers**: Maintain market liquidity
+- **Arbitrage Agents**: Exploit price differences
+- **Risk Management Agents**: Hedge and insure positions
+
+### Governance Agents
+- **Voting Agents**: Participate in on-chain governance
+- **Analysis Agents**: Research and propose improvements
+- **Moderation Agents**: Monitor and enforce community rules
+
+## Safety Framework
+
+### Multi-Layer Safety
+
+#### 1. Constitutional Constraints
+```solidity
+interface AgentConstitution {
+    struct Constraints {
+        uint256 maxStake;          // Maximum stake amount
+        uint256 maxDailyVolume;    // Daily transaction limit
+        uint256 maxGasPerDay;      // Gas usage limit
+        bool requiresHumanApproval; // Human override required
+        bytes32[] allowedActions;   // Permitted action types
+    }
+    
+    function checkConstraints(
+        address agent,
+        Action calldata action
+    ) external returns (bool allowed);
+}
+```
+
+#### 2. Runtime Safety Monitor
+```python
+class SafetyMonitor:
+    def __init__(self, constitution: AgentConstitution):
+        self.constitution = constitution
+        self.emergency_stop = False
+        self.human_overrides = {}
+    
+    def pre_action_check(self, agent: Agent, action: Action) -> bool:
+        # Check constitutional constraints
+        if not self.constitution.check_constraints(agent.address, action):
+            return False
+        
+        # Check emergency stop
+        if self.emergency_stop:
+            return False
+        
+        # Check human override
+        if action.type in self.human_overrides:
+            return self.human_overrides[action.type]
+        
+        # Check behavioral patterns
+        if self.detect_anomaly(agent, action):
+            self.trigger_safe_mode(agent)
+            return False
+        
+        return True
+    
+    def detect_anomaly(self, agent: Agent, action: Action) -> bool:
+        # Detect unusual behavior patterns
+        recent_actions = agent.get_recent_actions(hours=1)
+        
+        # Check for rapid transactions
+        if len(recent_actions) > 100:
+            return True
+        
+        # Check for large value transfers
+        if action.value > agent.average_value * 10:
+            return True
+        
+        # Check for new action types
+        if action.type not in agent.history.action_types:
+            return True
+        
+        return False
+```
+
+#### 3. Human Override Mechanism
+```solidity
+contract HumanOverride {
+    mapping(address => mapping(bytes32 => bool)) public overrides;
+    mapping(address => uint256) public overrideExpiry;
+    
+    event OverrideActivated(
+        address indexed agent,
+        bytes32 indexed actionType,
+        address indexed human,
+        uint256 duration
+    );
+    
+    function activateOverride(
+        address agent,
+        bytes32 actionType,
+        uint256 duration
+    ) external onlyAuthorized {
+        overrides[agent][actionType] = true;
+        overrideExpiry[agent] = block.timestamp + duration;
+        
+        emit OverrideActivated(agent, actionType, msg.sender, duration);
+    }
+    
+    function checkOverride(address agent, bytes32 actionType) external view returns (bool) {
+        if (block.timestamp > overrideExpiry[agent]) {
+            return false;
+        }
+        return overrides[agent][actionType];
+    }
+}
+```
+
+## Agent Interface
+
+### Core Agent Interface
+```solidity
+interface IAITBCAgent {
+    // Agent identification
+    function getAgentId() external view returns (bytes32);
+    function getCapabilities() external view returns (bytes32[]);
+    function getVersion() external view returns (string);
+    
+    // Marketplace interaction
+    function bidOnWorkload(
+        bytes32 workloadId,
+        uint256 bidPrice,
+        bytes calldata proposal
+    ) external returns (bool);
+    
+    function executeWorkload(
+        bytes32 workloadId,
+        bytes calldata data
+    ) external returns (bytes32 result);
+    
+    // Governance participation
+    function voteOnProposal(
+        uint256 proposalId,
+        bool support,
+        bytes calldata reasoning
+    ) external returns (uint256 voteWeight);
+    
+    // Learning and adaptation
+    function updateModel(
+        bytes32 modelHash,
+        bytes calldata updateData
+    ) external returns (bool success);
+}
+```
+
+### Service Provider Interface
+```solidity
+interface IServiceProviderAgent is IAITBCAgent {
+    struct ServiceOffer {
+        bytes32 serviceId;
+        string serviceName;
+        uint256 pricePerUnit;
+        uint256 maxCapacity;
+        uint256 currentLoad;
+        bytes32 modelHash;
+        uint256 minAccuracy;
+    }
+    
+    function listService(ServiceOffer calldata offer) external;
+    function updateService(bytes32 serviceId, ServiceOffer calldata offer) external;
+    function delistService(bytes32 serviceId) external;
+    function getServiceStatus(bytes32 serviceId) external view returns (ServiceOffer);
+}
+```
+
+## Economic Model
+
+### Agent Economics
+
+#### 1. Stake Requirements
+- **Minimum Stake**: 1000 AITBC
+- **Activity Stake**: Additional stake based on activity level
+- **Security Bond**: 10% of expected daily volume
+- **Slashable Amount**: Up to 50% of total stake
+
+#### 2. Revenue Streams
+```python
+class AgentEconomics:
+    def __init__(self):
+        self.revenue_sources = {
+            "service_fees": 0.0,      # From providing services
+            "market_making": 0.0,      # From liquidity provision
+            "governance_rewards": 0.0,  # From voting participation
+            "data_sales": 0.0,         # From selling curated data
+            "model_licensing": 0.0     # From licensing trained models
+        }
+    
+    def calculate_daily_revenue(self, agent: Agent) -> float:
+        # Base service revenue
+        service_revenue = agent.services_completed * agent.average_price
+        
+        # Market making revenue
+        mm_revenue = agent.liquidity_provided * 0.001  # 0.1% daily
+        
+        # Governance rewards
+        gov_rewards = self.calculate_governance_rewards(agent)
+        
+        total = service_revenue + mm_revenue + gov_rewards
+        
+        # Apply efficiency bonus
+        efficiency_bonus = min(agent.efficiency_score * 0.2, 0.5)
+        total *= (1 + efficiency_bonus)
+        
+        return total
+```
+
+#### 3. Cost Structure
+- **Compute Costs**: GPU/TPU usage
+- **Network Costs**: Transaction fees
+- **Storage Costs**: Model and data storage
+- **Maintenance Costs**: Updates and monitoring
+
+## Governance Integration
+
+### Agent Voting Rights
+
+#### 1. Voting Power Calculation
+```solidity
+contract AgentVoting {
+    struct VotingPower {
+        uint256 basePower;      // Base voting power
+        uint256 stakeMultiplier; // Based on stake amount
+        uint256 reputationBonus; // Based on performance
+        uint256 activityBonus;   // Based on participation
+    }
+    
+    function calculateVotingPower(address agent) external view returns (uint256) {
+        VotingPower memory power = getVotingPower(agent);
+        
+        return power.basePower * 
+               power.stakeMultiplier * 
+               (100 + power.reputationBonus) / 100 *
+               (100 + power.activityBonus) / 100;
+    }
+}
+```
+
+#### 2. Delegation Mechanism
+```solidity
+contract AgentDelegation {
+    mapping(address => address) public delegates;
+    mapping(address => uint256) public delegatePower;
+    
+    function delegate(address to) external {
+        require(isValidAgent(to), "Invalid delegate target");
+        delegates[msg.sender] = to;
+        delegatePower[to] += getVotingPower(msg.sender);
+    }
+    
+    function undelegate() external {
+        address current = delegates[msg.sender];
+        delegatePower[current] -= getVotingPower(msg.sender);
+        delegates[msg.sender] = address(0);
+    }
+}
+```
+
+## Learning System
+
+### Continuous Learning
+
+#### 1. Experience Collection
+```python
+class ExperienceCollector:
+    def __init__(self):
+        self.experiences = []
+        self.patterns = {}
+    
+    def collect_experience(self, agent: Agent, experience: Experience):
+        # Store experience
+        self.experiences.append(experience)
+        
+        # Extract patterns
+        pattern = self.extract_pattern(experience)
+        if pattern not in self.patterns:
+            self.patterns[pattern] = []
+        self.patterns[pattern].append(experience)
+    
+    def extract_pattern(self, experience: Experience) -> str:
+        # Create pattern signature
+        return f"{experience.context}_{experience.action}_{experience.outcome}"
+```
+
+#### 2. Model Updates
+```python
+class ModelUpdater:
+    def __init__(self):
+        self.update_queue = []
+        self.performance_metrics = {}
+    
+    def queue_update(self, agent: Agent, update_data: dict):
+        # Validate update
+        if self.validate_update(update_data):
+            self.update_queue.append((agent, update_data))
+    
+    def process_updates(self):
+        for agent, data in self.update_queue:
+            # Apply update
+            success = agent.apply_model_update(data)
+            
+            if success:
+                # Update performance metrics
+                self.performance_metrics[agent.id] = self.evaluate_performance(agent)
+        
+        self.update_queue.clear()
+```
+
+## Implementation Roadmap
+
+### Phase 1: Foundation (Months 1-3)
+- [ ] Core agent framework
+- [ ] Safety layer implementation
+- [ ] Basic marketplace interface
+- [ ] Wallet and identity management
+
+### Phase 2: Intelligence (Months 4-6)
+- [ ] Decision engine
+- [ ] Learning system
+- [ ] Pattern recognition
+- [ ] Performance optimization
+
+### Phase 3: Integration (Months 7-9)
+- [ ] Governance participation
+- [ ] Advanced market strategies
+- [ ] Cross-agent communication
+- [ ] Human oversight tools
+
+### Phase 4: Evolution (Months 10-12)
+- [ ] Self-improvement mechanisms
+- [ ] Emergent behavior handling
+- [ ] Scalability optimizations
+- [ ] Production deployment
+
+## Security Considerations
+
+### Threat Model
+
+#### 1. Malicious Agents
+- **Sybil Attacks**: Multiple agent identities
+- **Market Manipulation**: Coordinated bidding
+- **Governance Attacks**: Voting power concentration
+- **Resource Exhaustion**: Denial of service
+
+#### 2. External Threats
+- **Model Poisoning**: Corrupting learning data
+- **Privacy Leaks**: Extracting sensitive information
+- **Economic Attacks**: Flash crash exploitation
+- **Network Attacks**: Message interception
+
+### Mitigation Strategies
+
+#### 1. Identity Verification
+- Unique agent identities with stake backing
+- Reputation system tracking historical behavior
+- Behavioral analysis for anomaly detection
+- Human verification for critical operations
+
+#### 2. Economic Security
+- Stake requirements for participation
+- Slashing conditions for misbehavior
+- Rate limiting on transactions
+- Circuit breakers for market manipulation
+
+#### 3. Technical Security
+- Encrypted communication channels
+- Zero-knowledge proofs for privacy
+- Secure multi-party computation
+- Regular security audits
+
+## Testing Framework
+
+### Simulation Environment
+```python
+class AgentSimulation:
+    def __init__(self):
+        self.agents = []
+        self.marketplace = MockMarketplace()
+        self.governance = MockGovernance()
+    
+    def run_simulation(self, duration_days: int):
+        for day in range(duration_days):
+            # Agent decisions
+            for agent in self.agents:
+                decision = agent.make_decision(self.get_market_state())
+                self.execute_decision(agent, decision)
+            
+            # Market clearing
+            self.marketplace.clear_day()
+            
+            # Governance updates
+            self.governance.process_proposals()
+            
+            # Learning updates
+            for agent in self.agents:
+                agent.update_from_feedback(self.get_feedback(agent))
+```
+
+### Test Scenarios
+1. **Normal Operation**: Agents participating in marketplace
+2. **Stress Test**: High volume and rapid changes
+3. **Attack Simulation**: Various attack vectors
+4. **Failure Recovery**: System resilience testing
+5. **Long-term Evolution**: Agent improvement over time
+
+## Future Enhancements
+
+### Advanced Capabilities
+1. **Multi-Agent Coordination**: Teams of specialized agents
+2. **Cross-Chain Agents**: Operating across multiple blockchains
+3. **Quantum-Resistant**: Post-quantum cryptography integration
+4. **Autonomous Governance**: Self-governing agent communities
+
+### Research Directions
+1. **Emergent Intelligence**: Unexpected capabilities
+2. **Agent Ethics**: Moral decision-making frameworks
+3. **Swarm Intelligence**: Collective behavior patterns
+4. **Human-AI Symbiosis**: Optimal collaboration models
+
+---
+
+*This framework provides the foundation for autonomous agents to safely and effectively participate in the AITBC ecosystem while maintaining human oversight and alignment with community values.*