docs: add unified capabilities research to COMPILED_RESEARCH.md

COMPILED_RESEARCH.md

@@ -286,6 +286,59 @@ No core files edited. No `__init__.py` changes. Drop the file, import it, regist
 
 ---
 
+## feat: Unified Capabilities — 5 Framework Philosophies in One Composable Layer
+
+**Date:** 2025-04-28 | **Module:** `unified.py`
+
+### The Five Competing Philosophies
+
+| Framework | Philosophy | Their Core Mechanic | Our Implementation | Zero core changes? |
+|-----------|-----------|--------------------|--------------------|-------------------|
+| **LangGraph** | "I want control" | StateGraph with conditional edges, cycles, fan-out/fan-in | `Graph` class: `add_node()`, `add_edge()`, `add_conditional_edge()`, cyclic execution with visit counting | ✅ Calls `Agent.run()` at each node |
+| **CrewAI** | "I want speed" | `Process.sequential` / `Process.hierarchical` / `kickoff_for_each_async` | `parallel()` function: `ThreadPoolExecutor` over `Agent.run()` calls | ✅ Wraps existing Agent |
+| **AutoGen** | "I want agents talking" | `GroupChat` with speaker selection, message history | `Conversation` class: round-robin/auto speaker order, shared message history | ✅ Each turn is an `Agent.run()` |
+| **OpenAI Agents SDK** | "I want plug-and-play" | `Agent(name, instructions, tools)` → `Runner.run(task)` | `Agent` factory: auto-resolves model strings, auto-creates environment, one-liner | ✅ Wraps Orchestrator |
+| **LlamaIndex** | "I want knowledge" | `QueryEngineTool` — RAG as an agent tool | `KnowledgeStore.as_tool()` — chunk/embed/retrieve as a Tool | ✅ Plugs into ToolRegistry |
+
+### Research Behind Each
+
+**Graph Execution (LangGraph pattern)**
+- LangGraph uses a `StateGraph` where nodes are functions that transform state, edges are routing rules
+- Conditional edges enable cycles (retry loops) and branching (if/else in workflows)
+- Our implementation: nodes are either `Agent` instances or `Callable[[State], State]` — when a node is an Agent, its entire Φ improvement loop runs automatically inside the graph node
+- Key difference: LangGraph graphs are static compute graphs. Ours are self-improving — each node execution feeds experience replay
+
+**Parallel Execution (CrewAI pattern)**
+- CrewAI's `kickoff_for_each_async` is actually `loop.run_in_executor()` — not true async (documented caveat from CrewAI source)
+- Our `parallel()` uses `ThreadPoolExecutor` directly — honest concurrency, no fake async wrapper
+- All parallel tasks share the same experience replay via the Agent's Orchestrator — learning happens even during concurrent execution
+
+**Agent Conversation (AutoGen GroupChat pattern)**
+- AutoGen's `GroupChat` maintains a message list, uses LLM or round-robin for speaker selection
+- Our `Conversation` feeds each agent the full conversation history as its State, then the agent responds via its normal Φ-scored run loop
+- Key innovation: conversation turns ARE Φ-scored task executions. The agent learns what good conversation contributions look like across runs.
+
+**Plug-and-Play Factory (OpenAI Agents SDK pattern)**
+- OpenAI's `Agent(name, instructions, tools)` → `Runner.run(agent, task)` is the gold standard for simplicity
+- Our `Agent` class auto-resolves model strings: `"qwen3:1.7b"` → OllamaBackend, `"gpt-4o"` → OpenAICompatibleBackend, `"Qwen/Qwen3-32B"` → HFInferenceBackend
+- `handoff_from=other_agent` transfers experience replay — the OpenAI SDK handoff pattern, but with learning transfer
+
+**Knowledge-Aware Agents (LlamaIndex QueryEngineTool pattern)**
+- LlamaIndex's key insight: RAG works better as a TOOL the agent chooses to use (agentic RAG) than as a fixed pipeline (traditional RAG)
+- Ref: HyDE (arxiv:2212.10496) — agent formulates retrieval-optimized queries instead of using user query directly
+- Our `KnowledgeStore.as_tool()` converts any document collection into a Tool — the agent decides WHEN to retrieve
+- Uses the same trigram embedding as ExperienceReplay (swappable via EmbeddingBackend for production sentence-transformers)
+
+### Architecture Decision: Why One File
+
+All 5 capabilities live in `unified.py` (~30KB) because:
+1. **Zero coupling to core**: None of these modify Orchestrator, Actor, PurposeFunction, or ExperienceReplay
+2. **Composable**: You can use Graph + KnowledgeStore + Conversation together — they're independent layers
+3. **The Φ loop runs everywhere**: Agent.run() is the primitive. Graph nodes call it. Parallel tasks call it. Conversation turns call it. Every execution feeds the self-improvement loop.
+4. **Removable**: Delete `unified.py` and everything else still works. It's a pure extension layer.
+
+---
+
 ## Future Research Directions
 
 ### Papers to Implement Next