Core idea: systems that regulate themselves through feedback loops.
Design takeaway: Every node is either a sensor, controller, or effector. Missing any breaks the feedback loop.
Core idea: different problem domains need different response strategies.
Design takeaway: Input node IS the Cynefin classifier. Different domains = different graph paths.
Core idea: capability emerges from the network, not individual actors.
Design takeaway: The graph IS the intelligence. Nodes are replaceable. Edges are where meaning happens.
Like a webcam node in TouchDesigner. Always on, emits when something happens.
Like filter/transform nodes in Max/MSP. Shape the signal.
Like output nodes in Unreal Blueprints. Make something happen in the world.
Memory nodes are unique: they're called BY other nodes, not just wired in sequence. They're shared state — the "blackboard" in classic AI.
Key insight: like node-based visual programming, the graph runs continuously. Sensors fire, signals propagate, effectors act. The chat is just ONE sensor. Timer events, webhooks, system probes — all feed the same graph.
| # | Use Case | Tests | Nodes Needed | Phase |
|---|---|---|---|---|
| 1 | Greeting — "hey!" | Input classifies casual, Output responds warmly. Verify command + context visible in panels. | Input Output | NOW |
| 2 | Technical question — "how does asyncio.Queue work?" | Input classifies knowledge-needed. Output gives detailed answer. Context panel shows history growth. | Input Output | NOW |
| 3 | Multi-turn follow-up — ask, then "tell me more" | Input sees follow-up pattern. Output uses history for continuity. Watch context grow in both panels. | Input Output | NOW |
| 4 | Tone shift — friendly then frustrated "this is broken!" | Input detects tone change, adjusts command. Output shifts from casual to empathetic/helpful. | Input Output | NOW |
| 5 | Memory persistence — "my name is Nico" ... later ... "what's my name?" | Memorizer stores user fact. On later question, provides context to Thinker. Output answers correctly. | Input Memorizer Output | NEXT |
| 6 | Background monitoring — "watch CPU load, alert if >80%" | Timer/SystemProbe sensor fires periodically. Input classifies as monitoring. Feedback emits to UI without chat message. | Timer SystemProbe Feedback | LATER |
| 7 | System unresponsive — LLM takes 30s+ | Feedback node shows "thinking..." immediately. Timeout handling. User sees activity, not silence. | Input Feedback Output | NEXT |
| 8 | Cynefin: Clear domain — "what's 2+2?" | Input classifies as Clear, skips Thinker, routes directly to Output. Faster response, cheaper. | Input Router Output | LATER |
| 9 | Topic tracking — conversation covers 3 topics, user says "back to the first thing" | TopicTracker accumulates topics. UI shows topic list. User can click to refocus. Memorizer provides relevant context. | TopicTracker Memorizer UI | LATER |
| 10 | UI action — button in top bar triggers "summarize this conversation" | Non-chat input (button click) enters the graph as a sensor event. Input classifies, routes to Thinker+Memorizer. Output renders summary. | UI Sensor Thinker Memorizer | LATER |
Validates: Two-node communication works. LLM-to-LLM command passing. Context isolation visible. Streaming through graph.
Test cases: #1-4 (greeting, technical, follow-up, tone shift)
Success = You can see Input's reasoning and Output's execution as separate contexts. The command is meaningful, not just pass-through.
Validates: Non-LLM nodes in the graph. Real-time status. Parallel event emission (HUD fires while Output streams).
Test cases: #7 (unresponsive system — user sees "thinking..." not silence)
Success = User always sees activity within 200ms. Feedback panel in the UI shows event timeline.
Validates: Persistent state across the graph. Node-to-node context requests (Thinker asks Memorizer for context). Three LLM calls per turn, each with different context.
Test cases: #5 (memory persistence — "what's my name?")
Success = Conversation survives page reload. Memorizer panel shows what it stores vs what it provides.
Validates: The graph runs without user input. Sensor-driven processing. Background monitoring. The system is ALIVE, not just reactive.
Test cases: #6 (background CPU monitoring)
Success = UI shows activity without chat. Alerts appear. The graph is a living system, not a request/response pipe.
Validates: Multi-path graph. Input classifies domain, routes differently. Clear = fast path (skip Thinker). Complex = deep path (Thinker + tools + Memorizer). The graph adapts to the problem.
Test cases: #8 (Clear domain — fast path)
Success = Simple questions are 3x faster. Complex questions get deeper treatment. Visible in the graph view.
Validates: The graph doesn't just do chat. Non-chat inputs (buttons, lists) enter the graph. Non-chat outputs (topic sidebar, action bar) exit the graph. Full cybernetic loop with rich UI.
Test cases: #9 (topic tracking), #10 (UI button triggers graph)
Success = The agent is a workspace tool, not just a chatbot.
The worker nodes doing actual work.
Prevents conflicts between System 1 nodes.
Monitors performance, enforces policies.
Looks outward + forward. Adapts.
What the graph IS and won't do.
graph.md configUser isn't outside the system — they're an actant (ANT).
From cybernetics
Perception (sensors, classifiers) → Decision (routers, controllers) → Action (processors, effectors). Feedback from action back to perception. Missing any layer breaks the loop.
From ANT
Message schemas and inter-node protocols matter MORE than individual node intelligence. A mediocre LLM with excellent routing outperforms a brilliant LLM with bad routing. Capability is emergent from topology.
From signal processing
Only Processor nodes need LLMs. Classifiers, routers, filters, accumulators can be lightweight models or pure code. Keeps cost and latency sane. Reserve expensive calls for where reasoning matters.
From Max/MSP, Blueprints
Distinguish trigger inputs (fire processing) from context inputs (available but passive). Type the message wires. Dampen every feedback cycle (max iterations, circuit breakers).
From Ashby
Classifier/router layer must distinguish at least as many input types as you have processing strategies. Under-classification = wasted capability. Over-classification = premature complexity.
From Cynefin
Clear = shallow/fast (skip Thinker). Complicated = specialist path. Complex = parallel probes. Chaotic = hardcoded fallback, act first. Different domains = different graph depths.
The graph IS the agent. Not a single LLM with a prompt. Not a chain of API calls. A living, always-on, multi-model network of specialized processors — exactly like a signal processing graph, but for language and reasoning.
Each phase adds a node. Each node validates one architectural claim. If any claim fails, we learn something. If they all hold, we have a new kind of agent runtime.
The network is the capability (ANT). The variety must match the disturbance (Ashby). The domain determines the strategy (Cynefin). The organism needs all five systems to be viable (Beer).