• conforms_to::[[Reference Form Contract]]
• serves_as::[[Evidence That Surveyed RLM Context Boundaries Are Serialization or RPC]]
• in_practice_domain::[[eOS Continuum]]
• authored_by::[[Christopher Allen]]
• has_lifecycle::[[Seed Stage]]↗
• has_curation::[[Working Draft]]↗

RLM Architectures Survey (Allen, 2026)

Survey of seven Recursive Language Model implementations, conducted 2026-05-18 in two passes. The first pass asked whether any project treats this graph's runtime primitives as load-bearing and produced a negative result without architectural sharpness; the second pass reframed from the RLM side outward -- per project, what context-access architecture enables the defining RLM shape, "enabling the LM to programmatically examine, decompose, and recursively call itself over its input" (alexzhang13/rlm's self-description) -- and produced the load-bearing findings below. Every URL was verified in main context on 2026-05-18, including one quote-attribution correction made during verification.

Surveyed

• https://github.com/openprose/unix-rlm -- bash RLM loop; "The filesystem is the heap" (literal in the README); context fed by pipe via $RLM_INPUT; recursion via rlm calling itself.
• https://github.com/rawwerks/ypi -- $CONTEXT file path plus a jj workspace per recursive child; hashline line-addressed-edits API; five concentric guardrails (depth, PATH scrubbing, call count, budget, timeout).
• https://github.com/rawwerks/rlm-cli -- in-process REPL with Tantivy (tv.*), ripgrep (rg.*), and opt-in PageIndex (pi.*) as the LM's context tools.
• https://github.com/alexzhang13/rlm -- two modes: local Python exec via LocalREPL, or isolated execution via Docker, Modal, Prime, Daytona, E2B, or IPython. The reference interface: rlm.completion(prompt, model) -- an RLM presents as a language model -- with in-environment llm_query / rlm_query (and batched variants) bounded by max_concurrent_subcalls, and persistent=True giving multi-turn sessions via versioned context_N / history_N. Its seven environments all manage the same isolation-versus-persistence-versus-latency tradeoff (local is fast but "should not be used for production"; the isolated ones buy containment at the cost of process boundaries, cold starts, and "host callables cannot cross the process boundary"), and its stated design position moves away from JSON tool-calling toward code-as-action.
• https://github.com/codecrack3/Recursive-Language-Models-RLM-with-DSpy -- DSPy orchestration; execution via E2B sandbox (cloud) or RestrictedPython (local).
• https://github.com/openai/symphony -- self-defines as "a service that orchestrates coding agents", not an RLM; persistence explicitly not runtime-provided ("exact in-memory scheduler state is not restored... Restart recovery is tracker-driven and filesystem-driven").
• https://blog.cloudflare.com/project-think/ -- persistent actor per agent on Durable Objects ("Each agent runs on a Durable Object -- a stateful micro-server with its own SQL database"); "there's no implicit sharing of data between them" -- the parent-child boundary is RPC across isolated SQLite stores. Blog-specific mechanism claims (stash(), onFiberRecovered, globalOutbound: null) are absent from the shipping Agents SDK docs and read as preview or research.

Findings

Two dominant context-access patterns. (1) Process-per-step with context passed by path: unix-rlm's filesystem-as-heap plus $RLM_INPUT; ypi's $CONTEXT file plus per-child jj workspace; Symphony's per-issue workspace directory; alexzhang13/rlm's isolated mode. (2) In-process REPL where context is a variable: codecrack3 with RestrictedPython or E2B; alexzhang13/rlm's local exec; rlm-cli with its search helpers. Only Project Think reaches persistent-actor-per-agent with typesafe RPC, and Think states the actors share nothing implicitly.

Four architectural gaps that an orthogonally-persistent runtime with typed-property addressing and a capability sublanguage fills by runtime contract rather than by application discipline:

1. Live persistent object identity shared across recursive calls -- every surveyed project serializes parent-to-child context.
2. Typed property-graph addressing -- six of seven address context by file path or Python variable name; Think reaches typed structure inside SQLite but its inter-agent surface is opaque RPC.
3. Cross-session memory by runtime contract, not save/load -- the REPL variable an LM uses across two completion calls survives in none of the six non-Think projects.
4. Language-level capability passing to sandboxed children -- sandboxing across the seven is a deployment choice; none offers a safe sublanguage in which a child sees only the capabilities the parent explicitly hands it.

The claim this evidences. An orthogonally-persistent property-typed runtime with a Merry-style capability sublanguage enables an RLM architecture in which the parent and child see the same live property graph by identity rather than by value-copy, the recursive call is a capability hand-off over a typed predicate-addressable surface that survives runtime restart, and the child operates inside a language-level sandbox the parent constructed without process or VM fan-out. No surveyed RLM matches that shape, because every one's parent-to-child boundary is either serialization or actor-RPC across isolated stores.

Falsification condition. The claim fails if a surveyed project (or a successor) shows a parent and recursive child sharing live object identity across a restart without serialization, or hands a child a bounded capability surface at the language level rather than the process/VM level. Either observation retires the uniqueness claim and demotes this node to lineage evidence.

Sources

• Survey passes: two subagent passes 2026-05-18, second pass authoritative; all seven URLs main-context verified the same day (three spot-checked early, five via gh api .../readme), with the alexzhang13/rlm quote attribution corrected to rawwerks/ypi during verification.
• Stub note: authored 2026-08-07 from the verified 2026-05-18 survey record. First empirical exercise of the claim's runtime half now exists: this repository's spikes demonstrate recursion-shaped state surviving statedump/restore with object identity preserved, transactional outbound initiation inside atomic envelopes, and a live tool-calling exchange from inside the runtime; the eOS-Harness MVA architecture document records how each claim is leaned on.

Relations

• conforms_to::[[Reference Form Contract]]

  • Survey Reference: external implementations read against the graph's argument.

• informs_downstream::[[Agent Runtimes Require Native Primitives, Not External Glue]]

  • Every surveyed RLM rebuilds context persistence and isolation as application-layer machinery over serialization or RPC; the four gaps are exactly the properties the argument claims belong to the runtime.

• informs_downstream::[[eOS-Harness Minimum Viable Architecture]]

  • The unique-approach claim and its falsification condition are the argumentative foundation for the harness/runtime boundary the MVA document fixes.