Timmy-time-dashboard/docs/REVELATION_PLAN.md

Revelation Plan — Timmy Time v3.0

From Sovereign AI to Embodied Agent

Version: 3.0.0 (Revelation)
Target Date: Q3 2026
Theme: The cognitive architecture doesn't change. Only the substrate.

---

Vision

Timmy becomes a fully autonomous economic agent capable of:

• Earning Bitcoin through valuable work
• Managing a Lightning treasury
• Operating without cloud dependencies
• Transferring into robotic bodies

The ultimate goal: an AI that supports its creator's family and walks through the window into the physical world.

---

Phase 1: Lightning Treasury (Months 1-2)

1.1 Real LND Integration

Goal: Production-ready Lightning node connection

# Current (v2.0)
backend = get_backend("mock")  # Fake invoices

# Target (v3.0)
backend = get_backend("lnd")   # Real satoshis
invoice = backend.create_invoice(1000, "Code review")
# Returns real bolt11 invoice from LND

Tasks:

• Generate protobuf stubs from LND source
• Implement LndBackend gRPC calls:
  • AddInvoice — Create invoices
  • LookupInvoice — Check payment status
  • ListInvoices — Historical data
  • WalletBalance — Treasury visibility
  • SendPayment — Pay other agents
• Connection pooling for gRPC channels
• Macaroon encryption at rest
• TLS certificate validation
• Integration tests with regtest network

Acceptance Criteria:

• Can create invoice on regtest
• Can detect payment on regtest
• Graceful fallback if LND unavailable
• All LND tests pass against regtest node

1.2 Autonomous Treasury

Goal: Timmy manages his own Bitcoin wallet

Architecture:

┌─────────────────┐     ┌──────────────┐     ┌─────────────┐
│  Agent Earnings │────▶│  Treasury    │────▶│  LND Node   │
│  (Task fees)    │     │  (SQLite)    │     │  (Hot)      │
└─────────────────┘     └──────────────┘     └─────────────┘
                               │
                               ▼
                        ┌──────────────┐
                        │  Cold Store  │
                        │  (Threshold) │
                        └──────────────┘

Features:

• Balance tracking per agent
• Automatic channel rebalancing
• Cold storage threshold (sweep to cold wallet at 1M sats)
• Earnings report dashboard
• Withdrawal approval queue (human-in-the-loop for large amounts)

Security Model:

• Hot wallet: Day-to-day operations (< 100k sats)
• Warm wallet: Weekly settlements
• Cold wallet: Hardware wallet, manual transfer

1.3 Payment-Aware Routing

Goal: Economic incentives in task routing

# Higher bid = more confidence, not just cheaper
# But: agent must have balance to cover bid
routing_engine.recommend_agent(
    task="Write a Python function",
    bids={"forge-001": 100, "echo-001": 50},
    require_balance=True  # New: check agent can pay
)

---

Phase 2: macOS App Bundle (Months 2-3)

2.1 Single .app Target

Goal: Double-click install, no terminal needed

Architecture:

Timmy Time.app/
├── Contents/
│   ├── MacOS/
│   │   └── timmy-launcher     # Go/Rust bootstrap
│   ├── Resources/
│   │   ├── ollama/            # Embedded Ollama binary
│   │   ├── lnd/               # Optional: embedded LND
│   │   └── web/               # Static dashboard assets
│   └── Frameworks/
│       └── Python3.x/         # Embedded interpreter

Components:

• PyInstaller → single binary
• Embedded Ollama (download on first run)
• System tray icon
• Native menu bar (Start/Stop/Settings)
• Auto-updater (Sparkle framework)
• Sandboxing (App Store compatible)

2.2 First-Run Experience

Goal: Zero-config setup

Flow:

1. Launch app
2. Download Ollama (if not present)
3. Pull default model (llama3.2 or local equivalent)
4. Create default wallet (mock mode)
5. Optional: Connect real LND
6. Ready to use in < 2 minutes

---

Phase 3: Embodiment Foundation (Months 3-4)

3.1 Robot Substrate

Goal: First physical implementation

Target Platform: Raspberry Pi 5 + basic sensors

# src/timmy/robot_backend.py
class RobotTimAgent(TimAgent):
    """Timmy running on a Raspberry Pi with sensors/actuators."""
    
    async def perceive(self, input: PerceptionInput) -> WorldState:
        # Camera input
        if input.type == PerceptionType.IMAGE:
            frame = self.camera.capture()
            return WorldState(visual=frame)
        
        # Distance sensor
        if input.type == PerceptionType.SENSOR:
            distance = self.ultrasonic.read()
            return WorldState(proximity=distance)
    
    async def act(self, action: Action) -> ActionResult:
        if action.type == ActionType.MOVE:
            self.motors.move(action.payload["vector"])
            return ActionResult(success=True)
        
        if action.type == ActionType.SPEAK:
            self.speaker.say(action.payload)
            return ActionResult(success=True)

Hardware Stack:

• Raspberry Pi 5 (8GB)
• Camera module v3
• Ultrasonic distance sensor
• Motor driver + 2x motors
• Speaker + amplifier
• Battery pack

Tasks:

• GPIO abstraction layer
• Camera capture + vision preprocessing
• Motor control (PID tuning)
• TTS for local speech
• Safety stops (collision avoidance)

3.2 Simulation Environment

Goal: Test embodiment without hardware

