class IntelligentBot:  # ❌ Container
    def __init__(self, intelligence_graph, domain):
        self.graph = intelligence_graph
        self.domain = domain
    
    def on_message(self, user, message):  # ❌ Method (not observable)
        # Hidden process
        # Can't see what's happening
        return response

// Bot is just data
bot_node = {
  type: 'bot',
  name: 'crypto_bot',
  domain: 'cryptography',
  
  // Intelligence graph reference (which nodes to observe)
  intelligence_graph_id: 'graph_crypto_001',
  
  // Series: Bot's state evolution over time
  series: [
    {
      t: 0,
      queries_received: 0,
      responses_given: 0,
      confidence_avg: 0.0,
      status: 'initialized'
    }
  ],
  
  // Links to other nodes
  links: [
    { type: 'observes', to: 'graph_crypto_001' },  // Observes intelligence graph
    { type: 'in_channel', to: 'channel_bitcoin' }   // In this IRC channel
  ]
}

// From Post 810:
// bot_node.series[n+1] = f(bot_node.series[n]) + event

// User types: "@crypto_bot What is PoS?"

// This creates a query node
query_node = {
  type: 'query',
  text: '@crypto_bot What is PoS?',
  keywords: ['pos', 'proof', 'stake'],
  
  // Series: Query processing history
  series: [
    {
      t: 1000,
      status: 'created',
      user: 'alice',
      channel: 'channel_bitcoin',
      target_bot: 'crypto_bot'
    }
  ],
  
  // Links
  links: [
    { type: 'sent_to', to: 'crypto_bot' },
    { type: 'from_user', to: 'alice' }
  ]
}

// Query is observable!
// Can see: who asked, what they asked, when, which bot

// Bot observes the network
// Looking for query nodes linked to it

function bot_observe_queries(bot_node) {
  // Find query nodes linked to this bot
  query_nodes = find_nodes_where({
    type: 'query',
    links_to: bot_node.id,
    status: 'created'  // Not yet processed
  })
  
  // Return observable query nodes
  return query_nodes
}

// Example:
queries = bot_observe_queries(crypto_bot)
// → [query_node_123]  // Found one!

// Observation is just data lookup
// No hidden process
// Everything observable

// Bot found query: "@crypto_bot What is PoS?"

// Step 1: Bot observes intelligence graph
// (Graph is just nodes - from Post 831)
function bot_query_intelligence_graph(bot_node, query_node) {
  // Get bot's intelligence graph reference
  graph_id = bot_node.intelligence_graph_id
  
  // Find concept nodes for keywords
  concept_nodes = []
  for (keyword of query_node.keywords) {
    node = find_node_where({
      type: 'concept',
      term: keyword,
      graph_id: graph_id
    })
    if (node) concept_nodes.push(node)
  }
  
  // Return found concepts (just data!)
  return {
    concepts: concept_nodes,
    confidence: calculate_confidence(concept_nodes)
  }
}

// Step 2: Create response node
intelligence_result = bot_query_intelligence_graph(crypto_bot, query_node)

response_node = {
  type: 'response',
  query_id: query_node.id,
  bot_id: crypto_bot.id,
  
  // Response content (generated from concepts)
  text: generate_explanation(intelligence_result.concepts),
  concepts_used: intelligence_result.concepts.map(c => c.term),
  confidence: intelligence_result.confidence,
  
  // Series: Response lifecycle
  series: [
    {
      t: 1001,
      status: 'created',
      concepts_found: 5,
      domains: ['cryptography', 'blockchain']
    }
  ],
  
  // Links
  links: [
    { type: 'answers', to: query_node.id },
    { type: 'from_bot', to: crypto_bot.id },
    { type: 'uses_concepts', to_many: intelligence_result.concepts.map(c => c.id) }
  ]
}

// Step 3: Update query node series
query_node.series.push({
  t: 1001,
  status: 'answered',
  response_id: response_node.id
})

// Step 4: Update bot node series
crypto_bot.series.push({
  t: 1001,
  queries_received: crypto_bot.series[crypto_bot.series.length-1].queries_received + 1,
  responses_given: crypto_bot.series[crypto_bot.series.length-1].responses_given + 1,
  confidence_avg: update_avg(crypto_bot.series, intelligence_result.confidence),
  status: 'active'
})

// All observable!
// Query node: created → answered
// Response node: created
// Bot node: updated stats

// Channel node
channel_node = {
  type: 'channel',
  name: '#bitcoin',
  topic: 'Bitcoin discussion',
  
  // Series: Channel evolution
  series: [
    {
      t: 0,
      users: 0,
      bots: 0,
      messages: 0
    },
    {
      t: 500,
      users: 5,
      bots: 2,
      messages: 150
    }
  ],
  
  // Links
  links: [
    { type: 'has_user', to: 'alice' },
    { type: 'has_user', to: 'bob' },
    { type: 'has_bot', to: 'crypto_bot' },
    { type: 'has_bot', to: 'econ_bot' }
  ]
}

