---
name: agent-o-rama
description: "Layer 4 Learning and Pattern Extraction for Cognitive Surrogate Systems"
---
# agent-o-rama
> Layer 4: Learning and Pattern Extraction for Cognitive Surrogate Systems
**Version**: 1.1.0 (music-topos enhanced)
**Trit**: +1 (Generator - produces learned patterns)
**Bundle**: learning
## Overview
Agent-o-rama trains learning agents on interaction sequences to discover behavioral patterns. It extracts temporal, topic, and network patterns from raw interaction data, producing models compatible with the cognitive-surrogate skill.
## Enhanced Integration: Multi-Interpreter
### DuckDB Pattern Storage
```sql
CREATE TABLE learned_patterns (
pattern_id VARCHAR PRIMARY KEY,
pattern_type VARCHAR, -- 'temporal', 'topic', 'network', 'skill'
pattern_data JSON,
confidence FLOAT,
learned_at TIMESTAMP,
seed BIGINT -- SPI seed for reproducibility
);
-- Temporal pattern query
SELECT
EXTRACT(HOUR FROM created_at) as hour,
EXTRACT(DOW FROM created_at) as day_of_week,
COUNT(*) as post_count,
AVG(response_time_minutes) as avg_response_time
FROM interactions
GROUP BY hour, day_of_week
ORDER BY post_count DESC;
```
### Python Predictor
```python
# agent_o_rama.py
import jax
import jax.numpy as jnp
from dataclasses import dataclass
@dataclass
class InteractionPredictor:
learning_rate: float = 0.01
epochs: int = 100
batch_size: int = 32
seed: int = 0xf061ebbc2ca74d78
def fit(self, db_path: str, table: str, validation_split: float = 0.2):
"""Train on DuckDB interaction sequences."""
import duckdb
conn = duckdb.connect(db_path)
data = conn.execute(f"SELECT * FROM {table}").fetchall()
# JAX training loop with SPI seed
key = jax.random.PRNGKey(self.seed)
for epoch in range(self.epochs):
key, subkey = jax.random.split(key)
# ... training logic
def predict(self, history):
"""Predict next interaction given history."""
return self.model(history)
```
### Ruby Skill Discovery
```ruby
# lib/agent_o_rama.rb
module AgentORama
def self.discover_skills(interactions, min_frequency: 5, coherence_threshold: 0.7)
# Group by inferred skill
skill_candidates = interactions.group_by { |i| infer_skill(i) }
skill_candidates.map do |skill_name, examples|
frequency = examples.size
coherence = calculate_coherence(examples)
next unless frequency >= min_frequency && coherence >= coherence_threshold
{
skill: skill_name,
frequency: frequency,
coherence: coherence,
exemplars: examples.first(3)
}
end.compact
end
def self.calculate_coherence(examples)
# Coherence via condensed stack descent
stack = WorldBroadcast::CondensedAnima.analytic_stack(
examples.map { |e| e[:id].hash }
)
stack[:descent_data].size.to_f / examples.size
end
end
```
### Hy Bidirectional Learning
```hy
;; From thread_relational_hyjax.hy - enhanced
(defclass ThreadBidirectionalLearner []
"Learn thread patterns by coupling reading (analysis) with writing (synthesis)"
(defn __init__ [self latent-dim]
(setv self.latent-dim latent-dim)
(setv self.read-patterns {})
(setv self.write-templates {})
(setv self.coupling-loss []))
(defn encode-thread [self acset]
"READ: ACSet → Latent representation"
(setv features
{:n-threads (len acset.threads)
:n-messages (len acset.messages)
:n-concepts (len acset.concepts)
:n-files (len acset.files)
:n-relations (len acset.related)
:concept-entropy (compute-message-entropy
(list (.values acset.concepts)))})
(setv latent (jnp.array
[(get features "n-threads")
(get features "n-messages")
(get features "n-concepts")
(get features "n-files")
(get features "n-relations")
(float (get features "concept-entropy"))]))
(setv (get self.read-patterns "latest") features)
latent)
(defn bidirectional-loss [self acset]
"Coupling loss: read → latent → write should reconstruct"
(setv latent (self.encode-thread acset))
(setv template (self.decode-thread latent))
;; Reconstruction error
(setv error
(+ (abs (- (get template "suggested-threads") (len acset.threads)))
(abs (- (get template "suggested-messages") (len acset.messages)))))
{:latent latent :error error}))
```
## GF(3) Triad Integration
| Trit | Skill | Role |
|------|-------|------|
| -1 | self-validation-loop | Validates learned patterns |
| 0 | cognitive-surrogate | Consumes patterns for prediction |
| +1 | **agent-o-rama** | Generates learned patterns |
**Conservation**: (-1) + (0) + (+1) = 0 ✓
## Justfile Recipes
```makefile
# Train interaction predictor
agent-train db="interactions.duckdb" epochs="100":
python3 -c "from agent_o_rama import InteractionPredictor; p = InteractionPredictor(epochs={{epochs}}); p.fit('{{db}}', 'interactions')"
# Discover skills via Ruby
agent-skills:
ruby -I lib -r agent_o_rama -e "puts AgentORama.discover_skills(interactions).to_json"
# Hy bidirectional learning
agent-hy:
uv run hy -c '(import lib.thread_relational_hyjax :as tra) (setv learner (tra.ThreadBidirectionalLearner 6)) (print "Learner ready")'
```
## Related Skills
- `cognitive-surrogate` (Layer 6) - Consumes learned patterns
- `entropy-sequencer` (Layer 5) - Arranges training data
- `acsets` (Layer 3) - Structured pattern storage
- `gay-mcp` - Deterministic seeding via SPI
