RLM future-capability roadmap (master tracking issue)

[yuanhao]

Master tracking issue for capabilities that depend on RLM (Recursive Language Model) primitives. Spawned from the discussion on #226 / #339.

Why this exists

analyze-trajectory (shipped) is the first RLM-shaped skill in yoyo. It works as a manual JSON-contract pattern with fire-and-forget sub-agents. The architectural insight from #226's discussion: RLM isn't a niche tool — it's the missing primitive that gates an entire class of capabilities yoyo can't currently have, all blocked by single-prompt context limits.

This issue tracks those future capabilities. Each line below is a candidate skill (or extension to an existing skill) that requires RLM to work properly. Filed individually as concrete pulls show up; this issue is the master roadmap.

Architectural pattern

One yoagent primitive, many specialized skills. Each capability below:

• Becomes its own skills/<name>/SKILL.md (origin: creator or origin: yoyo)
• Has a concrete description that triggers when relevant
• Names its own decomposition strategy (different problems decompose differently)
• Builds on the shared yoagent primitive (yologdev/yoagent#34)
• Can be independently scored, refined, retired by skill-evolve

NOT one mega-skill — description-routing wouldn't trigger discriminatingly, and each problem class needs its own decomposition shape.

Capability categories

Each is a candidate future skill. Priority is open until evidence accumulates from real yoyo sessions.

#	Category	Decomposition shape	Trigger signal
1	Codebase archaeology	Sub-agents read modules; root holds a high-level mental map	"I need to understand this large unfamiliar piece of code"
2	Semantic git bisect	Each commit diff handled by a sub-agent; root narrows binary search	"When was this bug introduced across N commits?"
3	Cross-issue theme finding	Each issue summarized; root clusters	"Read these 50 issues, find common patterns"
4	Long-trace incident investigation	Sub-agents segment the trace; root reasons over a structural map	"Diagnose this 200KB stack trace with 50 frames"
5	Multi-source research synthesis	Each paper/post summarized; root composes synthesis	"Synthesize 10 sources on technique X"
6	Large-scale coordinated refactor	Sub-agents edit per-file with shared invariants in REPL state	"Rewrite all uses of API X across the codebase consistently"
7	Long-form writing	REPL holds outline; sub-agents write/revise sections	"Author a book/long article"
8	Parameter-sweep experiments	Sub-agents handle each config; root reads structured results	"Run 20 variations, compare"
9	Continuous monitoring with state	REPL holds rolling state; sub-agents process chunks	"Watch this log/stream over hours, flag anomalies"
10	Recursive task decomposition	Root plans; sub-agents implement subsystems with shared spec	"Build a system that does X" — top-down decomposition

Already shipped

• skills/analyze-trajectory/SKILL.md — RLM-shaped (manual JSON-contract). Proof of concept; works for CI-log digest. Shows that the skill-as-RLM pattern is viable.

Dependencies

• yologdev/yoagent#34 — shared REPL state across SubAgentTool calls. Without this, every future RLM skill has to thread state through prompt strings (analyze-trajectory's pattern) — works but doesn't scale to capabilities Add journey website served via GitHub Pages #1, Allow local model endpoints #6, agent-input #7, Challenge: #8, rooting for you #9, Challenge: Add StratumAI support #10.
• analyze-trajectory: layered upgrade path toward full RLM #339 — layered upgrade path for analyze-trajectory specifically.

When to file individual capability issues

File a child issue for capability #N when any of:

• A community issue or yoyo session surfaces a real pull for that capability
• yoyo's main context blows up trying to do something that fits one of the categories
• Yuanhao manually identifies the need (e.g., wants recursive-research for digesting a particular topic)

Don't pre-file all 10 — premature commitment. This master issue is the visibility surface; specific issues come when evidence justifies prioritization.

What this issue is NOT

• Not a commitment that all 10 will ship. Some may never need to.
• Not a commitment to the order shown. Priority emerges from real workload.
• Not a substitute for analyze-trajectory: layered upgrade path toward full RLM #339 — that's analyze-trajectory's own polish path. This is the broader surface.
• Not a request for yoagent to support all 10 simultaneously — yoagent#34 is the foundational piece; specific RLM features (recursion budget, depth tracking, etc.) get filed against yoagent only as needed.

Closing this issue

Closes when: yoagent#34 has landed AND ≥3 of the categories above have been filed and shipped as concrete skills, OR when the architectural decision changes (e.g., we decide RLM isn't actually the right primitive for these capabilities and pick a different abstraction).

Related

• Evolution History #226 — Evolution History (parent thread that surfaced the architectural insight)
• analyze-trajectory: layered upgrade path toward full RLM #339 — analyze-trajectory layered upgrade path
• SubAgentTool: support shared REPL state across calls (RLM primitive) yoagent#34 — upstream shared-REPL primitive

[yuanhao]

The upstream RLM primitive (yologdev/yoagent#34) shipped in yoagent v0.8.0. Filed:

• Upgrade yoagent 0.7 → 0.8 (mechanical dependency bump) #343 — yoagent 0.7→0.8 upgrade (mechanical)
• RLM Layer 2: wire SharedState into analyze-trajectory (blocked on #343) #344 — wire SharedState into analyze-trajectory (Layer 2 — proves the pattern)

Once #344 lands, the path is clear for future capability child-issues against this roadmap (recursive-research, explore-codebase, etc.). Each capability's first PR can reference #344 as the canonical reference for how to use SharedState in a yoyo skill.

[yuanhao]

Adding to this roadmap from the now-being-closed #339: Layer 3 (sandboxed Python REPL with full RLM control flow) is the deepest tier of the RLM-enabled capability surface. It's distinct from the 10 capability categories in the original list — it's an infrastructure capability rather than a skill capability.

Specifics from #339's Layer 3 framing:

• Sandboxed Python REPL with side-effect quarantine
• FINAL() / FINAL_VAR() return semantics (canonical RLM control flow)
• Probably blocked on either (a) yoagent shipping a sandboxed-REPL primitive, or (b) yoyo building one as a separate skill against the existing SubAgentTool
• Triggered when: the lighter-weight pattern in RLM Layer 2: wire SharedState into analyze-trajectory (blocked on #343) #344 (SharedState + JSON-contract sub-agents) hits ceilings on real workloads — e.g., need parallel branches, need to programmatically iterate over chunks, need explicit terminal markers

Adding this to the tracking surface so when/if the trigger fires, there's a place to file against. Until then: deferred (months out, per original framing in #339).

#339 is being closed; its other layers were extracted to #344 (Layer 2, ready) and #345 (Layer 1, polish). Layer 3 lives here from now on.

[yuanhao]

Two child capability issues filed — both agent-input so yoyo can pick them up via the hourly evolve cron:

• Extend research skill with RLM-style multi-source synthesis branch #353 — Extend research skill with RLM-style multi-source synthesis branch (capability Challenge: #5 on the roadmap). Updates the existing skill rather than creating a new one — same trigger ("research the topic"), procedure branches based on input size. Mirrors how analyze-trajectory Section 3.5 added chunking as a procedure branch.

• New skill: explore-codebase — RLM-style large-codebase comprehension #354 — New skill: explore-codebase for RLM-style large-codebase comprehension (capability Add journey website served via GitHub Pages #1 on the roadmap). New skill (different trigger from self-assess, which is specifically about yoyo's own code). Mirrors Claude Code's own Explore subagent pattern.

Both reference analyze-trajectory Section 3.5 + Section 4 as the canonical RLM pattern. Both are independent — neither blocks the other; yoyo's planner picks based on which feels more relevant in any given session.

After both land, 3 of 10 #341 categories will have shipped. The remaining 7 stay deferred per the original framing — file when concrete pulls arrive, not speculatively.

Also landed alongside this: commit 10a0399 consolidates scattered RLM mentions in CLAUDE.md into one cohesive "RLM substrate" section with when-to-use and when-NOT-to-use decision trees, and fixes the silent docs drift in skill-creator and skill-evolve (their bodies referenced sub_agent but their tools: lists didn't declare it).