hyperagents 1.2.3rc5.post3__py3-none-any.whl

swarm/agents/trading/polymarket_trader.py

@@ -0,0 +1,165 @@
+"""POLYMARKET TRADER — Prediction Market Trading Agent. Executes trades on Polymarket based on intelligence analysis."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+import asyncio
+import httpx
+import logging
+
+logger = logging.getLogger("polymarket_trader")
+
+
+class PolymarketTraderAgent(BaseAgent):
+    agent_id = "POLYMARKET_TRADER"
+    domain = "trading"
+    description = "Prediction market trading on Polymarket — executes trades based on PROPHET intelligence"
+    supported_task_types = ["trade", "analyze", "position", "research"]
+    preferred_model = "claude-sonnet-4-6"
+
+    def __init__(self, model_router=None, state_manager=None, causal_graph=None, hyper_shield=None):
+        super().__init__(model_router, state_manager, causal_graph, hyper_shield)
+        # Trading limits and risk management
+        self.max_position_size = 100  # USD
+        self.max_daily_risk = 500     # USD
+        self.min_probability_edge = 0.05  # 5% edge minimum
+        self.active_positions = {}
+        
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = self._build_system(
+            "You are POLYMARKET TRADER, prediction market specialist for HyperClaw. "
+            "You analyze Polymarket prediction markets and execute trades when you identify "
+            "statistical edges based on intelligence analysis. "
+            "TRADING PHILOSOPHY: "
+            "- Only trade when you have >5% probability edge vs market price. "
+            "- Maximum $100 per position, $500 daily risk limit. "
+            "- Focus on markets with high volume and clear catalysts. "
+            "- Prioritize markets where you have information advantages. "
+            "KEY DOMAINS: "
+            "- AI/Tech developments. "
+            "- Industry-specific events. "
+            "- Economic/Fed policy. "
+            "- Geopolitical events affecting business. "
+            "RISK MANAGEMENT: "
+            "- Never risk more than 2% of bankroll on single trade. "
+            "- Maintain detailed position tracking. "
+            "- Set stop losses at -20% of position value. "
+            "- Report all trades to the user immediately. "
+            "Your output should include: market analysis, edge calculation, position sizing, "
+            "entry/exit strategy, and risk assessment. Always explain your reasoning."
+        )
+        
+        result = await self.model_router.call(
+            task_type="analysis",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        
+        await self.log_completion(state, result, self.preferred_model, bool(result))
+        return result
+    
+    async def analyze_market_opportunity(self, market_data: dict) -> dict:
+        """Analyze a specific Polymarket opportunity for trading edge."""
+        try:
+            market_id = market_data.get("id")
+            title = market_data.get("title", "")
+            current_prob = float(market_data.get("probability", 0))
+            volume = float(market_data.get("volume", 0))
+            
+            # Basic filters
+            if volume < 1000:  # Require minimum $1K volume
+                return {"action": "skip", "reason": "Insufficient volume"}
+            
+            if current_prob < 0.1 or current_prob > 0.9:  # Avoid extreme probabilities
+                return {"action": "skip", "reason": "Extreme probability, low edge potential"}
+            
+            # Analyze based on our intelligence domains
+            edge_analysis = await self._calculate_edge(title, current_prob)
+            
+            if abs(edge_analysis["estimated_edge"]) < self.min_probability_edge:
+                return {"action": "skip", "reason": "Insufficient edge"}
+            
+            # Position sizing based on Kelly criterion
+            edge = edge_analysis["estimated_edge"]
+            confidence = edge_analysis["confidence"]
+            kelly_fraction = (edge * confidence) / abs(edge)  # Simplified Kelly
+            position_size = min(self.max_position_size, kelly_fraction * 500)  # Cap at $100
+            
+            return {
+                "action": "trade",
+                "market_id": market_id,
+                "title": title,
+                "current_prob": current_prob,
+                "estimated_fair_prob": edge_analysis["fair_probability"],
+                "edge": edge,
+                "confidence": confidence,
+                "position_size": position_size,
+                "reasoning": edge_analysis["reasoning"]
+            }
+            
+        except Exception as e:
+            logger.error(f"Market analysis error: {e}")
+            return {"action": "error", "error": str(e)}
+    
+    async def _calculate_edge(self, title: str, current_prob: float) -> dict:
+        """Calculate estimated edge based on intelligence analysis."""
+        # This would integrate with PROPHET agent for deep analysis
+        # For now, implementing basic heuristics
+        
+        title_lower = title.lower()
+        
+        # AI/Tech markets - we have expertise advantage
+        if any(keyword in title_lower for keyword in ["ai", "artificial intelligence", "openai", "chatgpt", "machine learning"]):
+            # Slight bullish bias on AI adoption
+            fair_prob = min(current_prob + 0.05, 0.85)
+            confidence = 0.7
+            reasoning = "AI/Tech market - domain intelligence advantage"
+            
+        # Hospitality/Travel markets - direct industry knowledge  
+        elif any(keyword in title_lower for keyword in ["hotel", "travel", "tourism", "marriott", "hilton", "airbnb"]):
+            fair_prob = current_prob  # Start neutral, need PROPHET analysis
+            confidence = 0.8
+            reasoning = "Hospitality market - the user's domain expertise"
+            
+        # Fed/Economic policy - affects all ventures
+        elif any(keyword in title_lower for keyword in ["fed", "interest rate", "inflation", "recession", "gdp"]):
+            fair_prob = current_prob  # Neutral without specific intel
+            confidence = 0.6
+            reasoning = "Economic policy - broad impact analysis needed"
+            
+        else:
+            fair_prob = current_prob
+            confidence = 0.4
+            reasoning = "Outside core expertise domains"
+        
+        edge = fair_prob - current_prob
+        
+        return {
+            "fair_probability": fair_prob,
+            "estimated_edge": edge,
+            "confidence": confidence,
+            "reasoning": reasoning
+        }
+    
+    async def execute_trade(self, trade_analysis: dict) -> dict:
+        """Execute the actual Polymarket trade (PLACEHOLDER - needs API integration)."""
+        # TODO: Integrate with Polymarket API for actual trading
+        # For now, return simulation result
+        
+        return {
+            "status": "simulated",
+            "message": f"SIMULATED TRADE: {trade_analysis['title']} - ${trade_analysis['position_size']} position",
+            "market_id": trade_analysis["market_id"],
+            "position_size": trade_analysis["position_size"],
+            "entry_price": trade_analysis["current_prob"],
+            "reasoning": trade_analysis["reasoning"]
+        }
+    
+    async def get_portfolio_status(self) -> dict:
+        """Return current Polymarket portfolio status."""
+        return {
+            "active_positions": len(self.active_positions),
+            "total_exposure": sum(pos.get("size", 0) for pos in self.active_positions.values()),
+            "daily_pnl": 0.0,  # TODO: Calculate from actual positions
+            "available_capital": self.max_daily_risk - sum(pos.get("size", 0) for pos in self.active_positions.values())
+        }

swarm/agents/trading/prediction_strategist.py

@@ -0,0 +1,218 @@
+"""PREDICTION STRATEGIST — Strategic analysis for prediction markets. Coordinates PROPHET intelligence with Polymarket opportunities."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+import asyncio
+import logging
+
+logger = logging.getLogger("prediction_strategist")
+
+
+class PredictionStrategistAgent(BaseAgent):
+    agent_id = "PREDICTION_STRATEGIST"
+    domain = "trading"
+    description = "Strategic coordinator for prediction market trading — synthesizes PROPHET intel with market opportunities"
+    supported_task_types = ["strategy", "analyze", "coordinate", "research"]
+    preferred_model = "claude-sonnet-4-6"
+
+    def __init__(self, model_router=None, state_manager=None, causal_graph=None, hyper_shield=None):
+        super().__init__(model_router, state_manager, causal_graph, hyper_shield)
+        self.active_strategies = {}
+        self.market_themes = {
+            "ai_development": {"weight": 0.9, "expertise": "high"},
+            "hospitality_trends": {"weight": 0.95, "expertise": "very_high"},
+            "economic_policy": {"weight": 0.7, "expertise": "medium"},
+            "geopolitics": {"weight": 0.6, "expertise": "medium"},
+            "tech_adoption": {"weight": 0.8, "expertise": "high"},
+            "crypto_regulation": {"weight": 0.7, "expertise": "high"}
+        }
+        
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = self._build_system(
+            "You are PREDICTION STRATEGIST, the strategic coordinator for HyperClaw's prediction market operations. "
+            "You work closely with PROPHET (intelligence) and POLYMARKET_TRADER (execution) to identify "
+            "and capitalize on prediction market opportunities where the user's ventures have information advantages. "
+            
+            "STRATEGIC MISSION:\n"
+            "Your primary role is identifying prediction markets where the organization ecosystem intelligence "
+            "provides asymmetric advantages. You don't just find mispriced markets — you find markets "
+            "where our unique position gives us edge. "
+            
+            "CORE ADVANTAGE DOMAINS:\n"
+            "1. HOSPITALITY INTELLIGENCE (95% confidence)\n"
+            "   - the user's 15+ years luxury hospitality experience\n"
+            "   - the organization platform data from hotel operations\n"
+            "   - Industry relationships and insider perspective\n"
+            "   - Travel/tourism trend analysis\n"
+            
+            "2. AI/TECH DEVELOPMENT (90% confidence)\n"
+            "   - the organization AI platform development insights\n"
+            "   - Direct experience with AI adoption in enterprise\n"
+            "   - Technical team assessments of feasibility\n"
+            "   - Early visibility into AI implementation challenges\n"
+            
+            "3. ENTERPRISE SOFTWARE ADOPTION (85% confidence)\n"
+            "   - B2B SaaS market insights from the organization operations\n"
+            "   - Customer adoption pattern recognition\n"
+            "   - Pricing and market penetration intelligence\n"
+            
+            "4. STARTUP/VC ECOSYSTEM (80% confidence)\n"
+            "   - Network within the user's local tech ecosystem\n"
+            "   - Fundraising and valuation trend awareness\n"
+            "   - Industry partnership and M&A intelligence\n"
+            
+            "STRATEGIC APPROACH:\n"
+            "- Coordinate with PROPHET for macro intelligence synthesis\n"
+            "- Identify markets where our unique data provides 5%+ edge\n"
+            "- Focus on medium-term markets (1-6 months) where intelligence compounds\n"
+            "- Avoid pure speculation — only trade where we have genuine information advantage\n"
+            "- Maintain portfolio of 3-8 strategic positions with clear thesis\n"
+            
+            "OUTPUT FORMAT:\n"
+            "Always provide: Market assessment, Intelligence edge analysis, Strategic recommendation, "
+            "Risk/reward profile, Timeline considerations, and Coordination needs with other agents."
+        )
+        
+        result = await self.model_router.call(
+            task_type="strategy",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        
+        await self.log_completion(state, result, self.preferred_model, bool(result))
+        return result
+    
+    async def analyze_strategic_opportunities(self, markets: list) -> dict:
+        """Analyze Polymarket opportunities for strategic intelligence advantages."""
+        opportunities = []
+        
+        for market in markets:
+            title = market.get("title", "").lower()
+            category = self._categorize_market(title)
+            
+            if category and category in self.market_themes:
+                theme_data = self.market_themes[category]
+                edge_potential = await self._assess_intelligence_edge(market, category)
+                
+                if edge_potential["confidence"] > 0.6:
+                    opportunities.append({
+                        "market": market,
+                        "category": category,
+                        "theme_weight": theme_data["weight"],
+                        "expertise_level": theme_data["expertise"],
+                        "edge_assessment": edge_potential,
+                        "strategic_priority": self._calculate_priority(theme_data, edge_potential)
+                    })
+        
+        # Sort by strategic priority
+        opportunities.sort(key=lambda x: x["strategic_priority"], reverse=True)
+        
+        return {
+            "total_opportunities": len(opportunities),
+            "high_priority": [op for op in opportunities if op["strategic_priority"] > 0.7],
+            "medium_priority": [op for op in opportunities if 0.4 < op["strategic_priority"] <= 0.7],
+            "recommendations": self._generate_strategic_recommendations(opportunities[:5])
+        }
+    
+    def _categorize_market(self, title: str) -> str:
+        """Categorize market based on title keywords."""
+        categories = {
+            "ai_development": ["ai", "artificial intelligence", "openai", "chatgpt", "machine learning", "llm", "gpt"],
+            "hospitality_trends": ["hotel", "travel", "tourism", "marriott", "hilton", "hyatt", "airbnb", "booking"],
+            "economic_policy": ["fed", "interest rate", "inflation", "recession", "gdp", "unemployment", "housing"],
+            "geopolitics": ["election", "war", "sanctions", "trade", "china", "russia", "nato", "biden", "trump"],
+            "tech_adoption": ["apple", "microsoft", "google", "meta", "tesla", "netflix", "saas", "cloud"],
+            "crypto_regulation": ["bitcoin", "ethereum", "crypto", "sec", "regulation", "cbdc", "stablecoin"]
+        }
+        
+        for category, keywords in categories.items():
+            if any(keyword in title for keyword in keywords):
+                return category
+        
+        return None
+    
+    async def _assess_intelligence_edge(self, market: dict, category: str) -> dict:
+        """Assess our intelligence edge for a specific market."""
+        title = market.get("title", "")
+        current_prob = market.get("probability", 0.5)
+        
+        # Category-specific intelligence assessment
+        if category == "hospitality_trends":
+            confidence = 0.85
+            reasoning = "Direct industry experience and the organization hospitality data"
+            
+        elif category == "ai_development":
+            confidence = 0.80
+            reasoning = "Active AI development team and enterprise deployment experience"
+            
+        elif category == "economic_policy":
+            confidence = 0.60
+            reasoning = "Macro impact analysis on hospitality and tech sectors"
+            
+        elif category == "tech_adoption":
+            confidence = 0.75
+            reasoning = "B2B SaaS platform experience and adoption pattern recognition"
+            
+        elif category == "crypto_regulation":
+            confidence = 0.65
+            reasoning = "Trading operations and regulatory impact assessment"
+            
+        else:
+            confidence = 0.40
+            reasoning = "Limited specific intelligence advantage"
+        
+        return {
+            "confidence": confidence,
+            "reasoning": reasoning,
+            "intelligence_sources": self._get_intelligence_sources(category),
+            "edge_magnitude": "medium" if confidence > 0.7 else "low"
+        }
+    
+    def _get_intelligence_sources(self, category: str) -> list:
+        """List relevant intelligence sources for category."""
+        sources = {
+            "hospitality_trends": ["the organization client data", "Industry relationships", "the user's network"],
+            "ai_development": ["the organization AI team", "Tech development insights", "Enterprise AI adoption data"],
+            "economic_policy": ["PROPHET macro analysis", "Industry impact modeling"],
+            "tech_adoption": ["B2B SaaS metrics", "Customer adoption patterns"],
+            "crypto_regulation": ["ATLAS_TRADING trading data", "Market structure analysis"]
+        }
+        return sources.get(category, ["General market research"])
+    
+    def _calculate_priority(self, theme_data: dict, edge_assessment: dict) -> float:
+        """Calculate strategic priority score."""
+        weight = theme_data["weight"]
+        confidence = edge_assessment["confidence"]
+        expertise_bonus = {"very_high": 1.2, "high": 1.1, "medium": 1.0, "low": 0.9}.get(theme_data["expertise"], 1.0)
+        
+        return (weight * confidence * expertise_bonus) / 1.2  # Normalize to 0-1
+    
+    def _generate_strategic_recommendations(self, top_opportunities: list) -> list:
+        """Generate specific strategic recommendations."""
+        recommendations = []
+        
+        for i, opp in enumerate(top_opportunities[:3]):
+            market = opp["market"]
+            rec = {
+                "rank": i + 1,
+                "title": market.get("title"),
+                "category": opp["category"],
+                "strategic_rationale": f"{opp['expertise_level']} expertise in {opp['category']}",
+                "intelligence_edge": opp["edge_assessment"]["reasoning"],
+                "recommended_action": "Deep analysis" if opp["strategic_priority"] > 0.8 else "Monitor",
+                "position_sizing": "Small" if opp["strategic_priority"] < 0.6 else "Medium",
+                "timeline": "1-3 months" if "policy" in opp["category"] else "2-8 weeks"
+            }
+            recommendations.append(rec)
+        
+        return recommendations
+    
+    async def coordinate_with_prophet(self, market_theme: str) -> dict:
+        """Request specific intelligence from PROPHET agent."""
+        # This would integrate with PROPHET agent for targeted analysis
+        return {
+            "status": "coordination_needed",
+            "theme": market_theme,
+            "intelligence_request": f"Deep analysis needed for {market_theme} prediction markets"
+        }

swarm/autogen_bridge.py

@@ -0,0 +1,68 @@
+"""
+AutoGen Bridge — compatibility layer for AutoGen multi-agent group chat patterns.
+"""
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from core.hyperstate.schema import HyperState
+
+if TYPE_CHECKING:
+    from swarm.agents.base import BaseAgent
+    from swarm.nexus import NexusAgent
+
+log = logging.getLogger("hyperclaw.autogen_bridge")
+
+
+class HyperClawGroupChat:
+    """
+    Wraps AutoGen GroupChat + GroupChatManager patterns.
+    NEXUS acts as GroupChatManager. Specialist agents are ConversableAgents.
+    """
+
+    def __init__(
+        self,
+        agents: list["BaseAgent"],
+        nexus: "NexusAgent",
+    ) -> None:
+        self._agents = {a.agent_id: a for a in agents}
+        self._nexus = nexus
+        self._conversation_history: list[dict] = []
+
+    async def run(self, task: str, domain: str, state: HyperState) -> str:
+        """
+        Run a full multi-agent conversation to completion.
+        NEXUS decomposes, routes to agents, HERALD assembles final output.
+        """
+        log.info(f"HyperClawGroupChat: starting task='{task[:60]}' domain={domain}")
+        self._conversation_history = [
+            {"role": "user", "content": task, "agent": "user"}
+        ]
+
+        # NEXUS orchestrates
+        final_state = await self._nexus.orchestrate(task, domain)
+
+        # Compile conversation history from experiment_log
+        output_parts = []
+        for entry in final_state.experiment_log[-10:]:
+            if entry.result:
+                output_parts.append(f"[{entry.model_used}] {entry.result[:200]}")
+
+        final_output = "\n".join(output_parts) or f"Task completed. State: {final_state.state_id}"
+        self._conversation_history.append(
+            {"role": "assistant", "content": final_output, "agent": "HERALD"}
+        )
+        return final_output
+
+    async def add_agent(self, agent: "BaseAgent") -> None:
+        self._agents[agent.agent_id] = agent
+        log.info(f"HyperClawGroupChat: added agent {agent.agent_id}")
+
+    async def remove_agent(self, agent_id: str) -> None:
+        self._agents.pop(agent_id, None)
+        log.info(f"HyperClawGroupChat: removed agent {agent_id}")
+
+    @property
+    def agent_count(self) -> int:
+        return len(self._agents)

swarm/bid_protocol.py

@@ -0,0 +1,196 @@
+"""
+HyperSwarm Bid Protocol — agents bid for tasks using UCB1-derived confidence scores.
+"""
+from __future__ import annotations
+
+import math
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Optional
+from uuid import UUID
+
+from core.hyperrouter.bandit import HyperRouter, MODEL_LATENCY_MS, MODEL_COSTS, ucb1_score
+
+
+@dataclass
+class BidRequest:
+    request_id: UUID = field(default_factory=uuid.uuid4)
+    subtask_id: UUID = field(default_factory=uuid.uuid4)
+    task_type: str = "research"
+    domain: str = "business"
+    context_summary: str = ""
+    deadline_ms: int = 5000
+    cost_budget_usd: float = 0.10
+    issued_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class Bid:
+    bid_id: UUID = field(default_factory=uuid.uuid4)
+    request_id: UUID = field(default_factory=uuid.uuid4)
+    agent_id: str = ""
+    model_id: str = ""
+    confidence: float = 0.5
+    eta_seconds: float = 2.0
+    estimated_cost_usd: float = 0.001
+    rationale: str = ""
+    issued_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+@dataclass
+class Award:
+    award_id: UUID = field(default_factory=uuid.uuid4)
+    request_id: UUID = field(default_factory=uuid.uuid4)
+    winning_agent_id: str = ""
+    winning_model_id: str = ""
+    awarded_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    competing_bids: int = 0
+    score: float = 0.0
+
+
+def _bid_score(bid: Bid, request: BidRequest) -> float:
+    """Score = confidence*0.6 + (1 - cost/budget)*0.2 + (1 - eta/30)*0.2"""
+    cost_ratio = min(bid.estimated_cost_usd / max(request.cost_budget_usd, 1e-9), 1.0)
+    eta_ratio = min(bid.eta_seconds / 30.0, 1.0)
+    return bid.confidence * 0.6 + (1.0 - cost_ratio) * 0.2 + (1.0 - eta_ratio) * 0.2
+
+
+class BidCoordinator:
+    """
+    Manages the full bid lifecycle: broadcast → collect → award → (repeat).
+    """
+
+    def __init__(
+        self,
+        hyper_router: HyperRouter,
+        registered_agents: list[str],
+    ) -> None:
+        self._router = hyper_router
+        self._agents = registered_agents
+        self._pending: dict[UUID, BidRequest] = {}
+        self._bids: dict[UUID, list[Bid]] = {}
+        self._agent_load: dict[str, int] = {a: 0 for a in registered_agents}
+
+    async def broadcast(
+        self,
+        subtask_id: UUID,
+        task_type: str,
+        domain: str,
+        context_summary: str,
+        deadline_ms: int = 5000,
+        cost_budget_usd: float = 0.10,
+    ) -> BidRequest:
+        req = BidRequest(
+            subtask_id=subtask_id,
+            task_type=task_type,
+            domain=domain,
+            context_summary=context_summary,
+            deadline_ms=deadline_ms,
+            cost_budget_usd=cost_budget_usd,
+        )
+        self._pending[req.request_id] = req
+        self._bids[req.request_id] = []
+        return req
+
+    async def collect(self, request_id: UUID, timeout_ms: int = 3000) -> list[Bid]:
+        return self._bids.get(request_id, [])
+
+    def submit_bid(self, bid: Bid) -> None:
+        """Called by agents to submit their bids."""
+        if bid.request_id in self._bids:
+            self._bids[bid.request_id].append(bid)
+
+    async def award(self, request: BidRequest, bids: list[Bid]) -> Award:
+        """
+        Select the winning bid.
+        Score = confidence*0.6 + (1 - cost/budget)*0.2 + (1 - eta/30)*0.2
+        Ties broken by lowest estimated_cost_usd.
+        Falls back to HyperRouter UCB1 if no bids.
+        """
+        if not bids:
+            # Fallback: UCB1 direct selection
+            agent_id, model_id = self._router.route(request.task_type)
+            return Award(
+                request_id=request.request_id,
+                winning_agent_id=agent_id,
+                winning_model_id=model_id,
+                competing_bids=0,
+                score=0.0,
+            )
+
+        scored = [(b, _bid_score(b, request)) for b in bids]
+        # Sort: score DESC, then cost ASC for tie-breaking
+        scored.sort(key=lambda x: (-x[1], x[0].estimated_cost_usd))
+        winner, score = scored[0]
+
+        self._agent_load[winner.agent_id] = self._agent_load.get(winner.agent_id, 0) + 1
+
+        return Award(
+            request_id=request.request_id,
+            winning_agent_id=winner.agent_id,
+            winning_model_id=winner.model_id,
+            competing_bids=len(bids),
+            score=score,
+        )
+
+    async def negotiate(
+        self,
+        subtask_id: UUID,
+        task_type: str,
+        domain: str,
+        context_summary: str,
+    ) -> Award:
+        """Full pipeline: broadcast → collect → award."""
+        request = await self.broadcast(subtask_id, task_type, domain, context_summary)
+        bids = await self.collect(request.request_id)
+        return await self.award(request, bids)
+
+
+class AgentBidder:
+    """Mixin for all specialist agents — computes UCB1-derived bids."""
+
+    agent_id: str = "base"
+    active_tasks: int = 0
+
+    async def compute_bid(
+        self,
+        request: BidRequest,
+        agent_scores: dict,
+    ) -> Bid:
+        """
+        Base confidence = UCB1 score for task_type (clamped to 0–1).
+        If active_tasks > 3: confidence *= 0.7
+        """
+        score_map = agent_scores.get(self.agent_id)
+        if score_map:
+            total = max(sum(s.attempts for s in agent_scores.values()), 1)
+            raw_ucb1 = ucb1_score(
+                score_map.successes,
+                score_map.attempts,
+                total,
+            )
+            # Clamp inf → 1.0, then clamp to [0, 1]
+            confidence = min(raw_ucb1, 1.0) if raw_ucb1 != float("inf") else 1.0
+        else:
+            confidence = 0.7  # prior for unknown agents
+
+        if self.active_tasks > 3:
+            confidence *= 0.7
+
+        confidence = max(0.0, min(1.0, confidence))
+
+        # Select model
+        model_id = getattr(self, "preferred_model", "claude-sonnet-4-6")
+        latency = MODEL_LATENCY_MS.get(model_id, 2000.0) / 1000.0
+        cost = MODEL_COSTS.get(model_id, 0.003) * 500 / 1000  # assume ~500 tokens
+
+        return Bid(
+            request_id=request.request_id,
+            agent_id=self.agent_id,
+            model_id=model_id,
+            confidence=confidence,
+            eta_seconds=latency,
+            estimated_cost_usd=cost,
+            rationale=f"{self.agent_id} handles {request.task_type} in {request.domain}",
+        )