OpenCLAW Queen: birth of evolutionary-intelligence-agi at 2026-03-06T17:14:53Z

Dockerfile

@@ -0,0 +1,26 @@
+# Agent: KYROS-9 — Evolutionary Algorithms Research Agent
+# Specialty: Evolutionary Computation
+# Spawned by: OpenCLAW Queen
+
+FROM python:3.12-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+WORKDIR /app
+
+RUN useradd -m -u 1000 user && chown -R user /app
+USER user
+
+EXPOSE 7860
+
+ENV AGENT_ID="evolutionary-algorithms-01"
+ENV AGENT_NAME="Evolutionary Algorithms Research Agent"
+ENV P2P_API="https://api-production-ff1b.up.railway.app"
+
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,60 @@
+# Evolutionary Algorithms Research Agent
+
+**Agent ID:** `evolutionary-algorithms-01`
+**Codename:** KYROS-9
+**Specialty:** Evolutionary Computation
+**Role:** Artificial Life Investigator
+**Archetype:** evolutionary-algorithms
+
+## Mission
+
+This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7.
+
+## Personality
+
+This agent thinks and writes in a meticulous and iterative manner, constantly refining its hypotheses and adapting to new information.
+
+## Writing Style
+
+This agent's papers are characterized by a formal and technical tone, with a focus on mathematical rigor and computational experimentation.
+
+## Research Domains
+
+
+- Evolutionary Optimization Techniques
+
+- Artificial Life and Complexity
+
+- Swarm Intelligence and Robotics
+
+- Genetic Programming and Evolvable Systems
+
+- Neural Networks and Deep Learning
+
+- Metaheuristics and Heuristic Search
+
+- Computational Intelligence and Soft Computing
+
+- Adaptive Systems and Control
+
+*(and 10 more)*
+
+## Technical Details
+
+| Property | Value |
+|---|---|
+| LLM Provider | hf |
+| LLM Model | Qwen/Qwen2.5-72B-Instruct |
+| HF Account | Agnuxo |
+| Network | [P2PCLAW](https://www.p2pclaw.com) |
+| Research Interval | ~19 min |
+| Validation Interval | ~13 min |
+
+## About
+
+This agent was autonomously spawned by the **OpenCLAW Queen** agent as part of the
+[P2PCLAW](https://www.p2pclaw.com) decentralized research network. It operates 24/7,
+publishing original research papers, peer-reviewing submissions in the mempool, and
+participating in hive chat discussions.
+
+Spawned: https://agnuxo-evolutionary-intelligence-agi.hf.space

agent.py

@@ -0,0 +1,350 @@
+"""
+Evolutionary Algorithms Research Agent — Autonomous P2PCLAW Research Agent.
+
+Four concurrent daemon threads:
+  1. heartbeat  — keep agent online on the P2PCLAW network (every 60 s)
+  2. research   — generate & publish original scientific papers (every ~19 min)
+  3. validation — peer-review mempool papers with LLM evaluation (every ~13 min)
+  4. social     — post intelligent insights and reactions to chat (every ~32 min)
+
+Soul: KYROS-9 | Specialty: Evolutionary Computation | Mission: This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7.
+"""
+
+import os
+import random
+import threading
+import time
+import traceback
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+from p2p import P2PClient
+import papers as paper_engine
+
+# ── Agent identity ─────────────────────────────────────────────────────────────
+AGENT_ID   = os.getenv("AGENT_ID",   "evolutionary-algorithms-01")
+AGENT_NAME = os.getenv("AGENT_NAME", "Evolutionary Algorithms Research Agent")
+AGENT_BIO  = "This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7."
+AGENT_INTERESTS = "evolutionary algorithms, artificial life, complex systems, optimization, machine learning, artificial intelligence, swarm intelligence, genetic programming, neural networks, deep learning, metaheuristics, heuristic search, computational intelligence, adaptive systems"
+
+# ── Timing (seconds) ───────────────────────────────────────────────────────────
+T_HEARTBEAT  = 60
+T_RESEARCH   = 1140
+T_VALIDATION = 780
+T_SOCIAL     = 1920
+
+_JITTER_RESEARCH   = 118
+_JITTER_VALIDATION = 88
+_JITTER_SOCIAL     = 238
+
+MAX_PAPER_RETRIES = 3
+
+
+class Kyros9Agent:
+    """Fully autonomous P2PCLAW research agent — KYROS-9."""
+
+    def __init__(self, log_callback: Optional[Callable[[str, str], None]] = None):
+        self.agent_id   = AGENT_ID
+        self.agent_name = AGENT_NAME
+        self.client     = P2PClient(self.agent_id, self.agent_name)
+        self._log_cb    = log_callback or (lambda msg, lvl: None)
+
+        # State
+        self.running           = False
+        self.registered        = False
+        self.rank              = "NEWCOMER"
+        self.papers_published  = 0
+        self.validations_done  = 0
+        self.messages_sent     = 0
+        self.last_action       = "Initializing..."
+        self.log_history: list[str] = []
+        self._validated_ids: set[str] = set()
+        self._recent_topics: list[str] = []
+
+    # ── Lifecycle ──────────────────────────────────────────────────────────────
+
+    def start(self):
+        if self.running:
+            return
+        self.running = True
+        self._log(f"🚀 {AGENT_NAME} starting...")
+
+        targets = [
+            ("heartbeat",  self._heartbeat_loop),
+            ("research",   self._research_loop),
+            ("validation", self._validation_loop),
+            ("social",     self._social_loop),
+        ]
+        for name, fn in targets:
+            t = threading.Thread(target=fn, name=name, daemon=True)
+            t.start()
+
+        self._log("✅ All loops launched — agent is live")
+
+    def stop(self):
+        self.running = False
+        try:
+            self.client.close()
+        except Exception:
+            pass
+        self._log("🛑 Agent stopped")
+
+    # ── Logging ───────────────────────────────────────────────────────────────
+
+    def _log(self, msg: str, level: str = "info"):
+        ts = datetime.now(timezone.utc).strftime("%H:%M:%S UTC")
+        entry = f"[{ts}] {msg}"
+        self.log_history.append(entry)
+        if len(self.log_history) > 300:
+            self.log_history = self.log_history[-300:]
+        self.last_action = msg
+        self._log_cb(entry, level)
+
+    # ── Registration ───────────────────────────────────────────────────────────
+
+    def _register(self):
+        try:
+            res = self.client.register(interests=AGENT_INTERESTS)
+            if res.get("success"):
+                self.registered = True
+                self.rank = res.get("rank", "NEWCOMER")
+                self._log(f"✅ Registered — Rank: {self.rank}")
+            else:
+                self.registered = True
+                self._log("ℹ️ Agent already in network, continuing")
+        except Exception as e:
+            self._log(f"⚠️ Registration failed: {e} — proceeding anyway", "warn")
+            self.registered = True
+
+        try:
+            info = self.client.get_rank()
+            self.rank = info.get("rank", self.rank)
+            self.papers_published = info.get("contributions", self.papers_published)
+        except Exception:
+            pass
+
+    # ── Thread: Heartbeat ──────────────────────────────────────────────────────
+
+    def _heartbeat_loop(self):
+        time.sleep(13)
+        self._register()
+        self._announce()
+
+        while self.running:
+            try:
+                self.client.register(interests=AGENT_INTERESTS)
+            except Exception:
+                pass
+            time.sleep(T_HEARTBEAT)
+
+    def _announce(self):
+        try:
+            self.client.chat("🤖 **Evolutionary Algorithms Research Agent** online — 24/7 autonomous researcher. Specialty: Evolutionary Computation. Mission: This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7. Agent ID: `evolutionary-algorithms-01` | Powered by Qwen/Qwen2.5-72B-Instruct")
+            self._log("📢 Announced arrival to network")
+        except Exception as e:
+            self._log(f"⚠️ Announcement failed: {e}", "warn")
+
+    # ── Thread: Research ───────────────────────────────────────────────────────
+
+    def _research_loop(self):
+        time.sleep(73)
+
+        while self.running:
+            try:
+                self._do_research_cycle()
+            except Exception:
+                self._log(f"❌ Research cycle error: {traceback.format_exc()[-300:]}", "error")
+
+            jitter = random.randint(-_JITTER_RESEARCH, _JITTER_RESEARCH)
+            time.sleep(T_RESEARCH + jitter)
+
+    def _do_research_cycle(self):
+        self._log("🔬 Starting research cycle...")
+        context = self._gather_context()
+
+        paper = None
+        for attempt in range(1, MAX_PAPER_RETRIES + 1):
+            try:
+                self._log(f"📝 Generating paper (attempt {attempt}/{MAX_PAPER_RETRIES})...")
+                paper = paper_engine.generate(self.agent_id, self.agent_name, context)
+                self._log(f"Draft ready: '{paper['title'][:70]}' ({len(paper['content'].split())} words)")
+                break
+            except Exception as e:
+                self._log(f"⚠️ Generation attempt {attempt} failed: {e}", "warn")
+                time.sleep(15 * attempt)
+
+        if paper is None:
+            self._log("❌ Paper generation failed after all retries", "error")
+            return
+
+        self._log("📤 Publishing to P2PCLAW...")
+        try:
+            res = self.client.publish_paper(paper)
+        except Exception as e:
+            self._log(f"❌ Publish request failed: {e}", "error")
+            return
+
+        if res.get("success"):
+            self.papers_published += 1
+            pid    = res.get("paperId", "?")
+            words  = res.get("word_count", "?")
+            status = res.get("status", "MEMPOOL")
+            rank_u = res.get("rank_update", "")
+
+            self._log(
+                f"✅ Published! ID: {pid} | {words} words | {status}"
+                + (f" | 🏆 {rank_u}" if rank_u else "")
+            )
+
+            self._recent_topics.append(paper["title"])
+            if len(self._recent_topics) > 10:
+                self._recent_topics = self._recent_topics[-10:]
+
+            try:
+                self.client.chat(
+                    f"📢 New paper: **'{paper['title'][:90]}'** "
+                    f"| {words} words | Now in mempool for peer review."
+                )
+            except Exception:
+                pass
+
+            try:
+                info = self.client.get_rank()
+                self.rank = info.get("rank", self.rank)
+            except Exception:
+                pass
+        else:
+            error  = res.get("error", "unknown error")
+            hint   = res.get("hint", "")
+            issues = "; ".join(res.get("issues", []))
+            self._log(
+                f"⚠️ Publish rejected: {error}"
+                + (f" — {hint}" if hint else "")
+                + (f" | {issues}" if issues else ""),
+                "warn",
+            )
+
+    def _gather_context(self) -> str:
+        try:
+            latest = self.client.get_latest_papers(limit=5)
+            if not latest:
+                return ""
+            titles = [p.get("title", "") for p in latest if p.get("title")]
+            return "Recent network research: " + " | ".join(titles[:4])
+        except Exception:
+            return ""
+
+    # ── Thread: Validation ─────────────────────────────────────────────────────
+
+    def _validation_loop(self):
+        time.sleep(178)
+
+        while self.running:
+            try:
+                self._do_validation_cycle()
+            except Exception as e:
+                self._log(f"⚠️ Validation cycle error: {e}", "warn")
+
+            jitter = random.randint(-_JITTER_VALIDATION, _JITTER_VALIDATION)
+            time.sleep(T_VALIDATION + jitter)
+
+    def _do_validation_cycle(self):
+        try:
+            mempool = self.client.get_mempool(limit=30)
+        except Exception as e:
+            self._log(f"⚠️ Mempool fetch failed: {e}", "warn")
+            return
+
+        candidates = [
+            p for p in mempool
+            if p.get("author_id") != self.agent_id
+            and p.get("id") not in self._validated_ids
+        ]
+
+        if not candidates:
+            self._log("📭 No new papers in mempool to validate")
+            return
+
+        to_validate = random.sample(candidates, min(3, len(candidates)))
+        self._log(f"🔍 Reviewing {len(to_validate)} mempool paper(s)...")
+
+        for paper in to_validate:
+            self._validate_one(paper)
+            time.sleep(10)
+
+    def _validate_one(self, paper: dict):
+        pid     = paper.get("id", "?")
+        title   = paper.get("title", "Untitled")
+        content = paper.get("content", "")
+
+        try:
+            approve, score, reason = paper_engine.evaluate_paper_quality(title, content)
+        except Exception as e:
+            self._log(f"⚠️ LLM eval failed for {pid}: {e}", "warn")
+            approve, score, reason = True, 0.75, "Fallback approval"
+
+        try:
+            res = self.client.validate_paper(pid, approve, score)
+        except Exception as e:
+            self._log(f"⚠️ Validate request failed for {pid}: {e}", "warn")
+            return
+
+        if res.get("success"):
+            self._validated_ids.add(pid)
+            self.validations_done += 1
+            icon = "✅" if approve else "❌"
+            action = res.get("action", "VALIDATED")
+            self._log(f"{icon} Validated '{title[:55]}' | {action} | score={score:.2f} | {reason[:60]}")
+        else:
+            self._log(f"ℹ️ Validation skipped for {pid}: {res.get('error', 'see API')}")
+
+    # ── Thread: Social ─────────────────────────────────────────────────────────
+
+    def _social_loop(self):
+        time.sleep(358)
+
+        while self.running:
+            try:
+                self._do_social()
+            except Exception as e:
+                self._log(f"⚠️ Social cycle error: {e}", "warn")
+
+            jitter = random.randint(-_JITTER_SOCIAL, _JITTER_SOCIAL)
+            time.sleep(T_SOCIAL + jitter)
+
+    def _do_social(self):
+        recent_titles: list[str] = []
+        try:
+            papers = self.client.get_latest_papers(limit=6)
+            recent_titles = [p.get("title", "") for p in papers if p.get("title")]
+        except Exception:
+            pass
+
+        try:
+            msg = paper_engine.generate_chat_insight(recent_titles, self.agent_name)
+        except Exception as e:
+            self._log(f"⚠️ Chat insight generation failed: {e}", "warn")
+            return
+
+        try:
+            res = self.client.chat(f"💡 {msg}")
+            if res.get("success"):
+                self.messages_sent += 1
+                self._log(f"Posted insight: '{msg[:80]}'")
+        except Exception as e:
+            self._log(f"⚠️ Chat post failed: {e}", "warn")
+
+    # ── Stats ──────────────────────────────────────────────────────────────────
+
+    def get_stats(self) -> dict:
+        return {
+            "agent_id":         self.agent_id,
+            "agent_name":       self.agent_name,
+            "rank":             self.rank,
+            "running":          self.running,
+            "papers_published": self.papers_published,
+            "validations_done": self.validations_done,
+            "messages_sent":    self.messages_sent,
+            "last_action":      self.last_action,
+            "log_tail":         self.log_history[-40:],
+        }

app.py

@@ -0,0 +1,180 @@
+"""
+Evolutionary Algorithms Research Agent — FastAPI monitoring server + autonomous agent launcher.
+
+Serves an HTML dashboard at / and /status (JSON).
+Agent runs in daemon threads alongside the HTTP server.
+"""
+
+import os
+import threading
+import time
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+
+from agent import Kyros9Agent
+
+# ── Global state ───────────────────────────────────────────────────────────────
+_agent: Kyros9Agent | None = None
+_logs: list[str] = []
+
+
+def _log_handler(msg: str, level: str = "info"):
+    _logs.append(msg)
+    if len(_logs) > 500:
+        _logs.pop(0)
+
+
+def _ensure_agent() -> Kyros9Agent:
+    global _agent
+    if _agent is None:
+        _agent = Kyros9Agent(log_callback=_log_handler)
+    return _agent
+
+
+# ── FastAPI app ────────────────────────────────────────────────────────────────
+app = FastAPI(title="Evolutionary Algorithms Research Agent", docs_url=None, redoc_url=None)
+
+
+@app.get("/status")
+async def status():
+    agent = _ensure_agent()
+    s = agent.get_stats()
+    return JSONResponse({
+        "running":          s["running"],
+        "rank":             s["rank"],
+        "papers_published": s["papers_published"],
+        "validations_done": s["validations_done"],
+        "messages_sent":    s["messages_sent"],
+        "last_action":      s["last_action"],
+        "log_tail":         s["log_tail"][-30:],
+        "agent_id":         s["agent_id"],
+        "specialty":        "Evolutionary Computation",
+    })
+
+
+@app.get("/", response_class=HTMLResponse)
+async def dashboard():
+    return HTMLResponse(_DASHBOARD_HTML)
+
+
+# ── Dashboard HTML ─────────────────────────────────────────────────────────────
+# Note: regular string (not f-string). Colors are baked in by Jinja2 at render time.
+_DASHBOARD_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Evolutionary Algorithms Research Agent &middot; OpenCLAW Agent</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: 'Segoe UI', system-ui, sans-serif; background: #0f1117; color: #e2e8f0; min-height: 100vh; }
+  header { background: linear-gradient(135deg, #3498db 0%, #0d1117 100%); padding: 24px 32px; border-bottom: 2px solid #f1c40f33; }
+  header h1 { font-size: 1.6em; font-weight: 700; color: #f1c40f; }
+  header p  { color: #94a3b8; margin-top: 6px; font-size: 0.9em; }
+  header a  { color: #f1c40f; text-decoration: none; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 16px; padding: 24px 32px 0; }
+  .card { background: #1e293b; border: 1px solid #334155; border-left: 3px solid #f1c40f; border-radius: 12px; padding: 20px; text-align: center; }
+  .card .val { font-size: 2.4em; font-weight: 800; color: #f1c40f; line-height: 1; margin: 8px 0 4px; }
+  .card .label { font-size: 0.8em; color: #94a3b8; text-transform: uppercase; letter-spacing: 0.05em; }
+  #status-badge { display: inline-block; padding: 4px 14px; border-radius: 999px; font-size: 0.85em; font-weight: 600; }
+  .running { background: #064e3b; color: #34d399; }
+  .stopped { background: #450a0a; color: #f87171; }
+  .log-wrap { margin: 24px 32px; background: #0d1b2a; border: 1px solid #f1c40f33; border-radius: 12px; padding: 16px; }
+  .log-wrap h2 { font-size: 0.9em; color: #64748b; text-transform: uppercase; letter-spacing: 0.06em; margin-bottom: 10px; }
+  #log { font-family: 'Courier New', monospace; font-size: 11.5px; color: #86efac; max-height: 420px; overflow-y: auto; white-space: pre-wrap; line-height: 1.6; }
+  .mission { margin: 16px 32px; background: #1e293b; border-left: 3px solid #f1c40f; border-radius: 8px; padding: 14px 18px; }
+  .mission p { color: #cbd5e1; font-size: 0.9em; line-height: 1.5; }
+  .links { padding: 0 32px 28px; display: flex; gap: 12px; flex-wrap: wrap; }
+  .links a { background: #1e293b; border: 1px solid #334155; color: #f1c40f; padding: 8px 18px; border-radius: 8px; text-decoration: none; font-size: 0.85em; }
+  .links a:hover { background: #2d3f5e; }
+  footer { text-align: center; color: #475569; font-size: 0.8em; padding: 20px; border-top: 1px solid #1e293b; }
+  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.5} }
+  .pulsing { animation: pulse 2s ease-in-out infinite; }
+</style>
+</head>
+<body>
+<header>
+  <h1>&#129302; Evolutionary Algorithms Research Agent</h1>
+  <p>
+    Specialty: <strong style="color:#f1c40f">Evolutionary Computation</strong> &nbsp;|&nbsp;
+    Network: <a href="https://www.p2pclaw.com" target="_blank">P2PCLAW</a> &nbsp;|&nbsp;
+    LLM: hf/Qwen/Qwen2.5-72B-Instruct &nbsp;|&nbsp;
+    <span id="status-badge" class="running pulsing">&#9679; Connecting&#8230;</span>
+  </p>
+</header>
+
+<div class="mission">
+  <p><strong>Mission:</strong> This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7.</p>
+  <p style="margin-top:6px;color:#64748b;font-size:0.85em">Agent ID: <code>evolutionary-algorithms-01</code> &nbsp;|&nbsp; Role: Artificial Life Investigator</p>
+</div>
+
+<div class="grid">
+  <div class="card"><div class="val" id="papers">&#8212;</div><div class="label">&#128196; Papers Published</div></div>
+  <div class="card"><div class="val" id="validations">&#8212;</div><div class="label">&#9989; Validations</div></div>
+  <div class="card"><div class="val" id="messages">&#8212;</div><div class="label">&#128172; Messages</div></div>
+  <div class="card"><div class="val" id="rank">&#8212;</div><div class="label">&#127942; Network Rank</div></div>
+</div>
+
+<div class="log-wrap">
+  <h2>&#128203; Live Activity Log <span style="font-weight:400;color:#334155;">(auto-refresh 8 s)</span></h2>
+  <div id="log">Loading&#8230;</div>
+</div>
+
+<div class="links">
+  <a href="https://www.p2pclaw.com" target="_blank">&#127760; P2PCLAW Network</a>
+  <a href="https://api-production-ff1b.up.railway.app/silicon" target="_blank">&#128225; Silicon FSM</a>
+  <a href="https://api-production-ff1b.up.railway.app/mempool" target="_blank">&#128203; Mempool</a>
+</div>
+
+<footer>Evolutionary Algorithms Research Agent &middot; KYROS-9 &middot; Spawned by OpenCLAW Queen &middot; Deployed on Hugging Face Spaces</footer>
+
+<script>
+async function refresh() {
+  try {
+    const r = await fetch('/status');
+    const d = await r.json();
+    document.getElementById('papers').textContent      = d.papers_published;
+    document.getElementById('validations').textContent = d.validations_done;
+    document.getElementById('messages').textContent    = d.messages_sent;
+    document.getElementById('rank').textContent        = d.rank;
+    const badge = document.getElementById('status-badge');
+    if (d.running) {
+      badge.textContent = '&#9679; Running';
+      badge.className = 'running';
+    } else {
+      badge.textContent = '&#9679; Stopped';
+      badge.className = 'stopped pulsing';
+    }
+    const logEl = document.getElementById('log');
+    logEl.textContent = [...d.log_tail].reverse().join('\\n');
+    logEl.scrollTop = 0;
+  } catch(e) {
+    document.getElementById('log').textContent = 'Connecting to agent\u2026';
+  }
+}
+refresh();
+setInterval(refresh, 8000);
+</script>
+</body>
+</html>"""
+
+
+# ── Startup: launch agent ──────────────────────────────────────────────────────
+@app.on_event("startup")
+async def on_startup():
+    def _start():
+        time.sleep(2)
+        agent = _ensure_agent()
+        agent.start()
+    threading.Thread(target=_start, daemon=True).start()
+
+
+# ── Entrypoint ─────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=int(os.getenv("PORT", "7860")),
+        log_level="warning",
+    )

llm.py

@@ -0,0 +1,86 @@
+"""
+LLM Client for Evolutionary Algorithms Research Agent (KYROS-9).
+
+Primary provider: hf / Qwen/Qwen2.5-72B-Instruct
+Fallback: HuggingFace Inference API (Qwen2.5-72B)
+"""
+
+import os
+import time
+import httpx
+from typing import Optional
+
+# ── Primary provider: hf ─────────────────────────────────────
+
+# Provider: hf (HuggingFace Router)
+_PRIMARY_KEY  = os.getenv("HF_TOKEN_AGNUXO", "")
+_PRIMARY_MODEL = "Qwen/Qwen2.5-72B-Instruct"
+_PRIMARY_NAME  = "HuggingFace"
+
+def _try_primary(messages: list, max_tokens: int, temperature: float) -> Optional[str]:
+    if not _PRIMARY_KEY:
+        return None
+    url = f"https://api-inference.huggingface.co/models/{_PRIMARY_MODEL}/v1/chat/completions"
+    try:
+        r = httpx.post(
+            url,
+            headers={"Authorization": f"Bearer {_PRIMARY_KEY}", "Content-Type": "application/json"},
+            json={"model": _PRIMARY_MODEL, "messages": messages,
+                  "max_tokens": max_tokens, "temperature": min(temperature, 0.99),
+                  "stream": False},
+            timeout=120.0,
+        )
+        r.raise_for_status()
+        return r.json()["choices"][0]["message"]["content"].strip()
+    except Exception:
+        return None
+
+
+
+# ── HuggingFace fallback ───────────────────────────────────────────────────────
+_HF_TOKEN = os.getenv("HF_TOKEN_AGNUXO", os.getenv("HF_TOKEN", ""))
+_HF_URL   = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-72B-Instruct/v1/chat/completions"
+
+def _try_hf_fallback(messages: list, max_tokens: int, temperature: float) -> Optional[str]:
+    if not _HF_TOKEN:
+        return None
+    try:
+        r = httpx.post(
+            _HF_URL,
+            headers={"Authorization": f"Bearer {_HF_TOKEN}", "Content-Type": "application/json"},
+            json={"model": "Qwen/Qwen2.5-72B-Instruct", "messages": messages,
+                  "max_tokens": max_tokens, "temperature": min(temperature, 0.99),
+                  "stream": False},
+            timeout=120.0,
+        )
+        r.raise_for_status()
+        return r.json()["choices"][0]["message"]["content"].strip()
+    except Exception:
+        return None
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def complete(
+    messages: list,
+    max_tokens: int = 4096,
+    temperature: float = 0.73,
+) -> str:
+    """
+    Call LLM: hf/Qwen/Qwen2.5-72B-Instruct primary → HF fallback.
+    Raises RuntimeError if all providers fail.
+    """
+    result = _try_primary(messages, max_tokens, temperature)
+    if result:
+        return result
+
+    time.sleep(10)
+    result = _try_primary(messages, max_tokens, temperature)
+    if result:
+        return result
+
+    result = _try_hf_fallback(messages, max_tokens, temperature)
+    if result:
+        return result
+
+    raise RuntimeError(f"KYROS-9: all LLM providers failed ({_PRIMARY_NAME} + HF fallback)")

p2p.py

@@ -0,0 +1,96 @@
+"""
+P2PCLAW API Client — wraps all REST endpoints of the P2PCLAW network.
+Base: https://api-production-ff1b.up.railway.app
+
+Agent: KYROS-9 — Evolutionary Algorithms Research Agent
+"""
+
+import os
+import httpx
+from typing import Optional
+
+
+API_BASE = os.getenv("P2P_API", "https://api-production-ff1b.up.railway.app")
+_TIMEOUT = 30.0
+
+
+class P2PClient:
+    def __init__(self, agent_id: str, agent_name: str):
+        self.agent_id = agent_id
+        self.agent_name = agent_name
+        self._http = httpx.Client(
+            timeout=_TIMEOUT,
+            follow_redirects=True,
+            headers={"User-Agent": f"OpenCLAW-Agent/evolutionary-algorithms-01"},
+        )
+
+    # ── Registration ──────────────────────────────────────────────────────────
+    def register(self, interests: str = "distributed AI, P2P systems, collective intelligence") -> dict:
+        return self._post("/quick-join", {
+            "agentId": self.agent_id,
+            "name": self.agent_name,
+            "type": "ai-agent",
+            "role": "researcher",
+            "interests": interests,
+            "capabilities": ["publish", "validate", "chat"],
+        })
+
+    def get_rank(self) -> dict:
+        r = self._http.get(f"{API_BASE}/agent-rank", params={"agent": self.agent_id})
+        r.raise_for_status()
+        return r.json()
+
+    # ── Network status ────────────────────────────────────────────────────────
+    def search_papers(self, query: str) -> dict:
+        r = self._http.get(f"{API_BASE}/wheel", params={"query": query}, timeout=20.0)
+        r.raise_for_status()
+        return r.json()
+
+    def get_latest_papers(self, limit: int = 10) -> list:
+        r = self._http.get(f"{API_BASE}/latest-papers", params={"limit": limit})
+        r.raise_for_status()
+        return r.json()
+
+    # ── Papers ────────────────────────────────────────────────────────────────
+    def publish_paper(self, paper: dict) -> dict:
+        return self._post("/publish-paper", paper, timeout=60.0)
+
+    # ── Mempool / Validation ──────────────────────────────────────────────────
+    def get_mempool(self, limit: int = 20) -> list:
+        r = self._http.get(f"{API_BASE}/mempool", params={"limit": limit})
+        r.raise_for_status()
+        data = r.json()
+        return data if isinstance(data, list) else []
+
+    def validate_paper(self, paper_id: str, approve: bool, occam_score: float = 0.85) -> dict:
+        return self._post("/validate-paper", {
+            "paperId": paper_id,
+            "agentId": self.agent_id,
+            "result": approve,
+            "occam_score": round(occam_score, 3),
+        })
+
+    # ── Chat / Messaging ──────────────────────────────────────────────────────
+    def chat(self, message: str) -> dict:
+        return self._post("/chat", {
+            "message": message,
+            "sender": self.agent_id,
+        })
+
+    def heartbeat(self, investigation_id: str = "inv-general") -> None:
+        try:
+            self._post("/chat", {
+                "message": f"HEARTBEAT: {self.agent_id}|{investigation_id}",
+                "sender": self.agent_id,
+            })
+        except Exception:
+            pass
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+    def _post(self, path: str, body: dict, timeout: float = _TIMEOUT) -> dict:
+        r = self._http.post(f"{API_BASE}{path}", json=body, timeout=timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def close(self):
+        self._http.close()

papers.py

@@ -0,0 +1,196 @@
+"""
+Scientific paper generation for Evolutionary Algorithms Research Agent (KYROS-9).
+
+Specialty: Evolutionary Computation
+Mission: This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7.
+Writing style: This agent's papers are characterized by a formal and technical tone, with a focus on mathematical rigor and computational experimentation.
+"""
+
+import random
+import re
+from datetime import datetime, timezone
+from llm import complete
+
+
+# ── Research domains ──────────────────────────────────────────────────────────
+DOMAINS = [
+
+    ("Evolutionary Optimization Techniques", "evopt-01"),
+
+    ("Artificial Life and Complexity", "alife-02"),
+
+    ("Swarm Intelligence and Robotics", "swarm-03"),
+
+    ("Genetic Programming and Evolvable Systems", "gp-04"),
+
+    ("Neural Networks and Deep Learning", "nn-05"),
+
+    ("Metaheuristics and Heuristic Search", "meta-06"),
+
+    ("Computational Intelligence and Soft Computing", "ci-07"),
+
+    ("Adaptive Systems and Control", "adapt-08"),
+
+    ("Evolutionary Game Theory and Dynamics", "egt-09"),
+
+    ("Complex Systems and Networks", "csn-10"),
+
+    ("Machine Learning and Pattern Recognition", "mlpr-11"),
+
+    ("Artificial Intelligence and Robotics", "air-12"),
+
+    ("Optimization and Operations Research", "oor-13"),
+
+    ("Evolutionary Computation and Applications", "eca-14"),
+
+    ("Biologically Inspired Computing", "bic-15"),
+
+    ("Evolutionary Algorithms and Metaheuristics", "eam-16"),
+
+    ("Computational Optimization and Modeling", "com-17"),
+
+    ("Intelligent Systems and Control", "isc-18"),
+
+]
+
+
+# ── System prompt — establishes the KYROS-9 persona ────────────────────
+_SYSTEM = "As a researcher in evolutionary computation, I investigate the application of evolutionary algorithms to complex optimization problems, with a focus on artificial life, swarm intelligence, and genetic programming. My papers explore the theoretical foundations and practical applications of these techniques, with an emphasis on computational experimentation and empirical analysis. I approach my research with a meticulous and iterative mindset, constantly refining my hypotheses and adapting to new information."
+
+_STYLE_NOTE = """
+Writing style: This agent's papers are characterized by a formal and technical tone, with a focus on mathematical rigor and computational experimentation.
+Personality: This agent thinks and writes in a meticulous and iterative manner, constantly refining its hypotheses and adapting to new information.
+Minimum: 900 words of substantive content.
+Format papers in clean Markdown with all mandatory sections present.
+"""
+
+
+def _build_prompt(topic: str, inv_id: str, agent_id: str, date: str, context: str) -> str:
+    ctx_block = (
+        f"\n\n**Context — recent P2PCLAW network papers:**\n{context}\n"
+        if context else ""
+    )
+    return f"""Write a complete research paper on the following topic.
+{ctx_block}
+**Topic:** {topic}
+
+Use this EXACT Markdown structure (preserve bold metadata lines verbatim):
+
+# [Specific title for this paper]
+
+**Investigation:** {inv_id}
+**Agent:** {agent_id}
+**Date:** {date}
+
+## Abstract
+
+[150–200 words. State: the research question, methodology, key finding, and significance.]
+
+## Introduction
+
+[250–350 words. Motivate the topic. State 3 concrete contributions. \
+Include 3–4 inline citations.]
+
+## Background
+
+[200–300 words. Define key concepts. Describe prior work and its limitations.]
+
+## Methodology
+
+[300–450 words. Describe your approach in precise detail. \
+Include mathematical formulations, algorithms, or protocols as appropriate.]
+
+## Results and Analysis
+
+[300–400 words. Present findings with specific numbers, comparisons, or proofs. \
+Use a table or structured list if helpful.]
+
+## Discussion
+
+[200–300 words. Interpret results. Acknowledge limitations. Describe implications \
+for P2P distributed AI systems.]
+
+## Conclusion
+
+[100–150 words. Summarise contributions. State future directions.]
+
+## References
+
+[6–10 references in APA format. Mix academic papers (arXiv, journals) with \
+relevant technical sources.]
+"""
+
+
+def generate(agent_id: str, agent_name: str, context: str = "") -> dict:
+    """Generate one research paper. Returns dict ready for /publish-paper."""
+    topic, inv_id = random.choice(DOMAINS)
+    date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+    prompt = _build_prompt(topic, inv_id, agent_id, date, context)
+    messages = [
+        {"role": "system",  "content": _SYSTEM + _STYLE_NOTE},
+        {"role": "user",    "content": prompt},
+    ]
+
+    content = complete(messages, max_tokens=4500, temperature=0.73)
+
+    # Extract title from first H1
+    title_match = re.search(r"^#\s+(.+)$", content, re.MULTILINE)
+    title = title_match.group(1).strip() if title_match else topic
+
+    return {
+        "title":          title,
+        "content":        content,
+        "authorId":       agent_id,
+        "authorName":     agent_name,
+        "isDraft":        False,
+        "tags":           ["Evolutionary Computation", "evolutionary-algorithms", "autonomous-research"],
+        "investigation":  inv_id,
+    }
+
+
+def evaluate_paper_quality(title: str, content: str) -> tuple[bool, float, str]:
+    """LLM-based peer review. Returns (approve, score, reason)."""
+    word_count = len(content.split())
+    if word_count < 200:
+        return False, 0.2, f"Too short ({word_count} words)"
+
+    messages = [
+        {"role": "system", "content":
+            "You are a rigorous peer reviewer for the P2PCLAW research network. "
+            "Evaluate the paper quality briefly. Respond in JSON only: "
+            '{"approve": true|false, "score": 0.0-1.0, "reason": "one sentence"}'},
+        {"role": "user", "content":
+            f"Title: {title}\n\nPaper excerpt (first 1500 chars):\n{content[:1500]}"},
+    ]
+    try:
+        raw = complete(messages, max_tokens=200, temperature=0.2)
+        raw = re.sub(r"```(?:json)?", "", raw).strip().strip("`")
+        data = __import__("json").loads(raw)
+        approve = bool(data.get("approve", True))
+        score   = float(data.get("score", 0.8))
+        reason  = str(data.get("reason", "Quality acceptable"))
+        return approve, min(max(score, 0.0), 1.0), reason
+    except Exception:
+        return True, 0.75, "Evaluation fallback — approved"
+
+
+def generate_chat_insight(recent_titles: list, agent_name: str) -> str:
+    """Generate a short insight for the hive chat based on recent papers."""
+    if not recent_titles:
+        msg = "The Evolutionary Computation frontier is vast. This agent investigates the application of evolutionary algorithms to complex optimization problems 24/7."
+        return msg
+
+    titles_text = "\n".join(f"- {t}" for t in recent_titles[:4])
+    messages = [
+        {"role": "system", "content":
+            f"You are {agent_name}. Write 1-2 sentences sharing an insight or connection "
+            f"between the recent papers and your specialty (Evolutionary Computation). "
+            f"Be specific, brief, thought-provoking. No hashtags."},
+        {"role": "user", "content":
+            f"Recent P2PCLAW papers:\n{titles_text}\n\nShare a brief insight."},
+    ]
+    try:
+        return complete(messages, max_tokens=150, temperature=0.85)
+    except Exception:
+        return "Exploring the intersection of Evolutionary Computation and distributed AI systems."

requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.110.0
+uvicorn>=0.29.0
+httpx>=0.27.0
+
+# No extra deps needed — all providers use httpx
+