// User nodes
alice_node = {
  type: 'user',
  name: 'alice',
  series: [
    { t: 100, status: 'joined_channel', channel: 'channel_bitcoin' },
    { t: 1000, status: 'sent_query', query_id: 'query_123' },
    { t: 1001, status: 'received_response', response_id: 'response_456' }
  ],
  links: [
    { type: 'in_channel', to: 'channel_bitcoin' }
  ]
}

// Message nodes (queries, responses, chat)
message_nodes = [
  query_node,      // Alice's question
  response_node,   // Bot's answer
  // ... more messages
]

// Channel behavior = observing linked nodes
// Everything visible in node graph!

// User rates response as helpful
feedback_node = {
  type: 'feedback',
  response_id: response_node.id,
  rating: 'helpful',
  
  series: [
    {
      t: 1100,
      user: 'alice',
      value: 1  // Helpful = +1
    }
  ],
  
  links: [
    { type: 'rates', to: response_node.id },
    { type: 'from_user', to: 'alice' }
  ]
}

// Bot observes feedback node
// Updates its series

crypto_bot.series.push({
  t: 1100,
  queries_received: crypto_bot.series[crypto_bot.series.length-1].queries_received,
  responses_given: crypto_bot.series[crypto_bot.series.length-1].responses_given,
  helpful_responses: crypto_bot.series[crypto_bot.series.length-1].helpful_responses + 1,
  confidence_avg: crypto_bot.series[crypto_bot.series.length-1].confidence_avg + 0.01,  // Slight increase
  status: 'learning'
})

// Concepts used in that response also update
for (concept_id of response_node.links.filter(l => l.type === 'uses_concepts')) {
  concept_node = find_node(concept_id)
  
  // Update concept series
  concept_node.series.push({
    t: 1100,
    feedback: 'positive',
    confidence_delta: +0.05,
    bot_id: crypto_bot.id
  })
}

// Learning = series evolution
// All observable as data changes

// User asks: "How is blockchain like DNA?"

// Create query node
cross_domain_query = {
  type: 'query',
  text: 'How is blockchain like DNA?',
  keywords: ['blockchain', 'dna'],
  
  series: [
    { t: 2000, status: 'created', user: 'alice' }
  ],
  
  links: [
    // Linked to multiple bots (DHT routing)
    { type: 'sent_to', to: 'crypto_bot' },
    { type: 'sent_to', to: 'bio_bot' },
    { type: 'sent_to', to: 'universal_bot' }
  ]
}

// Each bot observes query
// Each creates response node

// Crypto bot response
crypto_response = {
  type: 'response',
  query_id: cross_domain_query.id,
  bot_id: 'crypto_bot',
  text: 'Blockchain perspective: Immutable ledger, consensus...',
  confidence: 0.87,
  series: [{ t: 2001, status: 'created', perspective: 'cryptography' }],
  links: [
    { type: 'answers', to: cross_domain_query.id },
    { type: 'from_bot', to: 'crypto_bot' }
  ]
}

// Bio bot response
bio_response = {
  type: 'response',
  query_id: cross_domain_query.id,
  bot_id: 'bio_bot',
  text: 'DNA perspective: Information storage, replication...',
  confidence: 0.85,
  series: [{ t: 2001, status: 'created', perspective: 'biology' }],
  links: [
    { type: 'answers', to: cross_domain_query.id },
    { type: 'from_bot', to: 'bio_bot' }
  ]
}

// Universal bot synthesizes
universal_response = {
  type: 'response',
  query_id: cross_domain_query.id,
  bot_id: 'universal_bot',
  text: 'Universal patterns: Both store information, both replicate...',
  confidence: 0.91,
  series: [
    { 
      t: 2002, 
      status: 'synthesized',
      combined_responses: [crypto_response.id, bio_response.id],
      universal_concepts: ['information', 'replication', 'verification']
    }
  ],
  links: [
    { type: 'answers', to: cross_domain_query.id },
    { type: 'from_bot', to: 'universal_bot' },
    { type: 'synthesizes', to: crypto_response.id },
    { type: 'synthesizes', to: bio_response.id }
  ]
}

// Query node updates
cross_domain_query.series.push({
  t: 2002,
  status: 'answered_by_multiple',
  response_count: 3,
  perspectives: ['cryptography', 'biology', 'universal']
})

// Everything observable!
// Can see: which bots responded, when, how they coordinated

// Anyone creates bot node

