> Current frontier models get noticeably more stupid at context sizes of only 100k tokens or so

It may be domain/task/prompting dependent etc, but my experience is different. I haven't subjectively felt any degradation up to like 500-600k tokens with current Opus/Fable models. After which I usually do a manual hand-off to a fresh session anyway. I don't use context compaction though.

I think it probably is domain related. My main work for agents at the moment is on improving a crufty human-written JIT recompiler, and the number of mistakes and oversights even the very best models make is substantial. I would say maybe 50% of turns are correct semantically and don't regress performance, and that's after writing a lot of documentation, a lot of tests, and splitting up the codebase into smaller modules with well defined interfaces to reduce context size for any one change.

The first attempts I made to one shot improvements to the recompiler before doing the refactoring and test framework were basically all wrong and introduced lots of bugs, a per turn success rate in the single digit percentages. Each of the non-functional changes I made improved the performance substantially as you might expect. The real eye opener though was the refactoring into smaller units - that bumped up the success rate much more than I was expecting.

Don't get me wrong, the success rate of human changes is abysmal on these tasks, which is why the recompiler was in such a sorry state already. There are edge cases and gotchas everywhere. Opus, Astra and Gemini 4 all reason for hours on individual changes, and lesser models can churn for much longer and still fail.

Interestingly the code itself isn't really all that big - about 45000 lines of C all told.

Isn't this inherently task/domain/programming language/even prompting style specific? Why can't other people have genuinely different experience than you?

I think you can think of Pro approximately as running multiple instances of a non-pro model, than giving all their outputs to a final judge model which combines them into a better one.

Well, the number one beneficiary of US soft power was the US itself. It's just that many can't/won't see the harm that follows from losing that power.

You could also use it as a subagent prompted eg by Sonnet/Opus orchestrator agent and for many agentic workflows significant part of the dispatched tasks might be under 100k budget.

You can also create custom agents with defined effort levels and use those.

Well, always watch also the number of tokens used (and price). Intelligence scales with tokens so you might make Luna as smart as Sol with crazy amount of them :)

Also, these are benchmarks...

It's a bit misleading I think because these benchmarks are for Max level, at which Anthropic newest models use crazy amount of reasoning tokens. And we know that intelligence scales with their number.

On the contrary, subagents save context overall, when the task is sufficiently large.

Also, my experience is that Fable 5.1 is very good at prompting/orchestrating Opus/Sonnet subagents when working on a larger task (e.g. 1-2M context window use only for the orchestrator itself).

Well, it's performance "surface" (is there a better term for this?) is probably very narrow compared to Fable :)