Loading video player...
The developers of Claude Code just silently announced massive updates that almost no one is
talking about, the biggest of which is the release of async background agents. What's strange
is that you won't find these features mentioned anywhere on Anthropik's main site or even
their blog. Now you might be wondering if these are actually useful, and honestly I
wasn't sure at first either, but I found an unexpected angle that's completely changed how
I use them. So in this video I'm going to break down exactly what that
is, why it makes a lot of existing AI coding frameworks basically unnecessary, and then
walk through several other Claude features. They announced these new features in the change logs
on Claude Code's GitHub repo. They mentioned that these agents and bash commands can run
asynchronously and send messages to wake up the main agent. The idea here is to
achieve true parallel working. It is quite simple to use them. We first asked Claude
to handle a task that benefits from a sub -agent, and then the main agent
creates a sub -agent for the task. When the agent has started running, we push
it to the background using Ctrl -B and continue working with the main agent on
other tasks. When the sub -agent has completed the task, it wakes up the main
agent with the results. We can also check our running agents using the tasks command.
Under the hood, the background agent works as a separate process that is able to
execute complex multi -step tasks autonomously, meaning it can independently handle full -scale tasks
on its own. They allow you to continue interacting with Claude Code's main thread without
blocking their execution, so you can use your time effectively instead of waiting. When they're
done executing, they report the results back to the main agent. Previously, you had to
open multiple terminals with separate Claude instances for this purpose. Now Claude does this itself,
managing background agents internally, coordinating multiple agents, and integrating the results on its own
without the manual setup we were using earlier. They say background agents are ideal for
researching while coding, reviewing workflows, performing parallel tasks, and handling any task that shouldn't
pollute your main context window. Before we discuss whether these agents actually save us time,
let's take a quick break to talk about Automata. After teaching millions of people how
to build with AI, we started implementing these workflows ourselves. We discovered we could build
better products, faster than ever before. We help bring your ideas to life, whether it's
apps or websites. Maybe you've watched our videos thinking, I have a great idea, but
I don't have a tech team to build it. That's exactly where we come in.
Think of us as your technical co -pilot. We apply the same workflows we've taught
millions directly to your project, turning concepts into real, working solutions without the headaches of
hiring or managing a dev team. Ready to accelerate your idea into reality? Reach out
at hello at automata .dev. So I tried out what they were suggesting, and from
the time I've spent with them so far, I really like what I'm seeing. I
think these agents have a lot of potential. These background agents can handle any research
task that takes a lot of time or might bloat your context window. You can
simply move that research to the background and assign a separate task to the main
agent. This allows the main agent to work on something completely different while remaining totally
isolated from the research task. These agents make it much easier to implement changes on
separate pages at the same time by parallelizing tasks. Instead of waiting for one agent
to handle everything sequentially, you can update them simultaneously. For example, if you're switching all
your components to a new library, you can use background agents to update them all
at once. Other than that, you're often left with tasks like reviews that take up
a lot of time. You can use async agents to launch several of them simultaneously.
One for a security review, one to identify performance bottlenecks, one for refactoring code, and
another to check for duplications or unused code. You can run all of these tasks
in the background while your main agent stays focused on a completely different feature update.
This way, each agent works separately and handles its own task independently from the others.
Now here's the unexpected angle I mentioned earlier. You can even equip background agents with
the ability to manage their work in a Git work tree, allowing them to commit
and push changes in isolation. Some of you might have already thought about this, but
for those who don't know, Git work trees are an extremely underutilized feature that lets
you work on multiple branches in separate directories. This means you can avoid constant branch
switching in a single workspace and simply spawn as many agents for as many features
as you like. To use this workflow, I set up a custom slash command that
creates a background agent to work on tasks in separate work trees. All the instructions
for this command live right in the commands folder, which you can find inside the
.clawed folder. Let's say I'm working on an app, but I'm not happy with the
theme. I have three different theme ideas and I want to implement all of them
to see which one looks best. Without work trees, I would have had to clone
the repo separately, create three different branches or open separate clawed instances just to keep
the tasks apart. But with background agents, all of that changes. The three agents worked
in parallel to implement those themes separately, all while leaving my main design completely unaffected.
This allows me to simply merge the theme I like into the main project and
discard the others. This setup made the implementation process significantly faster. Because all the changes
are isolated, I can choose the theme I like best from the different options. It
gives me the freedom to experiment and execute without worrying about breaking the main design
or having to revert unwanted changes. In the change logs, they announced some other really
cool features and one that I personally am really thankful for is instant auto compact.
Compacting used to take a good two to three minutes, but now it happens significantly
faster because it's likely maintaining histories for each project right in the .clawed folder. Claude
Code also added a prompt suggestion feature where you can simply press enter to accept
a suggestion or just type a new prompt in its place. You can use the
agent flag while starting Claude to run it as the specific agent you have in
your project, allowing you to delegate tasks to it directly. Claude Code now allows you
to fork sessions and choose between them when you launch Claude with the resume flag.
All you have to do is press the escape key twice and your current session
will be forked. Now, even though background agents are great, there are certain areas where
you shouldn't use them as they will hinder your workflow instead of making it better.
For example, you don't want to background any task that requires your input because that
would cause the agent to get blocked and unable to proceed. You also don't want
to background any task that requires your approval while it's running. It would just get
blocked in the background and you could actually lose track of it if the main
agent is busy with another task. It is also highly recommended not to assign tasks
that depend on each other as this can create conflicts in your agent's work. Instead,
it's much better to assign isolated tasks to each agent. There are a few best
practices you need to keep in mind to get the most out of this workflow.
While using background agents, you need to keep token usage in mind. Even though they
speed up your work, each agent consumes a significant number of tokens, so it's important
to track this if you want to avoid high bills. Since agents return their output
to the main agent, you have to make sure your tasks are isolated. Also, when
you're spawning an agent, give it a descriptive name. That way, if you're managing multiple
agents at once, you'll know exactly what each one is doing. That brings us to
the end of this video. If you'd like to support the channel and help us
keep making videos like this, you can do so by using the super thanks button
below. As always, thank you for watching and I'll see you in the next one.
AI Coding workflows are quietly changing with Claude Code’s new async background agents. This video breaks down how they actually work, when to use claude code subagents, how a claude code skill fits into real projects, and how to set up claude code for true parallel development. Claude Code recently shipped a set of updates that fundamentally change how AI-assisted coding workflows can be structured — but almost no one noticed. These features were quietly announced in changelogs, not blog posts, and they unlock something we’ve been missing: true parallel, autonomous AI work inside a single Claude Code session. In this video, I break down Claude Code’s new async background agents, how they work under the hood, and how they compare to older parallel execution workflows that required multiple terminals or manual orchestration. We walk through: • What background agents actually are and how they differ from normal Claude interactions • How claude code subagents run asynchronously without blocking your main context • How to push agents into the background and wake them automatically when they finish • When background agents save time — and when they actively hurt your workflow I also cover an unexpected but powerful angle: combining background agents with Git worktrees. This allows multiple autonomous agents to work on separate branches in isolation, commit changes independently, and report back without polluting your main workspace. It’s one of the cleanest ways to experiment, refactor, or test multiple implementations at once. Beyond agents, the video also touches on: • Instant auto-compact and why it’s significantly faster now • Session forking and resuming workflows • Prompt suggestions and agent flags • Practical limits around token usage and task isolation If you’ve been experimenting with claude code subagents, building your own claude code skill, or wondering how to set up claude code for real-world, production-grade workflows — this video is a deep, practical breakdown of what actually matters. No demos for demos’ sake. Just what works, what doesn’t, and how to use these features without breaking your flow.