Uncorrelated context windows improve complex agent tasks

Transcript

Transcribed by machine (Whisper) from the episode’s audio, so a word may be off here and there.

1. 1:14:46

   it was I think yesterday or the day before when we're recording this podcast was agent teams and as I understand the idea with what agent teams, agent swarms instead of single agent you can have a lead agent and it can delegate to its different teammates how do you start experimenting with this and how did you decide to ship it now? We're always doing experiments right there's all sorts of ways to get more mileage out of quad code. One way you can do it is by extending context. Another way is auto-compacting context.

2. 1:15:19

   So it's essentially infinite context. And that's what we have right now. Another way is using sub-agents. So you have multiple agents kind of working together. There's just like a lot of different approaches to get a little bit more mileage out of the context window. There's this one idea called uncorrelated context windows. That's what we call it. And the idea is you have multiple context windows, but they essentially start fresh. So they don't know about each other.

3. 1:15:43

   And so an example of this is like a correlated context window is if you have one, if you have the model and it does a task and then you have it just do a second task in that same context window. And in this case, the second task knows about the first one because it's in the same window. But for something like a subagent, it's uncorrelated because the main agent prompts the subagent, but the subagent's context window is fresh.

4. 1:16:02

   Besides that prompt, it doesn't know what's in the parent context window. And you can see this actually a little bit in, for example, like subagents versus skills. because when you run a skill, you know, or a slash command, it sees the parent context window versus for a subagent, it doesn't. So it's uncorrelated. There's some cases where you want that context. There's some cases when you don't. And there's this kind of interesting thing where uncorrelated context windows and just throwing more context at the problem and throwing more tokens at it when the windows are uncorrelated gives you better results.

5. 1:16:35

   It's actually a form of test time compute to do this. And for something like Teams, we've been experimenting with this for a while, I think since maybe like October or September or something like this. And it really just felt like with Opus 4.6, it clicked where the model figured out really how to use this. And sometimes you see these kind of cute exchanges where the agents are talking to each other and they're like discussing something.

6. 1:16:59

   It's very cool to see. It's very like humanistic in a way. But there's other times where you just get very good results. And so we had a bunch of internal evaluations, for example, where we have quad build something very, very complex, something more complex than what a single quad would build. And we saw the results just really, really improve with Opus 4.6 with Teams. And that's why we felt it's the right time to release it.

7. 1:17:20

   We also wanted to be careful. And the reason you have to opt into it, the reason it's a research preview is it uses a ton of tokens because it's just a bunch of quads that are running. Not everyone wants this all the time. So just excited to see how people use it and, you know, to hear the feedback. It's something you want for fairly complex tasks. You don't probably want this for every task. The main clod decides the roles for the subclods.

8. 1:17:43

   We don't have a kind of a regimented way to do this. It's context specific. I wouldn't say there's one right way to do it. I think actually a lot of the magic of this comes out of this idea of uncorrelated context windows. It's less about the specific configuration of the agents. But, you know, it's something that people should experiment with.