On March 18, 2026, Anthropic announced that Claude Code's output token limit was going from 25,000 to 128,000. That's a 5x-plus increase, meaning Claude can generate roughly 90-100K words in a single response, or equivalent amounts of code.
For ordinary chat scenarios, 25K tokens was fine — most conversation replies don't need more than a few thousand tokens. But in agent scenarios, a 128K output cap unlocks a range of uses that weren't possible before.
The 25K Bottleneck
Under a 25K output limit, plenty of useful agent tasks got artificially truncated.
Have the agent generate a complete technical document? 25K tokens is about 5,000-7,000 Chinese characters or maybe 15,000-18,000 English words — too short for a serious document. Have the agent do a full code review? If the codebase has a few thousand lines, the review comments plus suggestions easily blow past the limit. Have the agent analyze a long report and generate a structured summary? Input isn't the problem (the context window is 200K), but output was stuck at 25K.
Developers found workarounds: split long tasks into multiple short tasks, generate a piece at a time, stitch them together. But this introduced consistency problems — when you split a document into five pieces, coherence of style and logic across those pieces is hard to guarantee. The agent might forget the first section's context when it reaches the third, or repeat what it already said in the second.
These workarounds added application-layer complexity. You needed task-splitting logic, cross-request context passing, result stitching, and consistency checks. That's not a few lines of code — that's a whole feature module.
How 128K Changes the Game
A 128K output cap means most agent tasks can finish in a single response.
A complete technical document, a comprehensive code review, a detailed analysis report — all generated in one shot, no splitting and stitching. This isn't just a UX improvement. It eliminates an entire class of application-layer complexity.
When output doesn't need splitting, you don't need task-splitting logic. No cross-request context passing. No result stitching. No consistency checks. Your code can be a simple "send request, wait for response."
The Amplification Effect of Thin Architecture
This is exactly where NanoClaw benefits most.
NanoClaw's orchestration layer has no extra abstraction between the Claude Agent SDK and the user. It doesn't truncate output, doesn't paginate, doesn't add its own formatting. When Claude's output cap went from 25K to 128K, NanoClaw users immediately got the full 128K capability — no code update, no config change, they didn't even have to know the change happened.
Compare that to frameworks that built processing layers on top of model output. Some frameworks truncate long output, some paginate, some post-process. When the output cap changes, those layers may need updating — truncation thresholds need adjusting, pagination logic needs rethinking, post-processing assumptions need re-verifying.
NanoClaw doesn't have those layers. Model output goes directly to the user. So any improvement in model output capability flows through with zero latency and zero development cost.
This is a core advantage of thin architecture: when underlying capability improves, a thin middle layer transmits the improvement losslessly. The thicker the middle layer, the more friction in transmission — because every assumption, every processing step, every format conversion in the middle is a potential obstacle.
128K Output Plus Container Environment
128K output is especially valuable inside NanoClaw's container environment.
NanoClaw's agents can execute code inside their containers. When the agent generates a long code file — say, a complete Python script or a multi-file project — the 128K cap means the agent can generate complete code in a single response, then execute it, test it, fix issues, and run again in the same container session. The whole dev-test-fix loop happens in one continuous context.
Long-form text generation that previously required splitting is also straightforward now. Have the agent write an in-depth analysis, generate complete API documentation, create a multi-chapter tutorial — the 128K cap makes all of these single-interaction tasks.
Where This Is Headed
From 25K to 128K isn't the end. Anthropic's roadmap makes it clear that output capability will keep growing. Claude's context window went from 100K to 200K, and now output from 25K to 128K — both input and output are expanding fast.
For thin architectures, every expansion is free capability growth. NanoClaw doesn't have to do anything to "support" longer outputs — because it never limited output length in the first place. When Anthropic raises the output cap to 256K or 512K, NanoClaw users will pick up the new capability automatically, just as invisibly as they did going from 25K to 128K.
Features you didn't build don't need upgrading. Limits you didn't add don't need removing. That's the payoff of the minimal-code philosophy when capability expands — by doing nothing, you already did the most correct thing.