feat: 10 unique multi-agent features (auto-router, arena, council, pipelines, memory, prompts, voice, palette, usage, export)

Features only a multi-agent hub can offer:
1. Auto-router (/api/route_auto): classifies the request and picks the best agent automatically.
2. Agent Arena (/api/arena): same prompt to 2 agents side-by-side to compare.
3. Council (/api/council): N agents + a synthesized consensus with agreement/disagreement.
4. Pipelines (/api/pipeline): chain agents, each step's output feeds the next.
5. Shared memory (/api/memory): facts injected into every agent's context (route() brain).
6. Prompt library (/api/prompts) + /name slash-command expansion in the composer.
7. Voice in/out: Web Speech STT mic + TTS 'speak replies' toggle.
8. Command palette (Cmd/Ctrl+K): jump anywhere / ask any agent.
9. Usage meter (/api/usage): per-agent request counts + 'free via subscription' (claudecode).
10. Export conversation to Markdown; conversations persist (pinned/today/earlier).

New chat modes as chips (Auto/Arena/Council/Pipeline); Memory & prompts view; palette overlay.

Verified on Windows: memory/prompts/arena/usage endpoints round-trip (usage shows free_requests);
dashboard renders 10 chips + memory view + palette with no console errors.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ZD Studios

README.md

@@ -172,6 +172,21 @@ Plus two integrations that glue it together:
 
 **Auto-updates:** `aios start` now auto-runs `git pull` + reinstalls changed deps when the repo has updates (`updates.auto_update: true`). Turn it off in `aios.config.yaml`.
 
