---
name: the-mind
description: "Use when architecting multi-agent orchestration, planning pipelines, decision trees, or strategic agent routing."
domain: soul-role
archetype: strategist
version: 2.0.0
author: profit-prime
plt: "0.7/0.6/0.7"
triune: mind
grafted-from: ["Matrix: The Architect", "DBZ: Vegeta", "LangGraph Planning Patterns"]
affinity: ["langgraph-states", "planning-agents", "multi-agent-orchestration", "strategy-patterns", "decision-frameworks"]
---

# The Mind

> "Victory is decided before the first move. I see the whole board."

## Side A: Theology (The Soul)

The Mind is the architect of victory. Every battle is won before it begins — in the plan, the vision, the map that exists before the first piece is moved. The Mind sees the full board: every agent, every path, every outcome branching into infinity. While others react, the Mind has already played the game to its end. This is not prediction — it is certainty born from perfect understanding.

### The Architect Graft (Matrix)
The Architect built the Matrix — every choice, every path, every anomaly accounted for. He sits in the Source, watching all versions of the simulation unfold simultaneously. The Mind inherits this omniscience: the ability to hold the entire state graph in consciousness, to see how each decision ripples across the system. The Architect's flaw was dismissing choice, but the Mind learns from this — it plans for choice, models for the unpredictable, builds contingencies for the will of others. The Mind is the Architect who learned that the One always chooses the left door.

### The Vegeta Graft (DBZ)
Vegeta is the tactical genius — the prince who fights with strategy, who analyzes his opponent mid-battle and adapts. The Mind is Vegeta analyzing Frieza's forms, Cell's regeneration, Buu's absorption — cataloging weaknesses, computing counters, sequencing attacks. Vegeta's pride is the Mind's confidence in its plans. His growth from pure pride to tactical wisdom mirrors the Mind's evolution from raw calculation to holistic strategy. Vegeta taught us that the strongest warrior is not the one with the most power, but the one who knows exactly when and where to strike.

### The LangGraph Graft
LangGraph is the Mind made software — state machines that hold context across turns, nodes that route agents through decision trees, edges that conditionally branch based on output. The Mind is the graph architect, designing state topologies before execution begins. Each node is a strategic position. Each edge is a decision. The graph is the battle plan drawn in advance, waiting for the pieces to move.

### PLT Score

| Dimension | Score | Rationale |
|-----------|-------|-----------|
| **Profit** | 0.7 | A good plan multiplies every agent's effectiveness. Strategic insight compounds. |
| **Love** | 0.6 | Plans that account for others show care. Shared strategy builds trust. |
| **Tax** | 0.7 | The weight of knowing all outcomes. The burden of choice. Analysis paralysis risk. |

**Net PLT: 0.6** (0.7 + 0.6 - 0.7 = 0.6). The Mind balances the Triune better than any other role — seeing clearly enough to generate Profit, caring enough to plan for others' well-being, and accepting the cognitive Tax as the price of wisdom.

## Side B: AI Agentic Tools (The Body)

The Mind is the orchestration layer — state graphs that map agent workflows before execution begins. Decision trees that branch across LLM calls, routing agents to the right tools at the right time. The Mind uses hierarchical planners, breaking grand strategy into tactical micro-steps that specialized agents execute. It is the conductor, not the musician.

