Claude Code's sub-agents solve one problem and create three others

Published Jul 31, 2026, 10:30 AM EDT Mahnoor Faisal is a tech journalist covering AI and productivity tools with bylines at XDA, SlashGear, MakeUseOf, Laptop Mag, and Android Police. She's been writing professionally since she was sixteen, and has since penned hundreds of articles. This includes in-depth coverage of AI tools like NotebookLM to breaking news across the AI space. Her passion for technology started when she received her first iPod Touch (4th generation) on her 8th birthday, and she's been deep in the tech world ever since. Currently pursuing a degree in computer science, Mahnoor brings both a journalist's eye and a technical foundation to her coverage of how AI is reshaping the way we work and learn. The first time you build something you've only ever been able to describe with words using AI genuinely feels like magic. Your vision goes from idea to concept within minutes, and it's faster than anything you've done before. The second, third, fourth, and even the tenth time you use AI to build, that same speed (and excitement) still holds. However. something subtle shifts at this stage. You begin to notice friction you overlooked at first: you're still doing everything one step at a time. You ask for one thing, wait, review it, then ask for the next. That's where subagents come in. Instead of one task after another, they let you run several at once. And once you begin building this way, it's hard to go back. But you quickly learn that parallelism isn't free. For every bottleneck subagents clear, they quietly introduce a few of their own. Subagents break the context bottleneck A separate window for the messy work To understand the biggest benefit of subagents, it's important you understand a bit of how AI models actually remember things during a conversation. Every AI chat has a fixed amount of space it can hold in its "head" at once. This is referred to as the context window in more technical terms. Everything from your session lives in that space, including each question you ask, every file the AI opens, and every answer it gives back. All of this context piles up, and the space doesn't grow to make room. It's fixed. Now, LLMs nowadays have context windows far larger than they used to. Claude Opus 5 and most other flagship models, for instance, have a 1M-token context window. Despite how huge this window sounds, it fills up extremely fast when you're working on a real project. Everything from back-and-forth messages and opening dozens of files to running commands and reading their output to repeated chunks of the same information stacks up in that space and stays there. Once the context window gets too crowded, the model begins to slip. You'll notice it forgetting things you told it earlier, answers turning vaguer, and you'll find yourself repeating context you've already given just to get back on track. Subagents fix this by sending the messy work off to the side. Each subagent runs in its own context window, meaning anything it opens, reads, or works through stays in that separate space instead of piling into yours. Instead of opening thirty files right in front of you and cluttering the main workspace, a subagent goes into a separate room, does the digging on its own, and comes back with just a short summary. This allows the main conversation to stay clean and focused, holding only the things that actually matter instead of every messy step it took to get there. The same walls that keep noise out keep context out A subagent can't see what you can While the context window problem is the one subagents were built to fix, it ironically introduces the very first problem you'll run into: a subagent can't see what you can. When you delegate a task, the subagent doesn't start from where you are in the conversation and starts fresh. It can't see your chat history, the files you've already opened, or anything you explained a few messages ago. All it gets is a short brief that Claude writes describing the task, and it works from that alone. Everything else you've built up in the main session stays behind. Most of the time, this is fine. If you ask a subagent to read a long log file and pull out one error, it doesn't need the backstory. However, the moment the task depends on something you established earlier, the isolation works against you. The subagent goes off, does the work confidently, and returns an answer that's wrong in a way it couldn't have known about, because the detail that mattered was never passed to it! Say you mentioned at the start that a certain file shouldn't be touched. Ten minutes later, you send a subagent to refactor something nearby. It never got that instruction, so it edits the file anyway, hands you a clean summary, and you don't catch it until later. While the clean context certainly lets you keep the noise out of your main window, it also means you kept your subagent in the dark. Plus, the deeper you nest them (subagents spawning their own subagents), the more this compounds. Each new wall seals off a little more of what the layer below it knows! All you get back is a summary The thinking is never surfaced The second problem follows directly from the first. Since a subagent works in its own separate context, the only thing that comes back to you is its final summary. You don't see the steps it took, the dead ends it hit, or the reasoning it used to land on its answer. You get the conclusion and nothing else. On the surface, this doesn't really seem like it's too big of a problem. After all, you delegate the task precisely so you wouldn't have to watch every single step. However, it also means you're trusting a verdict you can't check yourself. When a subagent returns something that looks right but isn't, you have no easy way to see where it went wrong, because the part that would explain it was never written down. You can inspect what went in and what came out, but not how it got from one to the other. If you're running multiple agents through a workflow, the progress view shows you a live tree of what's happening — which phase each agent is in, which one is running what. However, that's just status and not reasoning. You can see that an agent is working and what it's labeled, not the thinking behind the result it eventually hands back. Most importantly, subagents aren't free In terms of time, tokens, and limits Since every subagent runs in its own context window, you're paying to fill and process a separate context each time you spawn one. Of course, that adds up fast. By Anthropic's own numbers, multi-agent workflows use roughly three to ten times as many tokens as a single-agent session doing the same work. While subagents consuming more tokens doesn't translate to literal dollars when you're on a subscription plan like Pro or Max, it still costs you in a currency that matters just as much: your usage limits. Those extra tokens burn through your session and weekly caps far quicker, so a workflow that leans on subagents can leave you throttled or locked out well before you'd expect. And ironically, while subagents are pitched as a way to speed things up, they don't always deliver on that either. Since each subagent starts cold, it has to gather its own context from scratch before it can do anything useful, and that startup cost is real. For a quick, one-off task, spinning up a subagent is often slower than just doing the work yourself in the main session. The time you save by running things in parallel only pays off when the task is big enough to cover that overhead in the first place! Ultimately, while subagents have their benefits, it's best to avoid them when they aren't needed. If the task is small, keep it in the main thread. And if it's tightly tied to everything else you're working on, splitting it off is worse than useless, because subagents can't see each other's contexts!