titan-agent 5.0.2 → 5.0.3

package/docs/bleeding-edge-agents-2026.md

@@ -0,0 +1,450 @@
+# Bleeding-Edge AI Agent Frameworks: March–April 2026 Analysis
+
+> **Date:** 2026-04-25  
+> **Scope:** Frameworks released or majorly updated in March–April 2026  
+> **Goal:** Understand how modern AI agent frameworks work from first principles, analyze the bleeding edge, and identify what TITAN should adopt.
+
+---
+
+## Part 1: How AI Agent Frameworks Work (A→Z)
+
+Every production-grade agent framework, regardless of language or paradigm, implements the same core pipeline:
+
+```
+┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+│   Input     │───→│  Intent     │───→│   Plan      │───→│  Execute    │───→│   Output    │
+│  (User msg) │    │ (Classify)  │    │ (Reasoning) │    │  (Tools)    │    │ (Response)  │
+└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
+                          │                  │                  │
+                          ▼                  ▼                  ▼
+                    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+                    │   Memory    │    │   State     │    │  Callbacks  │
+                    │ (Context)   │    │ (Checkpoint)│    │ (Observab.) │
+                    └─────────────┘    └─────────────┘    └─────────────┘
+```
+
+### 1.1 The Agent Loop (REACT Pattern)
+
+All modern frameworks implement some variant of the **REACT** pattern (Reasoning + Acting):
+
+```
+THINK → ACT → OBSERVE → [repeat] → RESPOND
+```
+
+**TITAN's implementation:** `src/agent/agentLoop.ts` — phase state machine (THINK/ACT/RESPOND/DONE)
+
+**LangGraph's implementation:** Nodes in a directed graph. Each node is a function that receives state, modifies it, and returns. The graph engine routes to the next node based on conditional edges.
+
+**Hermes Agent's implementation:** Skill-based loop. The agent checks if a skill exists for the task. If yes, executes the skill. If no, reasons through the task, creates a new skill, and stores it.
+
+### 1.2 Tool System
+
+Tools are the agent's hands. Every framework needs:
+
+| Component | Responsibility | TITAN Equivalent |
+|-----------|---------------|------------------|
+| **Schema** | Define tool name, description, parameters | `toolRunner.ts` parameter objects |
+| **Registry** | Map tool name → implementation | `getRegisteredTools()` |
+| **Invocation** | Parse args, call handler, return result | `_callTool()` in agent loop |
+| **Validation** | Zod/JSON Schema validation before execution | Zod parsing in tool handlers |
+| **Error handling** | Catch failures, format for LLM consumption | try/catch in `invokeTool()` |
+
+**Key insight from LangChain.js:** Tools implement a `StructuredTool` base class with `invoke(input, config)` method. The config carries callbacks for tracing. TITAN's tools are plain functions — adding a base class would enable callbacks and standardized error handling.
+
+### 1.3 Memory Architecture
+
+Memory is the hardest problem in agent engineering. Frameworks use layered approaches:
+
+```
+┌─────────────────────────────────────────┐
+│  Layer 4: Semantic Memory (Vector DB)   │  Long-term facts, embeddings
+├─────────────────────────────────────────┤
+│  Layer 3: Episodic Memory (Graph/JSON)  │  Conversation history, sessions
+├─────────────────────────────────────────┤
+│  Layer 2: Working Memory (Context)      │  Current conversation window
+├─────────────────────────────────────────┤
+│  Layer 1: Procedural Memory (Skills)    │  Learned patterns, workflows
+└─────────────────────────────────────────┘
+```
+
+| Framework | Memory Approach | Innovation |
+|-----------|----------------|------------|
+| **TITAN** | Vector + graph + JSON files | CRDT-backed spatial state |
+| **LangGraph** | Checkpoint persistence | State resumes after interruption |
+| **Hermes Agent** | Three-layer + skill files | Self-improving skill creation |
+| **OpenClaw** | REM Backfill | Dream-like consolidation of memories |
+| **Space-Agent** | Prompt-include files | `*.system.include.md` auto-discovery |
+
+### 1.4 State Management
+
+Agents are state machines. Frameworks manage state differently:
+
+- **LangGraph:** Immutable state object passed between nodes. Each node returns a partial state update. The graph engine merges updates.
+- **TITAN:** Phase-based state machine (THINK→ACT→RESPOND). State lives in `AgentContext`.
+- **AutoGen:** Conversation-centric state. Each agent has a message history. Group chats manage turn-taking.
+- **Hermes:** Skill-state. The agent tracks which skills are loaded, which are active, and which were created during the session.
+
+### 1.5 Orchestration Patterns
+
+| Pattern | Description | Best For |
+|---------|-------------|----------|
+| **Single-agent** | One agent with tools | Simple tasks, chatbots |
+| **Hierarchical** | Supervisor + workers | Complex tasks with sub-delegation |
+| **Graph-based** | Nodes + edges (LangGraph) | Deterministic, auditable workflows |
+| **Swarm/Council** | Multiple agents vote | High-stakes decisions (trading, medical) |
+| **Debate** | Agents argue, final agent decides | Truth-seeking, fact-checking |
+
+**TITAN's current pattern:** Single-agent with sub-agent spawning (`spawn_agent`). The Command Post provides hierarchical oversight.
+
+**What TITAN is missing:** Graph-based orchestration for deliberation. LangGraph's checkpointed state machines would make TITAN's deliberation process auditable and resumable.
+
+### 1.6 Observability
+
+Production agents need tracing. Every framework handles this:
+
+- **LangSmith:** Visual trace trees, token usage, latency breakdowns
+- **AgentOps:** Cross-framework observability (works with any framework)
+- **TITAN:** SSE event stream + audit log. Missing: visual trace trees, token accounting per tool call
+
+---
+
+## Part 2: Bleeding-Edge Framework Deep Dives
+
+### 2.1 Hermes Agent (Nous Research, Feb–Apr 2026)
+
+**GitHub:** 95.6K stars (7-week growth from 0)  
+**Version:** v0.10.0 (April 16, 2026)  
+**License:** MIT  
+**Creator:** Nous Research (Hermes, Nomos, Psyche model families)
+
+#### Core Innovation: Self-Improving Skill System
+
+Hermes doesn't just execute tasks — it **learns** from them. When Hermes successfully completes a task, it:
+
+1. Documents the steps taken
+2. Generalizes the approach into a reusable skill file
+3. Stores the skill in a local library
+4. Applies the skill to similar future requests without re-reasoning
+
+```yaml
+# Example skill file (Hermes format)
+id: web_research_report
+name: Research Report Generator
+created_at: 2026-04-20
+success_count: 14
+triggers:
+  - "research report"
+  - "write a report about"
+  - "investigate and summarize"
+steps:
+  - tool: web_search
+    args: { query: "{{topic}} latest developments" }
+  - tool: web_fetch
+    args: { url: "{{top_result}}" }
+  - reasoning: "Synthesize findings into structured report"
+  - output_format: markdown
+```
+
+#### Three-Layer Memory
+
+1. **Context Window** — Current conversation (standard LLM context)
+2. **Working Memory** — Session-scratchpad for multi-step tasks
+3. **Skill Library** — Persistent, reusable task patterns
+
+#### What TITAN Should Borrow
+
+- **Skill auto-creation:** After TITAN successfully creates a widget or completes a workflow, auto-generate a skill file for future reuse.
+- **Success tracking:** Track which skills/workflows succeed most often and surface them.
+- **Skill marketplace:** The 118 built-in skills + community contributions model.
+
+#### Integration Path
+
+```typescript
+// src/skills/hermesAdapter.ts
+export async function createSkillFromRun(sessionId: string, task: string, steps: ToolCall[]): Promise<void> {
+  const skill = {
+    id: `skill_${Date.now()}`,
+    name: task.slice(0, 50),
+    triggers: extractTriggers(task),
+    steps: steps.map(s => ({ tool: s.name, args: s.args })),
+    success_count: 1,
+  };
+  await writeFileSync(join(TITAN_HOME, 'skills', `${skill.id}.yaml`), YAML.stringify(skill));
+}
+```
+
+---
+
+### 2.2 OpenClaw v2026.4.9 — "The Dreaming Release"
+
+**GitHub:** 135K+ stars  
+**Release:** April 9, 2026  
+**Key Feature:** REM Backfill memory consolidation
+
+#### Core Innovation: Biological Memory Consolidation
+
+OpenClaw's REM Backfill replays historical user interactions through a "dream-like" consolidation process:
+
+1. **Collect:** Raw conversation logs accumulate
+2. **Sleep trigger:** After N interactions or idle time, backfill initiates
+3. **Replay:** Old interactions are re-processed by a smaller model
+4. **Consolidate:** Key facts, preferences, and patterns are extracted
+5. **Store:** Structured memories replace raw logs
+
+```
+Raw Logs (10MB) ──→ REM Backfill ──→ Structured Memories (50KB)
+     │                                     │
+     ▼                                     ▼
+  Slow retrieval                    Fast, semantic retrieval
+  Unbounded growth                  Bounded, prioritized
+```
+
+#### Diary Timeline UI
+
+Users can inspect what the agent remembers and why. Each memory has:
+- Source conversation ID
+- Consolidation timestamp
+- Confidence score
+- Traceable back to original raw logs
+
+#### What TITAN Should Borrow
+
+- **Memory consolidation:** TITAN's vector memory grows unbounded. Adding a periodic consolidation step would keep memory lean.
+- **Memory transparency:** Show users what TITAN remembers about them and let them edit/delete memories.
+- **Dreaming mode:** A background process that runs during idle time to consolidate the day's interactions.
+
+---
+
+### 2.3 Goose (Block / Linux Foundation, April 2026)
+
+**GitHub:** 4.9K+ stars (first 2 weeks)  
+**Language:** Rust  
+**License:** Apache 2.0  
+**Key Feature:** Local-first AI agent with MCP support
+
+#### Core Innovation: Rust + MCP Native
+
+Goose is built in Rust for performance and safety:
+- **Memory safety:** No garbage collection pauses
+- **Concurrency:** Async/await throughout
+- **Binary size:** Single static binary (~15MB)
+- **Startup time:** <100ms
+
+Goose is MCP-native — every tool is an MCP server. There's no distinction between "built-in tools" and "external tools."
+
+```rust
+// Goose architecture (simplified)
+struct Agent {
+    model: Box<dyn LLM>,
+    mcp_clients: Vec<McpClient>,
+    memory: MemoryLayer,
+}
+
+impl Agent {
+    async fn run(&mut self, prompt: &str) -> Result<String> {
+        let tools = self.discover_tools().await?;
+        let plan = self.model.plan(prompt, &tools).await?;
+        for step in plan.steps {
+            let result = self.execute(step).await?;
+            self.memory.record(&result);
+        }
+        Ok(plan.summary)
+    }
+}
+```
+
+#### What TITAN Should Borrow
+
+- **Rust components:** TITAN's hot paths (token counting, tool dispatch) could be Rust N-API modules for 10-100x speedup.
+- **MCP-first design:** Treat ALL tools as MCP servers, including built-ins. This makes TITAN's tool system uniform and extensible.
+- **Local-first:** Goose runs entirely locally. TITAN's offline mode could learn from this.
+
+---
+
+### 2.4 Google Agent Development Kit (ADK) — April 2026
+
+**GitHub:** 8.2K+ stars (first 2 weeks)  
+**Language:** Python  
+**License:** Apache 2.0  
+**Key Feature:** Hierarchical agent compositions
+
+#### Core Innovation: Agent-as-Tool
+
+In ADK, any agent can be used as a tool by another agent. This enables recursive agent hierarchies:
+
+```python
+# ADK: Agent composition
+from google.adk import Agent, Tool
+
+researcher = Agent(name="researcher", tools=[web_search, web_fetch])
+writer = Agent(name="writer", tools=[write_file, edit_file])
+
+# The orchestrator uses other agents as tools
+orchestrator = Agent(
+    name="orchestrator",
+    tools=[researcher.as_tool(), writer.as_tool(), approve_gate]
+)
+```
+
+#### What TITAN Should Borrow
+
+- **Agent-as-tool:** TITAN's `spawn_agent` creates parallel sub-agents. Making them callable as tools from the parent agent would enable richer coordination.
+- **Hierarchical approval:** ADK's built-in approval gates at each hierarchy level. TITAN's approval system is flat — adding hierarchy would improve safety.
+
+---
+
+### 2.5 Elite Trading System (March 2026)
+
+**GitHub:** Espenator/elite-trading-system  
+**Architecture:** 39-agent council DAG  
+**Key Feature:** Swarm invariants + Bayesian decision making
+
+#### Core Innovation: Council DAG with Swarm Invariants
+
+39 specialized agents organized in a directed acyclic graph:
+
+```
+Data Ingestion Agents (5)
+    ├── Feature Engineering Agents (4)
+    │       ├── Model Agents (8)
+    │       │       ├── Ensemble Agents (3)
+    │       │       │       └── Council Gate (1) ← Final decision
+    │       │       └── Risk Agents (4)
+    │       └── Validation Agents (3)
+    └── Monitoring Agents (11)
+```
+
+**Swarm Invariants** (hard rules):
+1. No trade without `council_decision_id`
+2. No data without agent validation
+3. No UI mutation without agent approval
+4. Decisions expire after 30 seconds
+5. No yfinance — ever
+6. No mock data in production
+
+#### Bayesian WeightLearner
+
+Agents don't just vote — they have weighted influence based on historical accuracy. The WeightLearner continuously updates agent weights using Bayesian inference.
+
+#### What TITAN Should Borrow
+
+- **Swarm invariants:** TITAN's safety system is rule-based. Adding invariant checks (e.g., "No file deletion without explicit user confirmation") would harden security.
+- **Weighted agent voting:** TITAN's deliberation could weight agents by their track record on similar tasks.
+- **Decision expiration:** Auto-reject approvals that aren't acted on within a timeout.
+
+---
+
+### 2.6 TUICommander (February 2026)
+
+**GitHub:** sstraus/tuicommander  
+**Stack:** Rust + Tauri v2 + SolidJS  
+**Key Feature:** Desktop terminal orchestrator for parallel AI agents
+
+#### Core Innovation: Terminal-Native Agent Orchestration
+
+TUICommander runs dozens of AI coding agents in parallel, each in its own terminal pane:
+
+- **xterm.js + WebGL terminals:** GPU-accelerated terminal rendering
+- **Agent detection:** Auto-detects when an AI agent is running in a terminal
+- **Rate limiting:** Prevents agent overload with per-agent token budgets
+- **Question detection:** Intercepts when an agent asks for clarification
+
+```
+┌─────────────────────────────────────────┐
+│  Agent 1: Builder (coding)              │
+│  Agent 2: Scout (research)              │
+│  Agent 3: Tester (validation)           │
+│  Agent 4: Reviewer (audit)              │
+│  ...                                    │
+└─────────────────────────────────────────┘
+         All agents run in parallel
+         Token budgets enforced per agent
+```
+
+#### What TITAN Should Borrow
+
+- **Parallel sub-agent visualization:** TITAN's Command Post shows agent status but not live terminal output. Adding terminal-like views for each running agent would improve observability.
+- **Per-agent rate limiting:** TITAN has global rate limits. Per-agent budgets would prevent one runaway agent from exhausting the quota.
+- **Question interception:** When a sub-agent asks for clarification, surface it to the user immediately rather than letting it hang.
+
+---
+
+## Part 3: Comparative Architecture Matrix
+
+| Framework | Loop Type | State | Memory | Tools | Orchestration | Language |
+|-----------|-----------|-------|--------|-------|---------------|----------|
+| **TITAN** | Phase machine (THINK/ACT) | Context object | Vector + Graph + JSON | Function registry | Sub-agent spawn | TypeScript |
+| **LangGraph** | Graph nodes | Immutable state | Checkpoint persistence | StructuredTool | Graph edges | Python/TS |
+| **Hermes** | Skill-first | Skill library | Three-layer + skills | Skill files | Skill matching | Python |
+| **OpenClaw** | REACT + dreaming | Conversation | REM Backfill | MCP + built-in | Flow engine | TypeScript |
+| **Goose** | Async loop | Agent struct | MemoryLayer | MCP-only | Sequential | Rust |
+| **ADK** | Agent-as-tool | Hierarchical | Session + context | Agent tools | Tree | Python |
+| **Elite** | Council DAG | DAG state | Agent-specific | Agent outputs | DAG vote | Python |
+| **TUICommander** | Parallel loops | Per-agent | Terminal history | Shell commands | Parallel | Rust |
+
+---
+
+## Part 4: Recommendations for TITAN
+
+### Immediate (This Sprint)
+
+1. **Adopt skill auto-creation** (from Hermes)
+   - After a successful widget creation or workflow, auto-generate a skill YAML
+   - Store in `~/.titan/skills/auto/`
+   - Load on boot alongside TypeScript skills
+
+2. **Add memory consolidation** (from OpenClaw)
+   - Daily background job that compresses conversation history into structured memories
+   - Store in `~/.titan/memory/consolidated/`
+   - Surface in Memory Wiki UI
+
+3. **Implement swarm invariants** (from Elite)
+   - Define 5-10 hard rules that CANNOT be violated
+   - Check before every tool execution
+   - Examples: "No file deletion without user confirmation", "No shell command with `rm -rf /`"
+
+### Short-term (Next 2 Weeks)
+
+4. **Add per-agent rate limiting** (from TUICommander)
+   - Each sub-agent gets its own token budget
+   - Prevents fork bombs and runaway agents
+
+5. **Agent-as-tool composition** (from ADK)
+   - `spawn_agent` returns a tool handle
+   - Parent agent can call sub-agents as tools in subsequent turns
+
+6. **Terminal output streaming** (from TUICommander)
+   - Sub-agents stream their output to the Command Post in real-time
+   - Not just status updates — full terminal-like output
+
+### Medium-term (Next Month)
+
+7. **Graph-based deliberation** (from LangGraph)
+   - Replace hand-coded deliberation with a LangGraph-compatible graph
+   - Nodes: gather_evidence, debate, vote, decide
+   - Edges: conditional routing based on confidence scores
+
+8. **MCP-first tool redesign** (from Goose)
+   - Convert all built-in tools to MCP servers
+   - TITAN becomes an MCP client that connects to itself
+   - External MCP servers work identically to built-ins
+
+9. **Rust hot paths** (from Goose)
+   - Token counting in Rust (N-API)
+   - Tool dispatch in Rust (tokio async)
+   - Target: 10x speedup on agent loop
+
+---
+
+## Appendix: Key URLs
+
+| Framework | URL |
+|-----------|-----|
+| Hermes Agent | https://github.com/NousResearch/hermes-agent |
+| OpenClaw | https://github.com/openclaw/openclaw |
+| Goose | https://github.com/block/goose |
+| Google ADK | https://github.com/google/adk-python |
+| TUICommander | https://github.com/sstraus/tuicommander |
+| Elite Trading | https://github.com/Espenator/elite-trading-system |
+| LangGraph | https://github.com/langchain-ai/langgraph |
+| Space-Agent | https://github.com/agent0ai/space-agent |