Claude Code 2.1: Agent Teams, 1M Context Windows, and 16 Features You Missed

February 2026 • 10 min read

Claude Code 2.1.0 dropped on January 8, 2026 with 1,096 commits — making it the biggest single release in Claude Code history. Then, just weeks later, Anthropic rolled out Opus 4.6 with a 1M token context window beta. If you blinked, you missed a lot.

We dug through the changelogs, the GitHub discussions, and the community chatter to pull out every feature that matters. Here are the 16 most important things from the Claude Code 2.1 era — and how to actually use them.

1. Agent Teams (Experimental)

This is the headline feature. Agent Teams lets you spawn sub-agents from within a Claude Code session, each with their own context and task. Think of it as a lead developer delegating to junior devs — except the junior devs are also Claude.

In practice, you can tell Claude to “refactor the auth module, update the tests, and fix the API docs” and it will spin up parallel agents to handle each task simultaneously. The lead agent coordinates, merges results, and resolves conflicts.

                What Agent Teams Enable
                Parallel task execution — multiple files edited at once, across different parts of the codebase
Specialized sub-agents — one agent for code, another for tests, another for documentation
Coordinated planning — the lead agent creates a plan, delegates, then reviews the combined output

            

Agent Teams is still marked as experimental, but early reports from developers running it on large monorepos are extremely promising. The key limitation right now is token cost — running 3-4 agents in parallel burns through your API budget quickly.

2. 1M Token Context Window

With the release of Opus 4.6, Claude Code gained access to a 1 million token context window in beta. To put that in perspective, that is roughly 750,000 words — or an entire medium-sized codebase loaded into memory at once.

The practical implications are significant. Instead of Claude needing to search, read, and re-read files as it works, it can hold your entire project in context. This means fewer hallucinations about file locations, fewer “let me check that file again” round-trips, and a much deeper understanding of cross-file dependencies.

                Best Use Cases for the 1M Window
                Large refactors — rename a core abstraction across dozens of files with full awareness of every usage
Architecture reviews — load the entire codebase and ask Claude to identify design issues
Migration projects — move from one framework to another with the full source in context

            

Note that the 1M window is in beta and requires Opus 4.6 to be selected as your model. Standard context limits still apply on older models.

3. Skills Overhaul

Skills got a major rework in 2.1. The old system was functional but rigid — you wrote a skill file, Claude loaded it, and that was it. The new system introduces three key improvements:

Forked context — skills can now run in their own context branch, so a skill that generates boilerplate does not pollute your main conversation history
Hot reload — edit a skill file and Claude picks up the changes immediately without restarting the session
Community skills marketplace — browse and install skills shared by other developers directly from the CLI with /skills search

If you have not looked at skills since the early days, it is worth revisiting. The ecosystem has matured significantly, with popular skills for Django scaffolding, React component generation, API endpoint creation, and more.

4. Shift+Enter for Newlines

This one sounds small but was the most requested feature on the Claude Code GitHub for months. Previously, pressing Enter always sent your message. Now, Shift+Enter inserts a newline, letting you compose multi-line prompts without triggering submission.

If you write detailed prompts (and you should), this single change makes the daily experience dramatically better.

5. Agents Continue When You Deny Tool Use

Before 2.1, if Claude asked to use a tool (say, writing to a file) and you denied it, the entire flow would stall. Claude would just sit there or apologize and stop working.

Now, when you deny a tool use request, Claude adapts and continues. It will either find an alternative approach or explain what it wanted to do and ask how you would like to proceed. This makes the “trust but verify” workflow much smoother — you can deny risky operations without killing the agent’s momentum.

6. Wildcard Tool Permissions

The permissions system got more granular. You can now set wildcard rules like “allow all file reads in src/” or “deny all writes to *.env” using glob patterns in your settings. This is particularly useful for teams that want to let agents work freely within certain boundaries.

Example Permission Rules

In your .claude/settings.json, you can define patterns like:

src/** — allow reads and writes
*.env — deny all access
tests/** — allow writes (let Claude create tests freely)
infrastructure/** — read only

7. /teleport to claude.ai/code

The /teleport command creates a seamless handoff between the CLI and the web interface. Run /teleport in your terminal session and it generates a link that opens claude.ai/code with your full conversation context intact.

This is perfect for situations where you want to share your session with a teammate, switch to a device without CLI access, or simply prefer the web UI for reviewing a long conversation. The context transfer includes your file tree, recent changes, and conversation history.

8. February Stability Update

The February patch (2.1.x) focused on stability and performance. The highlights:

Session guards — if a session crashes mid-operation, Claude Code now recovers gracefully instead of losing your conversation
Crash fixes — several edge cases that caused hard crashes on large file operations have been resolved
Faster terminal rendering — output from Claude now streams noticeably faster, especially for long code blocks
Reduced memory usage — long sessions no longer balloon in memory after hours of use

If you experienced random crashes or sluggishness in January, update to the latest patch. The difference is real.

9. Ten More Features Worth Knowing

Beyond the headliners, the 1,096-commit release packed in a ton of smaller improvements. Here is the rapid-fire list:

Improved diff display — file diffs now show syntax-highlighted before/after views
Git-aware context — Claude automatically reads your recent git history for better context on what you have been working on
Faster file search — the internal file indexer is significantly quicker on large repos
Better error recovery — when a command fails, Claude provides clearer explanations and retry options
Model switching mid-session — swap between Sonnet, Opus, and Haiku without restarting
Inline image support — paste screenshots directly into the CLI for visual debugging
Workspace file pinning — pin important files so Claude always has them in context
Streaming tool results — see command output in real-time instead of waiting for completion
Custom system prompts — set per-project system prompts in .claude/config.json for consistent behavior
Audit log — every tool use and file change is logged for compliance and review

10. Making the Most of These Features

With this many new capabilities, the question is not “what can Claude Code do?” but “how do I stay organized while using it?”

Here are practical tips for getting the most out of the 2.1 release:

Start with permissions — before using Agent Teams or any multi-agent workflow, set up your wildcard tool permissions. You do not want a sub-agent accidentally deleting your production config.
Use skills for repetitive tasks — if you find yourself giving Claude the same instructions across projects, write it as a skill. The hot-reload feature makes iteration fast.
Organize your sessions — with Agent Teams spawning multiple processes, terminal organization becomes critical. Use a tool like Beam to keep each agent’s output in its own workspace.
Save your context — the 1M window is powerful, but sessions still end. Use project memory files to persist architecture decisions, conventions, and key context between sessions.
Monitor your token usage — Agent Teams and the 1M context window can burn through tokens fast. Keep an eye on your Anthropic dashboard.

Pro Tip: Agent Teams + Beam

When running Agent Teams, each sub-agent runs in your terminal. Use Beam workspaces to give each agent its own tab. Name them by task — “Agent: Tests”, “Agent: Refactor”, “Agent: Docs” — so you can monitor each one independently and jump between them with ⌘P.

Manage Your Claude Code 2.1 Sessions with Beam

Agent Teams, parallel workflows, multiple sessions — keep it all organized with workspaces, layouts, and project memory. Free to try.

Download Beam Free

Summary

Claude Code 2.1 is a generational update. Agent Teams introduces true multi-agent collaboration. The 1M context window means Claude can finally understand your entire codebase at once. The skills overhaul makes custom workflows reusable and shareable. And dozens of quality-of-life improvements make the day-to-day experience significantly smoother.

The pace of development from the Claude Code team shows no signs of slowing down. If you are building software in 2026, this is the tool to watch — and the one to organize around.