Yes! Contrary to the anthropomorphized subagents, I view them as ways of managing context primarily. I'm exploring this idea in Scope[0] to have observable subagents that recursively break down the task to avoid having to compact. One thing I haven't been able to figure out is how to evaluate/improve this planning step. I am using markdown files to encode heuristics for planning but it feels too unstructured for me to measure. Would love it if someone pointed me to some existing literature/projects around this idea!

[0] https://github.com/adagradschool/scope

Yeah, from the title, it sounds like perhaps the entire operation is differentiable and therefore trainable as a whole model and that such training is done. However, upon close inspection, I can't find any evidence that more is done than calling the model repeatedly.

They state:

> RLMs are not agents, nor are they just summarization. The idea of multiple LM calls in a single system is not new — in a broad sense, this is what most agentic scaffolds do. The closest idea we’ve seen in the wild is the ROMA agent that decomposes a problem and runs multiple sub-agents to solve each problem. Another common example is code assistants like Cursor and Claude Code that either summarize or prune context histories as they get longer and longer. These approaches generally view multiple LM calls as decomposition from the perspective of a task or problem. We retain the view that LM calls can be decomposed by the context, and the choice of decomposition should purely be the choice of an LM.

Unless that subagebt you call can call subagents itself which can call subagents themselves, ad infinitum, it's not recursive.

sub-agents that access (and manipulate) the SAME context (a file system or variables in the REPL)

Two differences that I see:

1. RAG (as commonly used) is more of a workflow, this thing is more "agentic"

2. The recursive nature of it

First, the way I see workflow vs. agentic: the difference is where the "agency" is. In a workflow, the coder decides (i.e. question -> embed -> retrieve -> (optional) llm_call("rerank these parts with the question {q} in mind") -> select chunks -> llm_call("given question {q} and context {c}, answer the question to the best of your knowledge") )

The "agentic" stuff has the agent decide what to search for, how many calls to make and so on, and it then decides when to answer (i.e. if you've seen claude code / codex work on a codebase, you've seen them read files, ripgrep a repo, etc).

The second thing, about recurrence has been tried before (babyagi was one of the first that I remember, ~ '23) but the models weren't up to it. So there was a lot of glue around them to make them kinda sorta work. Now they do.

attention is all you need but over and over and over and over... Precision is what we should ask for.

Isn’t codex open source and you can just go read what they do?

I have read the gemini source and it’s a pretty simple prompt to summarize everything when the context window is full