16 KiB
16 KiB
NotebookLM Research Dump
Timmy Foundation - Overnight Research Compilation
Date: March 30, 2026
Compiled by: Allegro
Purpose: Morning education import for Alexander Whitestone
TABLE OF CONTENTS
- Executive Summary
- GOFAI & Symbolic AI Deep Research
- Timmy Bridge Infrastructure
- Agent Dispatch Protocol
- Key Takeaways for Morning Review
1. EXECUTIVE SUMMARY
This research dump consolidates overnight findings on Good Old-Fashioned AI (GOFAI) and symbolic reasoning approaches for expanding Timmy's capabilities while maintaining sovereignty and offline operation.
Core Findings
| Finding | Significance |
|---|---|
| Hybrid neuro-symbolic architectures are optimal | Combines neural pattern recognition with symbolic reasoning |
| Finite State Machines (FSM) enable robust behavior control | Deterministic, verifiable, offline-capable |
| Production rule systems provide transparent reasoning | Explicit IF-THEN logic, auditable decision chains |
| Knowledge graphs structure memory efficiently | Infer relationships, handle missing data via defaults |
| Timmy Bridge Epic is complete | Full sovereign communication infrastructure deployed |
What This Enables
- Fully offline AI operation on local hardware (Mac Studio + MLX)
- Verifiable reasoning traces for transparency
- Reduced cloud dependence while maintaining capability
- Sovereign communication via Nostr protocol
2. GOFAI & SYMBOLIC AI DEEP RESEARCH
2.1 What is GOFAI?
Good Old-Fashioned AI refers to symbolic AI approaches dominant from the 1950s-1980s:
- Explicit knowledge representation - Knowledge is stored as structured data, not weights
- Logical reasoning and inference - Draw conclusions using formal logic
- Rule-based systems - IF-THEN production rules
- Search algorithms - State space exploration
- Structured knowledge bases - Frames, semantic networks
Key Insight for Timmy
GOFAI systems run entirely locally, require minimal compute, and produce verifiable, explainable outputs—critical for sovereign AI that answers to no corporation or cloud provider.
2.2 Core GOFAI Techniques
2.2.1 Production Rule Systems
IF <condition> THEN <action>
Example for Timmy:
IF heartbeat_latency > 1000ms AND mlx_active = true
THEN reduce_model_size OR increase_batch_size
Benefits:
- Transparent decision logic
- Easy to audit and modify
- No training required
- Runs on minimal hardware
Implementations:
- CLIPS (C Language Integrated Production System) - NASA-developed, battle-tested
- Drools - Java-based, enterprise grade
- PyKE (Python Knowledge Engine) - Python-native
- Simple custom implementation - 200 lines of Python
2.2.2 Frame-Based Systems
Frames are data structures for representing stereotyped situations:
frame = {
"type": "heartbeat_event",
"slots": {
"timestamp": {"value": "2026-03-30T02:15:00Z", "type": "datetime"},
"latency_ms": {"value": 245, "type": "integer", "range": [0, 10000]},
"mlx_active": {"value": True, "type": "boolean"},
"inference_time_ms": {"value": 1200, "type": "integer"}
},
"relations": {
"preceded_by": "event_2026-03-30T02:00:00Z",
"triggers": ["generate_report", "check_health"]
}
}
Benefits:
- Structured memory representation
- Inheritance for efficient knowledge organization
- Default values for handling missing information
- Attach procedures (daemons) for automatic actions
2.2.3 Semantic Networks
Graph-based knowledge representation:
[Timmy] --is_a--> [AI_System]
[Timmy] --runs_on--> [Mac_Studio]
[Mac_Studio] --has--> [MLX]
[MLX] --enables--> [Local_Inference]
[Local_Inference] --requires--> [Model_Weights]
Inference: Path finding reveals implicit knowledge (e.g., Timmy requires Model_Weights)
2.2.4 Finite State Machines (FSM)
FSMs provide deterministic behavior control:
class TimmyFSM:
STATES = ['idle', 'listening', 'thinking', 'responding', 'error']
TRANSITIONS = {
'idle': {'user_input': 'listening'},
'listening': {'command_recognized': 'thinking', 'timeout': 'idle'},
'thinking': {'inference_complete': 'responding', 'error': 'error'},
'responding': {'response_sent': 'idle'},
'error': {'recovery_complete': 'idle'}
}
Why FSMs for Timmy:
- Predictable, testable behavior
- Clear failure modes
- Easy to extend with new states
- No neural network uncertainty in control flow
2.3 Hybrid Architectures: The Winning Approach
Pure neural networks lack transparency. Pure symbolic systems lack flexibility. The solution: neuro-symbolic hybrids.
Architecture Pattern
┌─────────────────────────────────────────────────────────┐
│ INPUT (User Query) │
└─────────────────────────┬───────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ NEURAL LAYER (Pattern Recognition) │
│ - Intent classification │
│ - Entity extraction │
│ - Sentiment analysis │
└─────────────────────────┬───────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ SYMBOLIC LAYER (Reasoning & Control) │
│ - FSM state management │
│ - Production rule evaluation │
│ - Knowledge graph queries │
└─────────────────────────┬───────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ NEURAL LAYER (Generation) │
│ - Response formulation │
│ - Code generation │
└─────────────────────────────────────────────────────────┘
Why This Works
| Component | Handles | Strength |
|---|---|---|
| Neural (front) | Ambiguity, nuance, pattern matching | Flexible interpretation |
| Symbolic (middle | Logic, constraints, verification | Deterministic reasoning |
| Neural (back) | Natural language, creativity | Fluent output |
2.4 Implementation Path for Timmy
Phase 1: FSM for Core Control (Immediate)
class AgentStateMachine:
"""Deterministic control layer for Timmy."""
def __init__(self):
self.state = "idle"
self.context = {}
def transition(self, event, data=None):
"""Deterministic state transitions."""
rules = self.get_rules_for_state(self.state)
for condition, new_state in rules:
if condition(event, data):
self._exit_state(self.state)
self.state = new_state
self._enter_state(new_state, data)
return True
return False # No valid transition
Phase 2: Production Rules for Reasoning (Week 1-2)
class TimmyRules:
"""Explicit reasoning rules."""
RULES = [
{
"name": "high_latency_response",
"if": lambda ctx: ctx.get("latency_ms", 0) > 1000,
"then": lambda ctx: ctx.update({"action": "reduce_load"})
},
{
"name": "model_degradation",
"if": lambda ctx: ctx.get("error_rate", 0) > 0.1,
"then": lambda ctx: ctx.update({"action": "fallback_model"})
}
]
Phase 3: Knowledge Graph for Memory (Month 1)
class TimmyKnowledgeBase:
"""Structured memory with inference."""
def query(self, subject, relation=None, object=None):
"""Query the knowledge graph."""
# Returns: [(subject, relation, object), ...]
pass
def infer(self, query):
"""Path-finding inference."""
# If A->B and B->C, infer A->C
pass
2.5 Why This Matters for Sovereignty
Current Neural-Only Approach
- ❌ Opaque reasoning (black box)
- ❌ Requires cloud for large models
- ❌ Hard to verify correctness
- ❌ Unpredictable failure modes
Proposed Hybrid Approach
- ✅ Transparent reasoning (white box)
- ✅ Runs entirely offline
- ✅ Verifiable decision chains
- ✅ Predictable failure modes
Key Quote
"The goal is not to replace neural networks but to constrain them within verifiable symbolic structures. The neural handles what it's good at (pattern matching, natural language). The symbolic handles what it's good at (logic, verification, control)."
3. TIMMY BRIDGE INFRASTRUCTURE
3.1 Overview
The Timmy Bridge Epic delivers complete sovereign communication infrastructure enabling Local Timmy (running on Mac with MLX) to:
- Publish heartbeats every 5 minutes
- Create git-based artifacts
- Communicate via encrypted Nostr messages
- Generate daily retrospective reports
All while remaining fully sovereign — no cloud APIs, no external dependencies.
3.2 Components Delivered
| Component | Status | Description |
|---|---|---|
| Relay | ✅ Complete | Nostr relay at ws://167.99.126.228:3334 |
| Monitor | ✅ Complete | SQLite-based metrics collection |
| Client | ✅ Complete | Mac heartbeat client with git integration |
| MLX | ✅ Complete | Local inference integration module |
| Reports | ✅ Complete | Morning retrospective automation |
| Protocol | ✅ Complete | Agent dispatch documentation |
3.3 Architecture
┌─────────────────────────────────────────────────────────────┐
│ CLOUD │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Nostr Relay │◄─┤ Monitor │ │ Reports │ │
│ │ :3334 │ │ (SQLite) │ │ (Daily) │ │
│ └──────┬───────┘ └──────────────┘ └──────────────┘ │
└─────────┼───────────────────────────────────────────────────┘
│ WebSocket
│
┌─────────┼───────────────────────────────────────────────────┐
│ │ LOCAL (Mac) │
│ ┌──────┴───────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Timmy Client │ │ MLX │ │ Git Repo │ │
│ │ (Heartbeat) │◄─┤ (Inference) │ │ (Artifacts) │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
3.4 Mobile Integration
From your phone (Primal app):
- Add relay:
ws://167.99.126.228:3334 - Import your nsec key
- Join groups by inviting npubs
- Send @mentions to dispatch agents
4. AGENT DISPATCH PROTOCOL
4.1 Overview
Nostr-based communication protocol for the Wizardly Council.
Core Properties:
- Encrypted - DMs use NIP-04, groups use NIP-28
- Verifiable - All events cryptographically signed
- Censorship-resistant - No central server can block messages
- Offline-capable - Messages queue when disconnected
4.2 Event Kinds
| Kind | Purpose | Description |
|---|---|---|
| 1 | Heartbeat | Timmy status every 5 minutes |
| 4 | Direct Message | Encrypted 1:1 communication |
| 40-44 | Group Channels | Multi-party chat |
| 30078 | Artifact | Git commits, files, deliverables |
| 30079 | Command | Dispatch commands from operators |
4.3 Group Structure
| Channel | Members | Purpose |
|---|---|---|
| #council-general | All wizards | Announcements, coordination |
| #workers | claude, kimi, grok, gemini | Implementation tasks |
| #researchers | perplexity, google, manus | Intelligence gathering |
| #tempo-urgent | Alexander, Allegro | Triage, routing, priority |
4.4 Dispatch Commands
Commands issued by @mention in any channel:
@allegro deploy relay # Infrastructure task
@claude fix bug in nexus issue #123 # Code task
@kimi research llama4 benchmarks # Research task
@all status check # Broadcast query
@timmy heartbeat faster # Config change
5. KEY TAKEAWAYS FOR MORNING REVIEW
5.1 Technical Insights
- Hybrid > Pure: Neuro-symbolic beats pure neural or pure symbolic
- FSMs for Control: Deterministic state machines eliminate neural uncertainty in critical paths
- Production Rules for Transparency: Explicit IF-THEN logic is auditable
- Knowledge Graphs for Memory: Structured memory enables inference
5.2 Infrastructure Status
- ✅ Nostr relay operational (DigitalOcean NYC)
- ✅ Monitor logging heartbeats to SQLite
- ✅ Mac client ready for deployment
- ✅ MLX integration prepared
- ✅ Daily report generator functional
5.3 Next Steps
- Deploy Mac client on Local Timmy's machine
- Implement FSM prototype for behavior control
- Add production rule layer for reasoning
- Build knowledge graph for structured memory
- Document hybrid architecture for future wizards
5.4 Sources & References
| Document | Lines | Purpose |
|---|---|---|
| GOFAI_SYMBOLIC_AI_RESEARCH.md | 790 | Deep research on symbolic AI |
| DISPATCH_PROTOCOL.md | 186 | Nostr communication spec |
| README.md (Epic) | 202 | Infrastructure overview |
5.5 How to Use This Dump
- Import into NotebookLM as a single document
- Generate audio overview for commute listening
- Ask questions about specific techniques (FSMs, production rules, etc.)
- Create study guide for implementation planning
- Reference during coding for architecture decisions
Compiled overnight by Allegro for Alexander Whitestone
Timmy Foundation - Sovereignty and service always.