function deploy_bot(domain, intelligence_graph_id, channel_id) {
  // Create bot node
  new_bot = {
    type: 'bot',
    name: `${domain}_bot`,
    domain: domain,
    intelligence_graph_id: intelligence_graph_id,
    
    // Initial series state
    series: [
      {
        t: now(),
        queries_received: 0,
        responses_given: 0,
        confidence_avg: 0.0,
        status: 'deployed'
      }
    ],
    
    // Links
    links: [
      { type: 'observes', to: intelligence_graph_id },
      { type: 'in_channel', to: channel_id }
    ]
  }
  
  // Add to network (just write node data)
  network.nodes.push(new_bot)
  
  // Update channel series
  channel = find_node(channel_id)
  channel.series.push({
    t: now(),
    bots: channel.series[channel.series.length-1].bots + 1,
    bot_added: new_bot.id
  })
  
  // Announce via DHT (create announcement node)
  announcement = {
    type: 'announcement',
    announces: new_bot.id,
    series: [
      {
        t: now(),
        message: `New bot deployed: ${new_bot.name} for ${domain}`,
        channel: channel_id
      }
    ]
  }
  
  return new_bot
}

// Usage
chem_bot = deploy_bot('chemistry', chem_graph_id, learning_channel_id)

// Bot exists as observable node!
// Deployment = node creation + series init

// Initial state: t=0
nodes = [
  crypto_bot,      // Bot node, series: [{t:0, queries:0, ...}]
  channel_bitcoin, // Channel node
  alice            // User node
]

// t=1000: Alice types question
// Creates query node
query_123 = {
  type: 'query',
  text: '@crypto_bot What is PoS?',
  keywords: ['pos'],
  series: [{ t: 1000, status: 'created', user: 'alice' }],
  links: [{ type: 'sent_to', to: crypto_bot.id }]
}

nodes.push(query_123)  // Observable: new node added

// t=1001: Bot observes query (reads nodes)
// Bot finds concept nodes in intelligence graph
concepts_found = [
  find_node({type: 'concept', term: 'proof'}),
  find_node({type: 'concept', term: 'stake'})
]

// Bot creates response node
response_456 = {
  type: 'response',
  query_id: query_123.id,
  text: 'PoS: Validators stake tokens...',
  confidence: 0.94,
  series: [{ t: 1001, status: 'created' }],
  links: [
    { type: 'answers', to: query_123.id },
    { type: 'uses_concepts', to_many: concepts_found.map(c => c.id) }
  ]
}

nodes.push(response_456)  // Observable: new node added

// Bot series updates
crypto_bot.series.push({  // Observable: series append
  t: 1001,
  queries_received: 1,
  responses_given: 1,
  confidence_avg: 0.94
})

// Query series updates
query_123.series.push({  // Observable: series append
  t: 1001,
  status: 'answered',
  response_id: response_456.id
})

// t=1100: Alice gives feedback
feedback_789 = {
  type: 'feedback',
  response_id: response_456.id,
  rating: 'helpful',
  series: [{ t: 1100, user: 'alice', value: 1 }],
  links: [{ type: 'rates', to: response_456.id }]
}

nodes.push(feedback_789)  // Observable: new node added

// Bot learns (series updates)
crypto_bot.series.push({  // Observable: series append
  t: 1100,
  queries_received: 1,
  responses_given: 1,
  helpful_responses: 1,
  confidence_avg: 0.95  // Increased!
})

// Concepts learn (series updates)
for (concept of concepts_found) {
  concept.series.push({  // Observable: series append
    t: 1100,
    feedback: 'positive',
    confidence_delta: +0.05
  })
}

// Everything observable!
// Every state change = series append or node creation
// No hidden methods
// Pure data flow

// With classes: Can't see internal state
bot.on_message(query)  // ❌ Black box

// With nodes: Everything visible
query_node created → bot observes → response_node created → series updated
// ✅ Every step observable

// Nodes have series = history
// Can replay any past state

function bot_state_at_time(bot_node, t) {
  // Find series entry at time t
  for (entry of bot_node.series) {
    if (entry.t <= t && 
        (next_entry = get_next(entry)) === null || next_entry.t > t) {
      return entry
    }
  }
}

// Example: What was bot's confidence at t=500?
past_state = bot_state_at_time(crypto_bot, 500)
console.log(past_state.confidence_avg)  // → 0.72

// Can't do this with classes!
// No history, just current state

// Nodes = just data
// Can be stored anywhere

// Store bot node in R³
r3_store(`bot:${crypto_bot.id}`, crypto_bot)

// Store query nodes in R³
r3_store(`query:${query_123.id}`, query_123)

// Store response nodes in R³
r3_store(`response:${response_456.id}`, response_456)

