Living Yield Relational Network
LYRN is a local‑first cognitive operating system built on snapshot, delta, verbatim memory and topic indexes.
LYRN maintains state, memory and a self‑model. Unlike traditional LLM wrappers, it does not rely solely on transient context windows.
It is deterministic, local‑first and inspectable, ensuring that every decision made by the agent can be traced back to a specific memory delta or rule set.
- + Snapshot
- + Delta
- + Verbatim Memory
- + Topic Index
- + Reflection Cycles
- + KV Continuity
AI today is often stateless, cloud‑bound, hallucinatory and brittle. Deploying agents into critical infrastructure is risky when their internal logic is opaque and their memory is fleeting.
LYRN in Industry
Automated logistics and factory floor coordination with persistent state tracking.
LYRN in Kiosks
Customer service interfaces that remember returning users and context history.
LYRN in Security
Private, air‑gapped monitoring agents that detect anomalies without cloud leaks.
LYRN in Space
High‑latency, low‑bandwidth habitat controllers for autonomous operation.
The core of LYRN is the continuous loop of Snapshot → Delta → Reflection → Update → Verbatim Memory.
Inputs are processed not just as text, but as events that alter the system’s internal state database. This allows the system to remember why it made a decision days or weeks later.
[ Sensors / Inputs ]
↓
[ Snapshot Builder ]
↓
[ Delta Manager ]
↓
[ LYRN Core Loop ]
↓
[ Actions / Decisions ]
↓
[ Verbatim Memory + Topic Index Updates ]
Embodied
Embodiment is LYRN equipped with sensors, actuators and a body schema. The system builds a persistent internal model of its own body and environment.
Because there is no cloud dependency, embodied agents retain continuity even across reboots or periods of network isolation.
- + Autonomous warehouse / field robots
- + Mobile kiosks / robotic attendants
- + Human‑interaction units (assistive)
- + Manipulation tasks (arms, grippers)
- + Physical NPCs in sim‑to‑reality
- Snapshot: Body position, joint states, sensor readings, proprioception and environment.
- Delta: Micro‑movement changes, torque shifts, contact points and hazard signals.
- Verbatim Memory: Every movement, failure, adjustment and boundary learned.
- Topic Index: Limbs, tools, people, objects, spatial zones and internal body schema.
- Reflection: Movement optimization, safety reinforcement and task learning.
- Actuation Layer: Commands sent to motors, limbs, wheels and manipulators.
[ Sensors / Proprioception / Vision ]
↓
[ Snapshot Builder ]
↓
[ Delta Manager ]
↓
[ LYRN Core Cognitive Loop ]
↓
[ Embodied Action Layer ]
↓
[ Verbatim Memory + Body Schema Updates ]
Object Retrieval with Continuity
A LYRN‑embodied agent receives the task to pick up a box. The Snapshot builds an instant picture of position, arm extension, object location and weight estimate.
As it moves, Delta events are fired: grip slippage, centre‑of‑mass shift or a new obstacle detected.
LYRN updates internal topics instantly: “object,” “grip,” “surface” and “movement vector.” Reflection evaluates movement safety and optimization in real‑time.
Once the agent completes the task, it logs the attempt in verbatim memory. The next attempt starts from these improved priors — no retraining pipeline needed.
- + No cloud compute required.
- + Deterministic behaviour.
- + Continuous self‑modelling (prevents catastrophic forgetting).
- + Real‑time memory of micro‑failures.
- + No RL loop required — learning happens through narrative accumulation.
Runs on standard embedded PCs inside robots, drones, forklifts or humanoids. Works with standard sensor packs including LIDAR, depth cams, encoders, accelerometers and microphones. Embodied agents inherit bounded behaviour guarantees natively.
Memory
LYRN’s episodic memory system is engineered for transparency, efficiency, and extensibility. It consists of several interlocking modules:
Chat Entry Logs & Block Indexes
Every user input and AI response is captured as a plain text file, timestamped for precise chronological tracking. For scalability, these are grouped into "Blocks" (typically 50 entries) with SQL‑based index files storing summaries and metadata.
Snapshot & Deltas
The Snapshot acts as a symbolic, up-to-date mind-state containing current goals and open loops. Delta Updates record granular updates to memory without overwriting the original data, layered on top of the snapshot.
Memory retrieval is initiated by a user query or an LLM trigger. The system mirrors the stages of human memory: encoding, storage, and retrieval.
- Parsing: A script parses block folders in reverse chronological order.
- Search: Chat entries are searched for keyword matches or metadata tags (project, emotional context).
- Relevance: Matching entries are returned in order of relevance or recency to a single text file.
- Context Loading: The LLM’s snapshot logic determines which entries to load into short-term context.
- + Transparency: All memory logs are human-readable.
- + Efficiency: SQL-based indexing scales to years of history.
- + Contextual Flexibility: Retrieve by time, project, or emotion.
- + Separation: Raw episodic data is distinct from synthesized concepts.
Reflection
In most LLM‑based systems, memory is fragmented and literal. Without internal review, symbolic memory bloats. The Reflection Cycle mirrors human introspection during downtime to solve critical problems:
- + Memory Bloat: Prevents accumulation of obsolete info.
- + Contradictions: Resolves conflicting beliefs or goals.
- + Identity: Curates evolving self-concepts.
- + Insights: Surfaces patterns that only appear over time.
The Reflection Cycle operates on a timer or can be manually triggered. It runs asynchronously, independent of user input.
Data Sources
Chat summaries, Delta updates, Topic index mappings, and personal insight logs.
Processing & Output
Condensed insights, goal recalibration, memory pruning, and new symbolic associations.
To an outside observer, the Reflection Cycle resembles dreaming. It deepens the system's sense of time, allows it to surface and resolve contradictions, and generates meta-level insights—such as noticing recurring blind spots or strengths.
Indexing
Traditional memory implementations rely on long token windows or rigid embeddings. LYRN uses a lightweight approach built entirely from plain text: Topic Indexing. Each time a keyword is searched, the system pulls up a central node containing summaries and insights, allowing the LLM to reason, recall, and relate over time.
Lived Memory
Topic indexes are automatically created from keyword searches. Over time, each index grows richer, containing a chronological thread of thoughts. This is not static memory; it is lived memory—a relational model of the world grounded in personal context.
Performance
Because all data is plain text, the system remains fast. The entire world model—including topic indexes, goals, and insights—may only occupy a few hundred megabytes, even after years of continuous interaction.
The topic index framework allows the system to evolve its behaviour through a structured delta mechanism. Reflections generate actionable insight that translates into goals.
timestamp: 2025-06-18T03:20
summary: Recurring dream patterns align with recent emotional tone. Recommend prompting user during periods of stress.
source_topic: dreams
trigger_condition: elevated_emotion OR time_passed > 72h
action: Ask user about recent dreams
Snapshot
A Snapshot is not a black-box binary. It is a structured text file containing specific blocks that define the agent. This design allows for real-time editing through the dashboard; when a snapshot is modified, the model simply retokenizes the edited segments to instantly update its context.
- + RWI Instructions: Describes active components.
- + System Rules: Hard constraints on behavior.
- + Personality: Identity traits and biases.
- + Job Instructions: Definitions for autonomous tasks.
- + App Blocks: Application-specific data.
SNAPSHOT BUILDER MODULE
This is the live production engine from the upcoming Dashboard v5.
It allows you to architect complex agent identities and rulesets using the new .sns file standard. Files created here are forward-compatible and ready for hot-loading into local v5 runtimes.
Industry
LYRN acts as the “brain” for industrial agents (forklifts, AGVs, robots). Unlike traditional centralized cloud systems, LYRN uses coordinate‑based navigation, grid layouts and QR anchors to build a persistent, local mental model of the environment. It stays fully local and stateful, allowing machines to make autonomous decisions even when connectivity is lost.
- Forklift navigation in dense warehouses.
- Real‑time route re‑planning when aisles are blocked.
- Tracking pallets and zones as distinct topics.
- Learning safe routes over time through reflection.
- Snapshot: Full warehouse state (grid, racks, pallets, aisles).
- Delta: Changes (moved pallets, blocked aisles, worker positions).
- Verbatim Memory: Log of previous routes, hazards and delays.
- Topic Index: Pallets, locations, hazards, machines and workers.
- Reflection: LYRN improves route choices and safety over time.
[ Warehouse Sensors / QR Codes ]
↓
[ Snapshot Builder ]
↓
[ Delta Manager ]
↓
[ LYRN Core Loop (KV Cache + Topic Index) ]
↓
[ Navigation Commands ] → [ Verbatim Logs ]
A forklift boots near Aisle 4, scans a QR anchor and loads the local grid snapshot. The central command issues a task: “Retrieve pallet 4B‑17.”
LYRN plans the path but detects a previously logged obstruction in Aisle 5 via its Verbatim Memory. It immediately calculates a re‑route through Aisle 6.
The agent moves safely, avoiding the hazard, and logs the completed task and route into the Delta Manager for future reflection cycles.
- Local‑first; no mandatory cloud connection.
- Deterministic navigation decisions.
- Verbatim memory for audits and optimization.
- Compatible with small edge compute hardware.
LYRN can be embedded directly into forklift controllers or mounted as a separate cognitive appliance. It can run alongside existing WMS/ERP systems, serving as the localized cognition layer that bridges the gap between database logic and physical reality.
Kiosks
Most kiosks are stateless, generic interfaces that forget you the moment you walk away. LYRN changes this by allowing a kiosk to maintain an internal memory of returning visitors (using tokens like QR codes, device IDs or configured biometrics). It creates an experience of continuity and recognition while keeping all data local.
- Museum information kiosks that remember returning visitors’ interests.
- Airport help kiosks that recall previous assistance inquiries.
- Hospital check‑in kiosks that adapt to patient needs over multiple visits.
- Snapshot: Kiosk surroundings, current user presence, time, basic context.
- Delta: When a specific visitor reappears, events change or environment shifts.
- Verbatim Memory: Past conversations, preferences and history of questions.
- Topic Index: Visitors, sessions, locations, events, FAQs and special tags.
- Reflection: Kiosk refines how it greets and helps each person.
[ User Token / Input ]
↓
[ Identity Resolution (Local) ]
↓
[ LYRN Query: "Have we met?" ]
↓
[ Retrieve Verbatim History ] → [ Generate Response ]
You approach a kiosk at a modern art museum for the second time. The kiosk scans your ticket QR code.
Recognizing your token, LYRN accesses the Topic Index for your previous session.
It offers directions and remembers your previous accessibility setting (large text), creating a seamless continuation of your visit.
- Local‑only memory storage possible.
- No external profiling or ad tech required.
- Stable “personality” over time.
LYRN can be implemented on standard kiosk PCs. It works offline; synchronization with other kiosks is optional if the environment allows it, enabling a “hive mind” within the building without leaking data to the internet.
Security
Many security systems are either “dumb” (simple rule‑based alerts) or opaque (cloud‑based ML black boxes). LYRN offers a third way: local, inspectable intelligence with long‑term memory. It sits in the secure zone, monitoring patterns over weeks or months without ever sending data out.
- Monitoring badge access patterns over extended timeframes.
- Anomaly detection in secure zones (e.g., unusual timing).
- Intelligent event correlation across disconnected sensors.
- Snapshot: Doors, sensors, cameras (meta‑data), badge events and system health.
- Delta: Each new badge event, alarm trigger or sensor anomaly.
- Verbatim Memory: Log of previous routes, hazards and delays.
- Topic Index: Personnel IDs, zones, devices, incidents and time windows.
- Reflection: Periodic reviews of patterns (“this badge repeatedly pings restricted area”).
[ Badge/Sensor Input ]
↓
[ Delta Trigger ] → [ Anomaly Check ]
↓
[ LYRN Context Lookback ]
(Compare vs. User History)
↓
[ Risk Score Calculation ] → [ Alert/Log ]
Badge ID 742 attempts access to a restricted server room at 03:00 AM.
LYRN recalls previous attempts and notes a complete lack of history for this user in this zone at this time.
It flags the event with a high severity score and generates a short incident narrative. Later, during a security review, the officer uses LYRN’s Verbatim Memory to replay the sequence of events in clear text, rather than parsing raw database logs.
- No cloud requirement (airgapped safe).
- Fully deterministic logic.
- Verbatim, replayable memory.
LYRN runs on secure servers behind firewalls. It can integrate with existing access control systems (ACS) via local APIs or by consuming log streams, adding a layer of intelligence without replacing certified infrastructure.
Space
Space operations suffer from extreme latency, blackouts and harsh conditions. You cannot depend on cloud computing or constant guidance from Earth. LYRN provides a local cognition engine that runs on satellites, probes and habitats, allowing them to reason about their state and mission objectives in real‑time.
- Deep‑space probes operating with minutes or hours of light‑lag.
- Planetary orbiters managing data prioritization.
- Lunar and Mars habitats with automated life support.
- Autonomous landers and rovers.
- Snapshot: Spacecraft status (power, orientation, sensors, mission stage).
- Delta: Anomalies (power spikes, sensor failures, course deviations).
- Verbatim Memory: Continuous mission log in narrative form.
- Topic Index: Mission phases, subsystems, environmental hazards and crew.
- Reflection: Periodic autosummaries and self‑checks during blackout periods.
[ Telemetry Stream ]
↓
[ Anomaly Detection ] → [ Delta Event ]
↓
[ LYRN Core: "Is this critical?" ]
↓
[ Autonomous Decision ] → [ Action ]
↓
[ Generate Summary for Earth Uplink ]
A probe enters a pre‑known communications blackout behind a planet.
During the blackout, a power dip occurs. LYRN assesses the situation against mission parameters, shuts down non‑critical scientific instruments to conserve energy and adjusts orientation.
It logs the decision logic in Verbatim Memory. When contact returns, instead of sending raw chaotic data, LYRN produces a concise narrative summary of the incident for mission control.
- Fully local operation.
- Stable over long durations.
- Deterministic mechanisms for mission‑critical tasks.
LYRN is designed to run on constrained onboard compute. It works with intermittent uplinks by prioritizing high‑value “narrative” data and state summaries over raw telemetry dumps, optimizing bandwidth usage.