RLM

RLM stands for Recursive Language Models: a long-context inference pattern where a model decomposes work, queries structured context through code or tools, and recursively calls into narrower subproblems instead of trying to force everything into one flat prompt.

On Quilt, that maps naturally to an isolated runtime with persistent workspace state, repeatable execution, and the ability to keep the model’s working context inside the environment rather than on a local laptop.

What RLM Is For

• recursive long-context reasoning over large or structured inputs
• code-backed context access through a REPL or script environment
• task decomposition where the model decides what to inspect next
• persistent trajectories, artifacts, and workspace state across runs
• isolated execution of agentic ML workflows on Quilt infrastructure
• optional GPU-backed execution through Quilt’s normal accelerator surface

Why It Matters In Quilt

RLM is not just “another CLI inside a container.” Its core value comes from the execution pattern itself.

In practice, Recursive Language Models need an environment that can:

• hold substantial local context and artifacts
• run Python or tool-driven inspection code safely
• persist trajectories and intermediate outputs
• resume sessions without rebuilding the environment from scratch

Quilt provides exactly that isolated runtime layer. RLM provides the recursive inference workflow on top of it.

This is the important split:

• RLM is the reasoning and execution model
• Quilt is the infrastructure and environment layer that hosts it cleanly

Quilt RLM Contract

On Quilt, RLM is not treated as an unstructured shell convenience. It has a specific runtime contract:

• the REPL acts only on state inside the Quilt environment
• admitted context lives inside /workspace
• local files become RLM context only after explicit sync into /workspace
• persistent runtime state lives under /workspace/.quilt/rlm
• manifests, trajectories, and artifacts remain attached to the environment instead of a local workstation

That execution boundary is the point of hosting RLM on Quilt. The environment is where the context lives.

Mental Model

Think about RLM as:

• a model-driven execution loop
• backed by code, tools, and a working filesystem
• designed for context retrieval, recursive decomposition, and long-horizon problem solving
• running inside a Quilt-hosted environment when you want isolation, persistence, and reproducibility

Do not think about it as a generic prompt wrapper or a one-shot chat interface.

Practical Shape

The practical RLM workflow usually looks like this:

• start with a task, prompt, or script
• sync or generate the files and data the model should work on inside /workspace
• inspect files, data, or prior outputs from a real runtime
• recurse into narrower subtasks when needed
• record trajectories, artifacts, and state for later review or continuation

That execution style is why RLM fits well on Quilt. The environment is part of the product, not an afterthought.

Native Container Selection

Quilt surfaces RLM through the same native container selection model it uses for other curated runtimes.

The direct path is one isolated runtime, one workspace, and one persistent RLM state tree selected as a first-class Quilt container image such as rlm.

Quilt-native multi-agent or mesh-oriented orchestration can still build on that same environment-local RLM model, but the base RLM runtime is not a separate launcher product.

Runtime Shape On Quilt

The RLM runtime on Quilt is designed around:

• a canonical workspace at /workspace
• a canonical RLM state root at /workspace/.quilt/rlm
• repeatable session reuse
• explicit local context sync
• optional persistent workspace volume attachment
• GPU-ready launcher scaffolding when the workflow needs accelerated execution

When To Reach For It

Situation	Better choice
You need recursive reasoning over large or structured context	RLM
You want isolated, persistent execution for long-running agentic ML workflows	RLM on Quilt
You want the runtime to stay bound to environment-local context instead of laptop-local state	RLM on Quilt
You need raw runtime APIs or direct container control	Quilt runtime docs
You need infrastructure orchestration across clusters and workloads	quiltc

Runtime Entry On Quilt

RLM is a real ML execution model first, and Quilt is the infrastructure layer that makes it practical to run as an isolated, persistent product surface.

Users access the curated RLM environment through Quilt’s normal container selection flow, the same way they choose other native Quilt runtimes.