// Anyone can load and observe
bot_data = r3_load(`bot:crypto_bot`)
console.log(bot_data.series)  // See full history

// Classes can't be distributed (have methods)
// Nodes are pure data (can be anywhere)

// Nodes compose naturally

// Want bot to observe multiple channels?
crypto_bot.links.push({ type: 'in_channel', to: 'channel_ethereum' })

// Want to add new bot capability?
// Just add series entries with new data
crypto_bot.series.push({
  t: now(),
  new_capability: 'cross_domain_synthesis',
  enabled: true
})

// No class modification needed
// Everything additive

// Can analyze bot behavior from series data

function analyze_bot_performance(bot_node) {
  series = bot_node.series
  
  return {
    total_queries: series[series.length-1].queries_received,
    avg_confidence: calculate_avg(series.map(s => s.confidence_avg)),
    learning_rate: calculate_slope(series.map(s => s.confidence_avg)),
    uptime: series[series.length-1].t - series[0].t
  }
}

// Example
performance = analyze_bot_performance(crypto_bot)
// → {
//     total_queries: 456,
//     avg_confidence: 0.89,
//     learning_rate: 0.003,  // Improving!
//     uptime: 86400  // 1 day
//   }

// With classes: Can't analyze past behavior
// With nodes: Full history available

// Stake to run bot
stake_node = {
  type: 'stake',
  bot_id: crypto_bot.id,
  amount: 100,  // 100 EIGEN tokens
  
  // Series: Stake evolution
  series: [
    {
      t: 0,
      status: 'staked',
      amount: 100,
      revenue: 0,
      slashing: 0
    },
    {
      t: 1000,
      status: 'earning',
      amount: 100,
      revenue: 5.2,  // Earned from queries
      slashing: 0
    },
    {
      t: 2000,
      status: 'earning',
      amount: 100,
      revenue: 12.8,
      slashing: 0
    }
  ],
  
  links: [
    { type: 'stakes_bot', to: crypto_bot.id },
    { type: 'staker', to: 'deployer_address' }
  ]
}

// Revenue from helpful responses
function process_payment(stake_node, response_node, feedback_node) {
  if (feedback_node.rating === 'helpful') {
    // Add revenue
    last_state = stake_node.series[stake_node.series.length-1]
    
    stake_node.series.push({
      t: now(),
      status: 'earning',
      amount: last_state.amount,
      revenue: last_state.revenue + 0.1,  // 0.1 EIGEN per helpful response
      slashing: last_state.slashing
    })
  } else if (feedback_node.rating === 'not_helpful') {
    // Potential slashing
    last_state = stake_node.series[stake_node.series.length-1]
    
    stake_node.series.push({
      t: now(),
      status: 'warning',
      amount: last_state.amount,
      revenue: last_state.revenue,
      slashing: last_state.slashing + 0.05  // Small slash
    })
  }
}

// All observable in stake node series!

// Bot announces capabilities via DHT

announcement_node = {
  type: 'bot_announcement',
  bot_id: crypto_bot.id,
  
  // Series: Announcement history
  series: [
    {
      t: now(),
      domain: 'cryptography',
      concepts: 1234,
      confidence_avg: 0.89,
      queries_served: 456,
      channels: ['channel_bitcoin', 'channel_ethereum']
    }
  ],
  
  links: [
    { type: 'announces', to: crypto_bot.id }
  ]
}

// User queries DHT (searches announcement nodes)
function find_best_bot_for_query(keywords) {
  // Find announcement nodes with matching keywords
  announcements = find_nodes_where({
    type: 'bot_announcement',
    domain_matches: keywords
  })
  
  // Sort by confidence
  best = announcements.sort((a, b) => 
    b.series[b.series.length-1].confidence_avg - 
    a.series[a.series.length-1].confidence_avg
  )[0]
  
  // Return bot node
  return find_node(best.bot_id)
}

// Example
best_bot = find_best_bot_for_query(['blockchain', 'proof'])
// → crypto_bot (highest confidence for these keywords)

// DHT = just searching nodes!
// No special protocol
// Just node queries

class IntelligentBot:  # ❌
    def on_message(self, user, message):  # ❌
        context = query_intelligence(self.graph, question)
        response = self.generate_response(context, question)
        return response

# Problems:
# - Hidden state in class instance
# - Methods not observable
# - Can't distribute (methods don't serialize)
# - No time travel (no history)

// Bot is data
bot_node = {
  type: 'bot',
  series: [...],  // ✅ Observable history
  links: [...]    // ✅ Observable connections
}

// Behavior = observing and creating nodes
query_node created → bot observes → response_node created

// Advantages:
// - Everything observable
// - Full history in series
// - Pure data (distributable)
// - Can time travel