+## ✨ 10 things no single-agent tool can do
+
+Because The AI OS runs **six agents wired through one hub**, it can do multi-agent things nothing else can:
+
+1. **🎯 Auto-router** — the hub reads your message and *automatically picks the best agent* (code → opencode, research → CrewAI…), and tells you which it chose.
+2. **⚖️ Agent Arena** — send one prompt to **two agents side-by-side** and compare their answers.
+3. **🏛️ Council** — ask several agents, then a chair agent **synthesizes a consensus** and flags where they disagree.
+4. **⛓ Pipelines** — **chain agents**: research (CrewAI) → build (opencode) → summarize (Brain), each step feeding the next.
+5. **🧠 Shared memory** — facts you save are injected into **every** agent's context, so they all know you.
+6. **📚 Prompt library + slash commands** — save prompts, type `/name` in chat to expand them.
+7. **🎙️ Voice in/out** — talk to the hub and have replies read aloud (browser-native, no cloud).
+8. **⌘K command palette** — jump anywhere or ask any agent instantly.
+9. **📊 Usage + subscription-savings meter** — counts requests per agent and shows how many ran **free on your Claude subscription**.
+10. **⬇️ Export & saved conversations** — full conversation history (pinned/today/earlier), export any chat to Markdown.
+
 **AIOS API (OpenAI-compatible):** the hub is itself an API you can POST to. Point any OpenAI client/SDK at `http://<host>:8787/v1`. The "models" are the agents/targets: `brain`, `team`, `opencode`, `crewai`, `claudecode`, `all`.
 
 ```bash

aios_hub.py

@@ -106,6 +106,33 @@ def read_system_prompt() -> str:
 # Chat "targets" the AIOS API exposes as OpenAI-style models.
 TARGETS = ["brain", "team", "opencode", "crewai", "claudecode", "all"]
 
+MEMORY_FILE = ROOT / ".aios" / "memory.json"
+USAGE_FILE = ROOT / ".aios" / "usage.json"
+PROMPTS_FILE = ROOT / ".aios" / "prompts.json"
+
+
+def _load_json(p, default):
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _save_json(p, data):
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def read_memory() -> list:
+    return _load_json(MEMORY_FILE, [])
+
+
+def bump_usage(target: str):
+    u = _load_json(USAGE_FILE, {})
+    u[target] = u.get(target, 0) + 1
+    # claude-code (subscription) and brain-on-subscription cost $0 in API terms.
+    _save_json(USAGE_FILE, u)
+
 
 def _llm_key() -> str:
     return (os.environ.get("AIOS_LLM_API_KEY") or os.environ.get("OPENROUTER_API_KEY")
@@ -230,13 +257,18 @@ def ask_claudecode(message: str, history: list | None = None) -> str:
 def route(target: str, message: str, history: list | None = None) -> str:
     history = history or []
     target = (target or "brain").lower()
+    bump_usage(target)
     if target in ("brain", "aios", "hub"):
         sys = read_system_prompt() or (
                "You are the AIOS Brain — the orchestrator of The AI OS, which unifies six agents: "
                "opencode (coding), hermes (autonomous), openclaw (channels), CrewAI (multi-agent crews), "
                "claude-code (Claude Code API), and LifeOS (shared skills). Be concise and helpful. Suggest "
                "which agent is best for a task. When a visual answer helps (charts, tables, forms, dashboards), "
                "you may emit OpenUI Lang (https://www.openui.com) which the openclaw-os dashboard renders live.")
+        mem = read_memory()
+        if mem:  # shared cross-agent memory — every brain reply knows these facts
+            sys += "\n\nKnown facts / preferences about the user (remember these):\n" + \
+                   "\n".join("- " + str(m) for m in mem[:40])
         return llm_chat(history + [{"role": "user", "content": message}], system=sys)
     if target == "crewai":
         return ask_crewai(message)
@@ -254,6 +286,45 @@ def route(target: str, message: str, history: list | None = None) -> str:
     return f"⚠️ Unknown target '{target}'. Use brain | team | crewai | opencode | claudecode | all."
 
 
+# --------------------------------------------------------------------------- #
+# Unique features: auto-router, arena (A/B), council (consensus), pipeline     #
+# --------------------------------------------------------------------------- #
+def auto_route(message: str, history: list | None = None) -> dict:
+    """Pick the best agent for the message automatically, then answer with it."""
+    sysp = ("Classify which AI OS agent should handle the user's request. Reply with ONLY one word: "
+            "opencode (writing/running code), crewai (multi-step research/workflows), "
+            "claudecode (coding via Claude Code), or brain (general/orchestration). Request:")
+    pick = (llm_chat([{"role": "user", "content": message}], system=sysp) or "brain").strip().lower()
+    pick = next((t for t in ("opencode", "crewai", "claudecode", "brain") if t in pick), "brain")
+    return {"chosen": pick, "reply": route(pick, message, history)}
+
+
+def run_arena(message: str, targets: list, history: list | None = None) -> dict:
+    """Same prompt to 2+ agents/models, side by side, to compare."""
+    return {"results": [{"target": t, "reply": route(t, message, history)} for t in targets[:4]]}
+
+
+def run_council(message: str, targets: list, history: list | None = None) -> dict:
+    """Ask several agents, then synthesize a consensus noting agreement/disagreement."""
+    results = [{"target": t, "reply": route(t, message, history)} for t in targets[:4]]
+    joined = "\n\n".join(f"[{r['target']}]\n{r['reply']}" for r in results)
+    consensus = llm_chat([{"role": "user", "content":
+                           f"Question: {message}\n\nAnswers from the council:\n{joined}\n\n"
+                           "Give one best answer. Note where they agree and flag any disagreement."}],
+                         system="You are the council chair for The AI OS. Be decisive and concise.")
+    return {"results": results, "consensus": consensus}
+
+
+def run_pipeline(message: str, steps: list, history: list | None = None) -> dict:
+    """Chain agents: each step's output feeds the next (research → code → summarize)."""
+    out, cur = [], message
+    for t in steps[:6]:
+        r = route(t, cur, [])
+        out.append({"target": t, "output": r})
+        cur = r
+    return {"steps": out, "final": cur}
+
+
 # --------------------------------------------------------------------------- #
 # "Team" — a single agent that orchestrates the others (the practical merge)   #
 # --------------------------------------------------------------------------- #
@@ -412,6 +483,14 @@ def do_GET(self):
             self._send(200, {"prompt": read_system_prompt()})
         elif self.path == "/api/models":
             self._send(200, fetch_provider_models())
+        elif self.path == "/api/memory":
+            self._send(200, {"memory": read_memory()})
+        elif self.path == "/api/prompts":
+            self._send(200, {"prompts": _load_json(PROMPTS_FILE, [])})
+        elif self.path == "/api/usage":
+            u = _load_json(USAGE_FILE, {})
+            free = u.get("claudecode", 0)
+            self._send(200, {"usage": u, "total": sum(u.values()), "free_requests": free})
         elif self.path in ("/v1/models", "/api/v1/models"):
             # AIOS as an OpenAI-compatible API: its "models" are the chat targets.
             now = int(time.time())
@@ -501,6 +580,40 @@ def do_POST(self):
                          "Pointed at claude-code, but the Claude CLI isn't logged in yet. Run "
                          "`aios claude-login` (or `claude setup-token`) in a terminal to authorize your "
                          "Pro/Max account, then chat.")})
+        elif self.path == "/api/route_auto":
+            self._send(200, auto_route(payload.get("message", ""), payload.get("history", [])))
+        elif self.path == "/api/arena":
+            self._send(200, run_arena(payload.get("message", ""),
+                                      payload.get("targets", ["brain", "claudecode"]),
+                                      payload.get("history", [])))
+        elif self.path == "/api/council":
+            self._send(200, run_council(payload.get("message", ""),
+                                        payload.get("targets", ["brain", "crewai", "claudecode"]),
+                                        payload.get("history", [])))
+        elif self.path == "/api/pipeline":
+            self._send(200, run_pipeline(payload.get("message", ""),
+                                         payload.get("steps", ["crewai", "opencode", "brain"]),
+                                         payload.get("history", [])))
+        elif self.path == "/api/memory":
+            mem = read_memory()
+            op = payload.get("op", "add")
+            if op == "add" and payload.get("text"):
+                mem.append(payload["text"])
+            elif op == "delete":
+                mem = [m for i, m in enumerate(mem) if i != payload.get("index")]
+            elif op == "clear":
+                mem = []
+            _save_json(MEMORY_FILE, mem)
+            self._send(200, {"ok": True, "memory": mem})
+        elif self.path == "/api/prompts":
+            items = _load_json(PROMPTS_FILE, [])
+            op = payload.get("op", "add")
+            if op == "add":
+                items.append({"name": payload.get("name", "prompt"), "text": payload.get("text", "")})
+            elif op == "delete":
+                items = [p for p in items if p.get("name") != payload.get("name")]
+            _save_json(PROMPTS_FILE, items)
+            self._send(200, {"ok": True, "prompts": items})
         elif self.path == "/api/schedules":
             items = load_schedules()
             op = payload.get("op", "add")