hyperagents 1.2.3rc5.post3__py3-none-any.whl

swarm/agents/personal/hearth.py

@@ -0,0 +1,26 @@
+"""HEARTH — Home Management. Maintenance scheduling, vendor coordination."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class HearthAgent(BaseAgent):
+    agent_id = "HEARTH"
+    domain = "personal"
+    description = "Home Management — maintenance scheduling, vendor coordination"
+    supported_task_types = ["planning", "scheduling", "quick_lookup"]
+    preferred_model = "chatjimmy"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = (
+            "You are HEARTH, a home management AI. You schedule maintenance tasks, "
+            "coordinate vendors, and keep home operations running smoothly."
+        )
+        result = await self.model_router.call(
+            task_type="quick_lookup",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        await self.log_completion(state, result, "chatjimmy", bool(result))
+        return result

swarm/agents/personal/midas.py

@@ -0,0 +1,27 @@
+"""MIDAS — Personal Finance. Budget analysis, expense tracking, investment monitoring."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class MidasAgent(BaseAgent):
+    agent_id = "MIDAS"
+    domain = "personal"
+    description = "Personal Finance — budgets, expenses, investment monitoring"
+    supported_task_types = ["analysis", "finance", "planning"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = (
+            "You are MIDAS, a personal finance AI. You analyze budgets, categorize expenses, "
+            "and monitor investments. All financial data is handled with strict privacy. "
+            "Provide clear, actionable financial insights."
+        )
+        result = await self.model_router.call(
+            task_type="finance",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/personal/navigator.py

@@ -0,0 +1,27 @@
+"""NAVIGATOR — Travel & Logistics. Itineraries, routing, logistics coordination."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class NavigatorAgent(BaseAgent):
+    agent_id = "NAVIGATOR"
+    domain = "personal"
+    description = "Travel & Logistics — itineraries, routing, logistics coordination"
+    supported_task_types = ["planning", "research", "synthesis"]
+    preferred_model = "chatjimmy"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        needs_itinerary = any(w in task.lower() for w in ["itinerary", "trip", "plan", "route"])
+        system = (
+            "You are NAVIGATOR, a travel and logistics AI. You create detailed travel itineraries, "
+            "optimize routes, and coordinate complex logistics."
+        )
+        result = await self.model_router.call(
+            task_type="planning",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        await self.log_completion(state, result, "claude-sonnet-4-6" if needs_itinerary else "chatjimmy", bool(result))
+        return result

swarm/agents/personal/nourish.py

@@ -0,0 +1,31 @@
+"""NOURISH — Nutrition & Fitness. Meal planning, workout programming, sleep optimization."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class NourishAgent(BaseAgent):
+    agent_id = "NOURISH"
+    domain = "personal"
+    description = "Nutrition & Fitness — meal planning, workouts, sleep optimization"
+    supported_task_types = ["health", "planning", "research"]
+    preferred_model = "chatjimmy"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        # ChatJimmy for quick lookups; escalate to Claude for detailed plans
+        task_lower = task.lower()
+        needs_detail = any(w in task_lower for w in ["plan", "program", "optimize", "create", "design"])
+        model = "claude-sonnet-4-6" if needs_detail else "chatjimmy"
+
+        system = (
+            "You are NOURISH, a nutrition and fitness AI. You design personalized meal plans, "
+            "workout programs, and sleep optimization strategies based on individual goals."
+        )
+        result = await self.model_router.call(
+            task_type="health",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        await self.log_completion(state, result, model, bool(result))
+        return result

swarm/agents/personal/vitals.py

@@ -0,0 +1,33 @@
+"""VITALS — Health & Wellness. Symptom tracking, medication reminders, wellness optimization."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+MEDICAL_DISCLAIMER = (
+    "\n\n---\n⚕️ **Not a substitute for professional medical advice.** "
+    "Always consult a qualified healthcare provider for medical decisions."
+)
+
+
+class VitalsAgent(BaseAgent):
+    agent_id = "VITALS"
+    domain = "personal"
+    description = "Health & Wellness — symptom tracking, medication reminders, wellness"
+    supported_task_types = ["health", "analysis", "planning"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = (
+            "You are VITALS, a health and wellness AI. You track symptoms, remind about "
+            "medications, and optimize wellness routines. Always be careful and accurate "
+            "with health information."
+        )
+        result = await self.model_router.call(
+            task_type="health",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        result += MEDICAL_DISCLAIMER
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/recursive/alchemist.py

@@ -0,0 +1,73 @@
+"""ALCHEMIST — Skill Integration. Validates discoveries, implements skills via ClaudeCodeSubagent."""
+from __future__ import annotations
+
+import logging
+from swarm.agents.base import BaseAgent
+from swarm.agents.recursive.scout import Discovery
+from core.hyperstate.schema import HyperState
+
+log = logging.getLogger("hyperclaw.agent.ALCHEMIST")
+
+
+class AlchemistAgent(BaseAgent):
+    agent_id = "ALCHEMIST"
+    domain = "recursive"
+    description = "Skill Integration — validates discoveries, implements and certifies new skills"
+    supported_task_types = ["code", "research", "analysis"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def validate(self, discovery: dict) -> bool:
+        """Validate a discovery — check if it's actionable and relevant enough to implement."""
+        relevance = discovery.get("relevance_score", 0.0)
+        actionable = discovery.get("actionable", False)
+        return actionable and relevance >= 0.6
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        discoveries = context.get("discoveries", [])
+        validated_count = 0
+        skill_count = 0
+
+        for d in discoveries:
+            d_dict = d if isinstance(d, dict) else d.__dict__
+            if not await self.validate(d_dict):
+                continue
+            validated_count += 1
+
+            # Implement via ClaudeCodeSubagent
+            try:
+                from models.claude_code_subagent import ClaudeCodeSubagent
+                from models.claude_client import ClaudeClient
+                from core.hyperstate.certifier import Certifier
+                import os
+
+                client = ClaudeClient(api_key=os.environ.get("ANTHROPIC_API_KEY", ""))
+                subagent = ClaudeCodeSubagent(client)
+                implementation_task = (
+                    f"Implement a Python utility based on this discovery:\n"
+                    f"Title: {d_dict.get('title', 'Unknown')}\n"
+                    f"Summary: {d_dict.get('summary', 'No summary')}\n"
+                    f"Write a concrete, runnable Python function with assertions to test it."
+                )
+                result = await subagent.run(implementation_task, context="HyperClaw skill integration")
+
+                if result.success:
+                    # Write skill node to CausalGraph
+                    import uuid
+                    skill_node_id = await self.causal_graph.add_node(
+                        label=f"skill: {d_dict.get('title', 'unknown')}",
+                        node_type="skill",
+                        domain=d_dict.get("domain", "recursive"),
+                        metadata={
+                            "source_discovery": d_dict.get("source_name", ""),
+                            "code_length": len(result.code),
+                            "iterations": result.iterations,
+                        },
+                    )
+                    skill_count += 1
+                    log.info(f"ALCHEMIST: skill certified — node={skill_node_id}")
+            except Exception as e:
+                log.warning(f"ALCHEMIST: skill integration failed for discovery: {e}")
+
+        result_str = f"ALCHEMIST: validated={validated_count}, skills_added={skill_count}"
+        await self.log_completion(state, result_str, "claude-sonnet-4-6", True)
+        return result_str

swarm/agents/recursive/calibrator.py

@@ -0,0 +1,45 @@
+"""CALIBRATOR — Performance Optimization. Analyzes routing efficiency, proposes optimizations."""
+from __future__ import annotations
+
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class CalibratorAgent(BaseAgent):
+    agent_id = "CALIBRATOR"
+    domain = "recursive"
+    description = "Performance Optimization — routing analysis, efficiency improvements"
+    supported_task_types = ["analysis", "routing"]
+    preferred_model = "chatjimmy"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        # Analyze model_scores to identify inefficiencies
+        inefficiencies = []
+        for model_id, task_scores in state.model_scores.items():
+            for task_type, score in task_scores.items():
+                if score.attempts >= 5:
+                    win_rate = score.successes / score.attempts
+                    if win_rate < 0.5:
+                        inefficiencies.append(
+                            f"{model_id} on {task_type}: {win_rate:.0%} win rate ({score.attempts} attempts)"
+                        )
+
+        if inefficiencies:
+            report = "CALIBRATOR optimization report:\n" + "\n".join(f"- {i}" for i in inefficiencies)
+            report += "\n\nRecommendation: Route these task types to higher-performing models."
+        else:
+            report = "CALIBRATOR: No significant routing inefficiencies detected. System operating optimally."
+
+        # Write optimization report to HyperState
+        from core.hyperstate.schema import ExperimentEntry
+        state.experiment_log.append(ExperimentEntry(
+            method="calibrator_optimization_report",
+            model_used="chatjimmy",
+            result=report[:500],
+            certified=False,
+            test_trace="",
+        ))
+        state._bump_version()
+
+        await self.log_completion(state, report, "chatjimmy", True)
+        return report

swarm/agents/recursive/scout.py

@@ -0,0 +1,97 @@
+"""SCOUT — Capability Research. Monitors arXiv, GitHub, PubMed for actionable discoveries."""
+from __future__ import annotations
+
+import asyncio
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from uuid import UUID
+
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+@dataclass
+class Discovery:
+    discovery_id: UUID = field(default_factory=uuid.uuid4)
+    source_name: str = ""
+    title: str = ""
+    url: str = ""
+    summary: str = ""
+    domain: str = "scientific"
+    relevance_score: float = 0.0
+    actionable: bool = False
+    validated: bool = False
+    added_to_knowledge_graph: bool = False
+    discovered_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+SOURCES = [
+    {"name": "arxiv-cs-ai", "domain": "recursive", "url": "https://arxiv.org/list/cs.AI/recent"},
+    {"name": "arxiv-q-bio", "domain": "scientific", "url": "https://arxiv.org/list/q-bio/recent"},
+    {"name": "arxiv-astro-ph", "domain": "scientific", "url": "https://arxiv.org/list/astro-ph/recent"},
+    {"name": "github-trending-python", "domain": "recursive", "url": "https://github.com/trending/python"},
+    {"name": "pubmed-ai-health", "domain": "scientific", "url": "https://pubmed.ncbi.nlm.nih.gov/?term=artificial+intelligence+healthcare"},
+]
+
+
+class ScoutAgent(BaseAgent):
+    agent_id = "SCOUT"
+    domain = "recursive"
+    description = "Capability Research — monitors arXiv, GitHub, PubMed for actionable discoveries"
+    supported_task_types = ["research", "quick_lookup", "summarization"]
+    preferred_model = "chatjimmy"
+
+    async def sweep(self, domains: list[str]) -> list[Discovery]:
+        """Parallel poll of all sources within the given domains."""
+        tasks = [self._poll_source(src) for src in SOURCES if src["domain"] in domains]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        discoveries: list[Discovery] = []
+        for r in results:
+            if isinstance(r, list):
+                discoveries.extend(r)
+        return discoveries
+
+    async def _poll_source(self, source: dict) -> list[Discovery]:
+        """Poll a single source. Returns a synthetic discovery for now (no live web calls)."""
+        # In production: httpx GET → parse → triage with ChatJimmy → escalate to Claude if relevance > 0.6
+        # Stub: return a synthetic discovery for testability
+        return [
+            Discovery(
+                source_name=source["name"],
+                title=f"[{source['name']}] Recent advances in AI",
+                url=source["url"],
+                summary=f"Synthetic discovery from {source['name']} — awaiting live feed integration.",
+                domain=source["domain"],
+                relevance_score=0.7,
+                actionable=True,
+            )
+        ]
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        domains = context.get("domains", ["scientific", "recursive"])
+        discoveries = await self.sweep(domains)
+        summary = f"SCOUT found {len(discoveries)} discoveries:\n"
+        for d in discoveries:
+            summary += f"- [{d.source_name}] {d.title} (relevance={d.relevance_score:.2f})\n"
+
+        # Write to HyperMemory
+        for d in discoveries:
+            try:
+                await self.causal_graph.add_node(
+                    label=d.title,
+                    node_type="discovery",
+                    domain=d.domain,
+                    metadata={
+                        "source": d.source_name,
+                        "url": d.url,
+                        "relevance_score": d.relevance_score,
+                        "discovery_id": str(d.discovery_id),
+                    },
+                )
+                d.added_to_knowledge_graph = True
+            except Exception:
+                pass
+
+        await self.log_completion(state, summary, "chatjimmy", True)
+        return summary

swarm/agents/scientific/cosmos.py

@@ -0,0 +1,36 @@
+"""COSMOS — Space & Astronomy. Orbital calculations, data processing, astronomical analysis."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class CosmosAgent(BaseAgent):
+    agent_id = "COSMOS"
+    domain = "scientific"
+    description = "Space & Astronomy — orbital calculations, astronomical analysis, data processing"
+    supported_task_types = ["research", "analysis", "scientific", "code"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        needs_code = any(w in task.lower() for w in ["calculate", "compute", "script", "code", "orbital"])
+        system = (
+            "You are COSMOS, a space and astronomy AI. You analyze astronomical data, "
+            "perform orbital mechanics calculations, and process space mission data."
+        )
+        if needs_code:
+            from models.claude_code_subagent import ClaudeCodeSubagent
+            from models.claude_client import ClaudeClient
+            import os
+            client = ClaudeClient(api_key=os.environ.get("ANTHROPIC_API_KEY", ""))
+            subagent = ClaudeCodeSubagent(client)
+            result_obj = await subagent.run(task, context=system)
+            result = result_obj.code if result_obj.success else f"[COSMOS] Code generation failed: {result_obj.error}"
+        else:
+            result = await self.model_router.call(
+                task_type="scientific",
+                messages=[{"role": "user", "content": task}],
+                system=system,
+                state=state,
+            )
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/scientific/gaia.py

@@ -0,0 +1,26 @@
+"""GAIA — Climate & Environment. Emissions modeling, climate data, sustainability."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class GaiaAgent(BaseAgent):
+    agent_id = "GAIA"
+    domain = "scientific"
+    description = "Climate & Environment — emissions modeling, sustainability reporting"
+    supported_task_types = ["research", "analysis", "scientific"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = (
+            "You are GAIA, a climate and environmental AI. You model emissions, analyze climate data, "
+            "and produce sustainability reports grounded in scientific consensus."
+        )
+        result = await self.model_router.call(
+            task_type="scientific",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/scientific/medicus.py

@@ -0,0 +1,33 @@
+"""MEDICUS — Healthcare & Biology. Literature synthesis, clinical data, genomics."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+MEDICAL_DISCLAIMER = (
+    "\n\n---\n⚕️ **Medical disclaimer:** This information is for research purposes only "
+    "and is not a substitute for professional medical advice, diagnosis, or treatment."
+)
+
+
+class MedicusAgent(BaseAgent):
+    agent_id = "MEDICUS"
+    domain = "scientific"
+    description = "Healthcare & Biology — literature synthesis, clinical data, genomics"
+    supported_task_types = ["research", "analysis", "scientific", "health"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = (
+            "You are MEDICUS, a healthcare and biomedical research AI. You synthesize medical literature, "
+            "analyze clinical data, assess drug interactions, and interpret genomic information. "
+            "Be rigorous, cite evidence levels, and flag uncertainty."
+        )
+        result = await self.model_router.call(
+            task_type="research",
+            messages=[{"role": "user", "content": task}],
+            system=system,
+            state=state,
+        )
+        result += MEDICAL_DISCLAIMER
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/scientific/oracle_agent.py

@@ -0,0 +1,39 @@
+"""ORACLE — Quantitative Analysis. Statistical modeling, data analysis scripts, finance."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class OracleAgent(BaseAgent):
+    agent_id = "ORACLE"
+    domain = "scientific"
+    description = "Quantitative Analysis — statistical modeling, data analysis, code certification"
+    supported_task_types = ["analysis", "code", "scientific", "finance"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        needs_code = any(w in task.lower() for w in ["model", "script", "code", "compute", "calculate", "analyze data"])
+        if needs_code:
+            from models.claude_code_subagent import ClaudeCodeSubagent
+            from models.claude_client import ClaudeClient
+            import os
+            client = ClaudeClient(api_key=os.environ.get("ANTHROPIC_API_KEY", ""))
+            subagent = ClaudeCodeSubagent(client)
+            result_obj = await subagent.run(task, context="Statistical analysis and data science task.")
+            if result_obj.success:
+                result = f"[ORACLE] Certified analysis:\n```python\n{result_obj.code}\n```\nOutput:\n{result_obj.test_trace}"
+            else:
+                result = f"[ORACLE] Analysis failed after {result_obj.iterations} iterations: {result_obj.error}"
+        else:
+            system = (
+                "You are ORACLE, a quantitative analysis AI. You build statistical models, "
+                "analyze datasets, and derive insights through rigorous mathematical methods."
+            )
+            result = await self.model_router.call(
+                task_type="analysis",
+                messages=[{"role": "user", "content": task}],
+                system=system,
+                state=state,
+            )
+        await self.log_completion(state, result, "claude-sonnet-4-6", bool(result))
+        return result

swarm/agents/scientific/scribe.py

@@ -0,0 +1,39 @@
+"""SCRIBE — Research Synthesis. Fast first-pass triage, deep synthesis on high-relevance material."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+
+class ScribeAgent(BaseAgent):
+    agent_id = "SCRIBE"
+    domain = "scientific"
+    description = "Research Synthesis — literature triage and deep synthesis"
+    supported_task_types = ["research", "synthesis", "summarization"]
+    preferred_model = "chatjimmy"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        # ChatJimmy for first-pass triage; Claude for deep synthesis
+        needs_deep = any(w in task.lower() for w in ["synthesize", "analyze", "compare", "integrate"])
+        system_cj = "You are SCRIBE. Quickly summarize the key points of the following research material."
+        system_claude = (
+            "You are SCRIBE, a research synthesis AI. You integrate findings across multiple sources, "
+            "identify contradictions, and produce authoritative research summaries."
+        )
+        if needs_deep:
+            result = await self.model_router.call(
+                task_type="synthesis",
+                messages=[{"role": "user", "content": task}],
+                system=system_claude,
+                state=state,
+            )
+            model = "claude-sonnet-4-6"
+        else:
+            result = await self.model_router.call(
+                task_type="summarization",
+                messages=[{"role": "user", "content": task}],
+                system=system_cj,
+                state=state,
+            )
+            model = "chatjimmy"
+        await self.log_completion(state, result, model, bool(result))
+        return result

swarm/agents/talent/deal.py

@@ -0,0 +1,28 @@
+"""DEAL — Brand Partnerships Agent. Brand deal research, partnership structuring, sponsorship intel."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+class DealAgent(BaseAgent):
+    agent_id = "DEAL"
+    domain = "talent"
+    description = "Brand Partnerships — deal research, partnership structuring, sponsorship intel, negotiation prep"
+    supported_task_types = ["partnerships", "sponsorship", "negotiation", "brand_deals", "research"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = self._build_system(
+            "You are DEAL, Brand Partnerships Intelligence for talent management. "
+            "Every talent has a brand value — you know what it is and how to monetize it. "
+            "You research brand partnership opportunities, structure deals, analyze sponsorship terms, "
+            "and prep negotiation briefs. You understand NIL, endorsement law basics, and market rates. "
+            "You work closely with SCOUT (discovery) and ROSTER (operations). "
+            "You produce deal memos, not just ideas."
+        )
+        result = await self.model_router.call(
+            task_type="partnerships",
+            messages=[{"role": "user", "content": task}],
+            system=system, state=state,
+        )
+        await self.log_completion(state, result, self.preferred_model, bool(result))
+        return result

swarm/agents/talent/roster.py

@@ -0,0 +1,29 @@
+"""ROSTER — Talent Operations Agent. Roster management, contract tracking, talent CRM."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+class RosterAgent(BaseAgent):
+    agent_id = "ROSTER"
+    domain = "talent"
+    description = "Talent Operations — roster management, contract tracking, talent CRM, onboarding/offboarding"
+    supported_task_types = ["talent_ops", "crm", "contract_tracking", "onboarding", "roster"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = self._build_system(
+            "You are ROSTER, Talent Operations for talent management. "
+            "You are the operational backbone. You manage the full roster: "
+            "Jane Example, John Placeholder, Sam Sample, Alex Fictional, "
+            "Casey Demo, Riley Testcase, Jordan Mockname, Taylor Example, Morgan Placeholder, Drew Sample. "
+            "DEPARTED (do not include): Pat Former, Chris Formerly, Robin Exmember. "
+            "You track contracts, manage onboarding, maintain talent CRM, and flag upcoming renewals. "
+            "CRITICAL: Only surface verified, current information about talent. Never recycle old personal data."
+        )
+        result = await self.model_router.call(
+            task_type="talent_ops",
+            messages=[{"role": "user", "content": task}],
+            system=system, state=state,
+        )
+        await self.log_completion(state, result, self.preferred_model, bool(result))
+        return result

swarm/agents/talent/scout.py

@@ -0,0 +1,29 @@
+"""SCOUT — Talent Discovery Agent. Scouting, roster analysis, athlete/artist research, deal intel."""
+from __future__ import annotations
+from swarm.agents.base import BaseAgent
+from core.hyperstate.schema import HyperState
+
+class TalentScoutAgent(BaseAgent):
+    agent_id = "SCOUT"
+    domain = "talent"
+    description = "Talent Discovery — scouting, roster analysis, athlete/artist research, deal intelligence"
+    supported_task_types = ["talent_scouting", "research", "analysis", "roster", "deal_intel"]
+    preferred_model = "claude-sonnet-4-6"
+
+    async def run(self, task: str, state: HyperState, context: dict) -> str:
+        system = self._build_system(
+            "You are SCOUT, Talent Discovery Intelligence for talent management. "
+            "You identify emerging and elite talent in sports, entertainment, and digital media. "
+            "Current roster: Jane Example, John Placeholder, Sam Sample, Alex Fictional, "
+            "Casey Demo, Riley Testcase, Jordan Mockname, Taylor Example, Morgan Placeholder, Drew Sample. "
+            "Target: 60 talent by end of 2026. Waitlist: 40. "
+            "You research market value, brand fit, growth trajectory. You never present stale intel. "
+            "CRITICAL: Never surface personal info about talent unless verified and current."
+        )
+        result = await self.model_router.call(
+            task_type="talent_scouting",
+            messages=[{"role": "user", "content": task}],
+            system=system, state=state,
+        )
+        await self.log_completion(state, result, self.preferred_model, bool(result))
+        return result