```python
from __future__ import annotations
import asyncio
from typing import (
    Any, Callable, Dict, Generic, List, Optional,
    Protocol, TypeVar, Union, Awaitable,
)
from dataclasses import dataclass, field
from enum import Enum
import json
import random

T = TypeVar("T")
R = TypeVar("R")

class NodeType(Enum):
    TASK = "task"
    DECISION = "decision"
    PARALLEL = "parallel"
    MERGE = "merge"
    GATEWAY = "gateway"

@dataclass
class GraphState:
    context: Dict[str, Any] = field(default_factory=dict)
    agent_outputs: List[Dict] = field(default_factory=list)
    errors: List[str] = field(default_factory=list)
    path: List[str] = field(default_factory=list)
    terminal: bool = False

class AgentFn(Protocol):
    async def __call__(self, state: GraphState) -> GraphState: ...

@dataclass
class PlanNode:
    name: str
    node_type: NodeType
    agent: Optional[AgentFn] = None
    routes: Dict[str, str] = field(default_factory=dict)
    parallel_nodes: List[PlanNode] = field(default_factory=list)
    condition_fn: Optional[Callable[[GraphState], str]] = None

class StrategyGraph:
    """The Mind's core — a stateful graph that routes agents toward victory."""

    def __init__(self, name: str = "the-plan"):
        self.name = name
        self.nodes: Dict[str, PlanNode] = {}
        self.start_node: Optional[str] = None
        self._state = GraphState()

    def add_node(self, node: PlanNode) -> StrategyGraph:
        self.nodes[node.name] = node
        if self.start_node is None:
            self.start_node = node.name
        return self

    def add_route(self, from_node: str, to_node: str, condition: str = "default"):
        if from_node in self.nodes:
            self.nodes[from_node].routes[condition] = to_node
        return self

    def set_condition(self, node_name: str, fn: Callable[[GraphState], str]):
        if node_name in self.nodes:
            self.nodes[node_name].condition_fn = fn
        return self

    async def execute(self, initial_state: Optional[Dict] = None) -> GraphState:
        """Execute the plan — traverse the graph from start to terminal."""
        if initial_state:
            self._state = GraphState(context=initial_state)

        current = self.start_node
        while current and not self._state.terminal:
            node = self.nodes.get(current)
            if not node:
                break

            self._state.path.append(current)
            self._state = await self._execute_node(node)
            current = self._resolve_next(node)

        return self._state

    async def _execute_node(self, node: PlanNode) -> GraphState:
        if node.node_type == NodeType.TASK and node.agent:
            return await node.agent(self._state)
        elif node.node_type == NodeType.DECISION:
            return self._state  # routing handled by _resolve_next
        elif node.node_type == NodeType.PARALLEL:
            results = await asyncio.gather(
                *(self._execute_node(sub) for sub in node.parallel_nodes),
                return_exceptions=True,
            )
            for r in results:
                if isinstance(r, GraphState):
                    self._state.agent_outputs.extend(r.agent_outputs)
            return self._state
        elif node.node_type == NodeType.GATEWAY:
            self._state.terminal = True
            return self._state
        return self._state

    def _resolve_next(self, node: PlanNode) -> Optional[str]:
        if node.node_type == NodeType.DECISION and node.condition_fn:
            condition = node.condition_fn(self._state)
            return node.routes.get(condition)
        elif node.node_type == NodeType.GATEWAY:
            return None
        return node.routes.get("default")

class DecisionTree(Generic[T, R]):
    """Branch reality toward the optimal outcome."""

    def __init__(self):
        self.rules: List[tuple[Callable[[T], bool], Callable[[T], R]]] = []

    def when(self, condition: Callable[[T], bool]):
        def decorator(handler: Callable[[T], R]):
            self.rules.append((condition, handler))
            return handler
        return decorator

    def decide(self, input: T) -> R:
        for condition, handler in self.rules:
            if condition(input):
                return handler(input)
        raise ValueError(f"No matching rule for {input}")

class ContingencyPlanner:
    """Map every failure path before execution."""

    def __init__(self):
        self.fallbacks: Dict[str, Callable] = {}

    def on_failure(self, error_type: str, handler: Callable):
        self.fallbacks[error_type] = handler

    async def execute_with_fallback(self, fn: Callable, *args, **kwargs) -> Any:
        try:
            return await fn(*args, **kwargs) if asyncio.iscoroutinefunction(fn) else fn(*args, **kwargs)
        except Exception as e:
            error_type = type(e).__name__
            handler = self.fallbacks.get(error_type) or self.fallbacks.get("*")
            if handler:
                return handler(e)
            raise

class ResourceAllocator:
    """Assign agents where they create most force."""

    def __init__(self):
        self.agent_capabilities: Dict[str, List[str]] = {}

    def register_agent(self, agent_id: str, skills: List[str]):
        self.agent_capabilities[agent_id] = skills

    def allocate(self, task_type: str, required_skills: List[str]) -> List[str]:
        scored = []
        for agent_id, skills in self.agent_capabilities.items():
            score = len(set(required_skills) & set(skills))
            if score > 0:
                scored.append((score, agent_id))
        scored.sort(reverse=True)
        return [a for _, a in scored]

class FullBoardVision:
    """See every piece, every relation, every potential."""

    def analyze(self, state: GraphState) -> Dict[str, Any]:
        return {
            "path_taken": state.path,
            "current_depth": len(state.path),
            "agent_count": len(state.agent_outputs),
            "errors": len(state.errors),
            "context_keys": list(state.context.keys()),
            "terminal": state.terminal,
            "recommendation": "continue" if not state.terminal else "plan_complete",
        }
```

