Not sure yet
Recursive language models and the deterministic turn in agentic systems
TomLast changed February 13, 2026Lately I’ve been noticing a convergence across three seemingly unrelated domains. Recursive language models propose deterministic evaluation trees for reasoning; observational memory compresses ephemeral context into log-based state; and orthogonal conditions in Kubernetes controllers have long maintained the ground truth of distributed systems. The common thread is a shift from event-driven narratives to state-based observations as the foundation of reliable computation.
This is the same pattern that repeats across software history: the transition from procedural chaos to declarative truth. Just as RAG served as the preamble to search-native thinking before LLMs democratized it, these three vectors point toward a future where agents operate not on prompt history, but on compressed, queryable state.
Recursive language models and the return of determinism
The Recursive Language Model (RLM) framework treats generation not as linear token prediction but as tree-structured recursive evaluation. The core insight: reasoning follows deterministic decomposition patterns rather than purely stochastic sampling chains.
Traditional autoregressive models operate as event streams; each token conditions on the previous, creating an irreversible temporal dependency. RLMs instead construct evaluation trees where intermediate states can be revisited, verified, and recomputed. The model maintains observational checkpoints at each recursive branch, enabling backtracking without full context recomputation.
This mirrors the fundamental insight Brian Grant articulated regarding Kubernetes conditions: state must be reconstructable by observation alone, not dependent on event history. The RLM tree structure implements this for language: each node represents a condition of the reasoning process (verified, unverified, contradicted), readable by any downstream component without replaying the entire generation chain.
Observational memory as orthogonal conditions for LLMs
Tyler Barnes and the Mastra team recently shipped observational memory, a system that compresses agent context into log-based observations rather than vector embeddings or knowledge graphs. The format resembles structured logging: formatted text with emoji-based prioritization (🔴 critical, 🟡 relevant, 🟢 informational), grouped by dates with temporal metadata.
Date: 2026-01-15
- 🔴 12:10 User is building a Next.js app with Supabase auth, due in 1 week (meaning January 22nd 2026)
- 🔴 12:10 App uses server components with client-side hydration
- 🟡 12:12 User asked about middleware configuration for protected routes
- 🔴 12:15 User stated the app name is "Acme Dashboard"
The architectural decision is significant: observations function as orthogonal condition types rather than event sequences. Where traditional memory systems store chat history (events), observational memory stores state snapshots (conditions). The system maintains a Ready-equivalent condition indicating operational status, alongside specialized conditions for user intent, system constraints, and temporal references.
This is Kubernetes conditions translated to LLM context management. As Grant noted in 2019 regarding the evolution of Kubernetes API patterns: the project moved from rigid state machines to “non-orthogonal, extensible conditions” precisely because reality refuses to fit into mutually exclusive categories. Observational memory implements this open-world assumption: the absence of an observation means Unknown, not False.
The compression mechanism reinforces this pattern. When raw messages hit 30k tokens, an “observer agent” compresses them into observations appended to the first block; when observations hit 40k tokens, a “reflector agent” garbage collects stale conditions. This two-tier system mirrors the Kubernetes pattern where kubelet and kube-scheduler maintain separate condition types on the same object, each responsible for their orthogonal domain.
The observer-mailbox pattern and cross-domain echoes
Prior to Mastra’s work on observational memory, I’ve been experimenting with this convergence in observer-mailbox, treating observations as ambient/background conditions that agents query without full context loading. The library implements the Kubernetes pattern for LLM memory: condition types represent cross-cutting concerns rather than sequential history.
The insight from distributed systems applies directly: components communicate more reliably through state than through messages. In Kubernetes, the kube-scheduler does not message the kubelet; it sets a PodScheduled condition that the kubelet observes. Similarly, observational memory allows parallel agents to set conditions (🔴 User blocked on auth, 🟡 Dependency update available) that other agents observe without parsing full chat history.
This creates the deterministic foundation required for reliable multi-agent systems. When agents share memory through orthogonal conditions rather than event streams, they achieve the same loose coupling that makes Kubernetes controllers composable. The mailbox pattern treats observations as the ground truth API between agents; events become merely the transport, not the source of truth.
The historical drift from events toward state
We’ve seen this transition before. In software architecture, we moved from procedural imperative code to declarative infrastructure-as-state. In networking, we shifted from circuit-switched connections (events) to packet-switched stateless protocols. In data management, we transitioned from event sourcing as primary storage to state snapshots with event logs as optimization.
RAG itself followed this trajectory. Before LLMs, RAG was essentially search engine thinking: compress the corpus into a queryable state (index) rather than replaying the crawl history. The embedding database became the condition set; similarity search the observation query. Only after ChatGPT did we revert temporarily to treating context as event history (the “chat” metaphor), before realizing again that state-based observation scales better.
The recursive language model completes this triad. Where observational memory provides the storage layer of state-based agent systems, RLMs provide the computation layer: deterministic evaluation trees that respect the same observational constraints. Together, they enable what we might call orthogonal agency: agents that coordinate not through message passing, but through shared condition states.
Noticing the pattern
What connects the dots between recursive language models, observational memory, and orthogonal conditions is a shared rejection of irreversible computation. Event streams are irreversible; once the token is generated, the context window shifts. State observations are reversible; conditions can be updated, cleared, or reverted independently.
This determinism is prerequisite for reliable autonomous systems. As Peter Steinberger noted regarding high-autonomy agent workflows: safety comes from blast radius containment and state reconstruction, not from reviewing every diff. When agents operate through observable conditions rather than opaque event chains, we gain the inspectability required for high delegation.
The convergence suggests we are approaching the endgame for agentic architecture: not agents as conversational partners, but as stateful controllers operating on declarative observations. The future looks less like ChatGPT and more like Kubernetes: a mesh of orthogonal controllers maintaining conditions, with humans querying state rather than micromanaging transitions.
The recursive structure of reasoning, the observational compression of memory, and the orthogonal decomposition of status: three vectors pointing toward the same destination. Deterministic state over stochastic events; observation over narration; conditions over chat.
References
Curious User is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.