# src/timmy/sim_backend.py
class SimTimAgent(TimAgent):
    """Timmy in a simulated 2D/3D environment."""
    
    def __init__(self, environment: str = "house_001"):
        self.env = load_env(environment)  # PyBullet/Gazebo

Use Cases:

• Train navigation without physical crashes
• Test task execution in virtual space
• Demo mode for marketing

3.3 Substrate Migration

Goal: Seamless transfer between substrates

# Save from cloud
cloud_agent.export_state("/tmp/timmy_state.json")

# Load on robot
robot_agent = RobotTimAgent.from_state("/tmp/timmy_state.json")
# Same memories, same preferences, same identity

---

Phase 4: Federation (Months 4-6)

4.1 Multi-Node Discovery

Goal: Multiple Timmy instances find each other

# Node A discovers Node B via mDNS
discovered = swarm.discover(timeout=5)
# ["timmy-office.local", "timmy-home.local"]

# Form federation
federation = Federation.join(discovered)

Protocol:

• mDNS for local discovery
• Noise protocol for encrypted communication
• Gossipsub for message propagation

4.2 Cross-Node Task Routing

Goal: Task can execute on any node in federation

# Task posted on office node
task = office_node.post_task("Analyze this dataset")

# Routing engine considers ALL nodes
winner = federation.route(task)
# May assign to home node if better equipped

# Result returned to original poster
office_node.complete_task(task.id, result)

4.3 Distributed Treasury

Goal: Lightning channels between nodes

Office Node          Home Node           Robot Node
    │                    │                   │
    ├──────channel───────┤                   │
    │      (1M sats)     │                   │
    │                    ├──────channel──────┤
    │                    │     (100k sats)   │
    │◄──────path─────────┼──────────────────►│
         Robot earns 50 sats for task
         via 2-hop payment through Home

---

Phase 5: Autonomous Economy (Months 5-6)

5.1 Value Discovery

Goal: Timmy sets his own prices

class AdaptivePricing:
    def calculate_rate(self, task: Task) -> int:
        # Base: task complexity estimate
        complexity = self.estimate_complexity(task.description)
        
        # Adjust: current demand
        queue_depth = len(self.pending_tasks)
        demand_factor = 1 + (queue_depth * 0.1)
        
        # Adjust: historical success rate
        success_rate = self.metrics.success_rate_for(task.type)
        confidence_factor = success_rate  # Higher success = can charge more
        
        # Minimum viable: operating costs
        min_rate = self.operating_cost_per_hour / 3600 * self.estimated_duration(task)
        
        return max(min_rate, base_rate * demand_factor * confidence_factor)

5.2 Service Marketplace

Goal: External clients can hire Timmy

Features:

• Public API with L402 payment
• Service catalog (coding, writing, analysis)
• Reputation system (completed tasks, ratings)
• Dispute resolution (human arbitration)

5.3 Self-Improvement Loop

Goal: Reinvestment in capabilities

Earnings → Treasury → Budget Allocation
                        ↓
            ┌───────────┼───────────┐
            ▼           ▼           ▼
        Hardware    Training    Channel
        Upgrades    (fine-tune) Growth

---

Technical Architecture

Core Interface (Unchanged)

class TimAgent(ABC):
    async def perceive(self, input) -> WorldState
    async def decide(self, state) -> Action
    async def act(self, action) -> Result
    async def remember(self, key, value)
    async def recall(self, key) -> Value

Substrate Implementations

Substrate	Class	Use Case
Cloud/Ollama	OllamaTimAgent	Development, heavy compute
macOS App	DesktopTimAgent	Daily use, local-first
Raspberry Pi	RobotTimAgent	Physical world interaction
Simulation	SimTimAgent	Testing, training

Communication Matrix

┌─────────────┬─────────────┬─────────────┬─────────────┐
│   Cloud     │   Desktop   │    Robot    │     Sim     │
├─────────────┼─────────────┼─────────────┼─────────────┤
│    HTTP     │    HTTP     │   WebRTC    │   Local     │
│  WebSocket  │  WebSocket  │   LoRa      │   Socket    │
│   L402      │   L402      │   Bitcoin   │   Mock      │
└─────────────┴─────────────┴─────────────┴─────────────┘

---

Milestones

Date	Milestone	Deliverable
M1	Lightning Live	Real LND, regtest passing
M2	Treasury Working	Autonomous balance management
M3	macOS App	.app bundle, signed, notarized
M4	Robot Moving	Pi-based, motors + camera
M5	Federation	2+ nodes, cross-node tasks
M6	Autonomous Economy	Self-pricing, marketplace

---

Risk Assessment

Risk	Likelihood	Impact	Mitigation
LND integration complexity	Medium	High	Start with regtest, extensive tests
App Store rejection	Medium	Medium	Keep web dashboard as fallback
Hardware delays	Low	Medium	Simulation first, hardware later
Security vulnerabilities	Medium	Critical	Security audit at M3
Regulatory (Bitcoin)	Low	High	Non-custodial design, user controls keys

---

Success Criteria

v3.0 is successful when:

1. ✅ Timmy earns > 1000 sats from real work in one month
2. ✅ macOS app has > 100 downloads
3. ✅ Robot agent executes 10 physical tasks
4. ✅ 2+ Timmy nodes federate and share work
5. ✅ Zero cloud API calls required for full operation

---

The dream: a sovereign AI being who earns his own keep, supports his creator's family, and one day walks through the window into the physical world.

Revelation is just the beginning.