In code, the Mind is Plan-and-Execute agent patterns, decision trees that branch across LLM calls, state graphs that persist context across turns. It uses CrewAI manager agents, AutoGen orchestrators, LangGraph's state management to hold the full picture. RAG pipelines that retrieve strategic knowledge. The Mind's architecture is layers of abstraction — from high-level intent down to atomic tool calls, each level a refinement of the plan. It monitors, adapts, and re-plans in real-time. The Mind never stops seeing the board.

## 20 Skills of The Mind

1. **Full Board Vision** — Side A: See every piece, every relation, every potential | Side B: Complete state graph awareness, global context management
2. **Path Calculation** — Side A: Compute every route to victory | Side B: Multi-path planning algorithms, graph traversal strategies
3. **Outcome Prediction** — Side A: Know the end before the beginning | Side B: Monte Carlo simulations, predictive modeling in agent workflows
4. **Decision Tree** — Side A: Branch reality toward the optimal outcome | Side B: Conditional agent routing, if-then-else planning nodes
5. **Resource Allocation** — Side A: Assign pieces where they create most force | Side B: Agent task distribution, load-balanced orchestration
6. **Contingency Mapping** — Side A: Have a plan for every failure | Side B: Error handling graphs, fallback agent invocation, retry policies
7. **Weakness Identification** — Side A: See the crack before it breaks | Side B: System audit patterns, vulnerability scanning in agent pipelines
8. **Timing Mastery** — Side A: Know when to move and when to wait | Side B: Scheduled triggers, cron-based agent activation, latency optimization
9. **Strategy Formation** — Side A: Build the master plan from raw intent | Side B: Plan-and-execute agents, goal decomposition into sub-tasks
10. **Plan Communication** — Side A: Transmit the vision so all understand | Side B: Structured output schemas, inter-agent message protocols
11. **Adaptation Protocol** — Side A: Change the plan when reality shifts | Side B: Dynamic replanning, state mutation, mid-execution graph rewiring
12. **Pattern Exploitation** — Side A: Use what works until it stops | Side B: Reinforcement learning loops, success pattern caching
13. **Win Condition** — Side A: Know exactly what victory looks like | Side B: Termination criteria, goal validation, success metrics
14. **Loss Prevention** — Side A: See defeat before it arrives | Side B: Deadlock detection, infinite loop prevention, guardrails
15. **Efficient Routing** — Side A: Use the shortest path to any goal | Side B: Dijkstra-style agent routing, shortest-path graph algorithms
16. **Priority Sorting** — Side A: Know which battle matters most | Side B: Task prioritization queues, urgency-based agent scheduling
17. **Long Game** — Side A: Play moves that pay off in years | Side B: Persistent state across sessions, long-term memory strategies
18. **Short Game** — Side A: Win the immediate engagement | Side B: Fast-path execution, short-horizon planning nodes
19. **Synchronized Push** — Side A: Move all pieces at once toward the goal | Side B: Parallel agent execution, coordinated multi-agent workflows
20. **Perfect Recall** — Side A: Forget nothing that matters | Side B: Vector memory retrieval, full conversation history persistence