Claude Code Tasks: Multi-Session AI Development
Anthropic engineer Thariq announces the evolution from Todos to Tasks—enabling dependency tracking, file-system storage, and coordination across multiple sessions and subagents
What are Claude Code Tasks?
Claude Code Tasks are a new primitive replacing the TodoWrite tool, designed for complex projects spanning multiple sessions and subagents. Tasks support dependencies, blockers, and metadata stored in ~/.claude/tasks. Multiple sessions can collaborate by setting CLAUDE_CODE_TASK_LIST_ID environment variable. Inspired by Steve Yegge's Beads system, Tasks solve the "50 First Dates" problem where AI agents lose context between sessions.
TL;DR
- •Todos → Tasks: Anthropic upgrades the TodoWrite tool to Tasks, a new primitive built for longer, more complex projects
- •Dependencies & Blockers: Tasks can have explicit dependencies on other tasks, mirroring how real projects work
- •File System Storage: Tasks persist in
~/.claude/tasks, enabling multi-session and multi-agent access - •Shared Task Lists: Set
CLAUDE_CODE_TASK_LIST_ID=myproject claudeto coordinate across sessions - •Community Inspiration: Takes cues from Steve Yegge's Beads system—solving agent memory loss with structured, queryable task data
Anthropic engineer Thariq dropped significant news for the Claude Code community: Todos are becoming Tasks. This isn't just a rename—it's a fundamental evolution in how Claude Code handles complex, long-running projects that span multiple sessions, subagents, and context windows.
The announcement, shared via X (formerly Twitter), reveals that as model capabilities grow with Opus 4.5, the old TodoWrite tool became somewhat redundant for smaller tasks. Claude can now track its own state better autonomously. But the flip side of that capability growth is that developers are now using Claude Code for longer, more complex projects—and those projects need coordination tools that match their ambition.
For Echofold users building sophisticated AI automation systems, this is a significant infrastructure upgrade. Tasks represent the foundation for truly autonomous, coordinated AI development workflows.
01.Why Todos Had to Evolve
The original TodoWrite tool served a clear purpose: help Claude track what it needed to do and give users visibility into progress. It was, according to Anthropic's documentation, "EXTREMELY helpful for planning tasks and for breaking down larger complex tasks into smaller steps."
But as Thariq explains, model capabilities have shifted the calculus:
"Compared to previous models, Opus 4.5 is able to run autonomously for longer and keep track of its state better. We found that the TodoWrite Tool was no longer necessary because Claude already knew what it needed to do for smaller tasks."
This is a fascinating admission: better models need different tools. When Claude couldn't reliably track multi-step processes, explicit todo tracking made sense. Now that it can handle that cognitive load internally, the tool can evolve to solve harder problems.
The New Problem: Project-Scale Coordination
As teams started using Claude Code for longer projects, new pain points emerged:
- ✗Context window boundaries: Projects that span multiple sessions lose state
- ✗Multi-agent chaos: Multiple subagents working on the same project can't coordinate
- ✗Dependency blindness: Todos don't track which tasks block other tasks
- ✗Memory loss: The "50 First Dates" problem—agents wake up with no memory of yesterday
02.How Claude Code Tasks Actually Work
Tasks solve the coordination problem through three key design decisions: dependency metadata, file system persistence, and cross-session broadcasting.
Architecture Overview
Dependency Metadata
Tasks can depend on other tasks, with blockers stored in metadata. This mirrors how real projects work—you can't deploy until tests pass, can't test until code is written.
File System Storage
Tasks persist in ~/.claude/tasks. This makes them accessible to multiple sessions, subagents, and even external tools you build yourself.
Cross-Session Broadcasting
When one session updates a Task, that change broadcasts to all sessions currently working on the same Task List. Real-time coordination without polling.
Using Shared Task Lists
To make sessions collaborate on a single Task List, set the environment variable before starting Claude:
# Start Claude with a shared task list
CLAUDE_CODE_TASK_LIST_ID=groceries claude
# Works with programmatic mode too
CLAUDE_CODE_TASK_LIST_ID=myproject claude -p "continue working on the API"
# And with the AgentSDK
CLAUDE_CODE_TASK_LIST_ID=backend-refactor node my-agent.jsAll sessions using the same CLAUDE_CODE_TASK_LIST_ID share and sync the same Task List in real-time.
03.The Beads Connection: Standing on Community Shoulders
Thariq explicitly credits Steve Yegge's Beads project as an inspiration. Beads is an open-source task management system built specifically for AI coding agents—and it tackles the same fundamental problem Tasks now addresses.
"Your agents simply cannot keep track of work using Markdown files. They try, and they will churn out gobs of six-phase markdown todo-plans in your project until the cows come home. But the whole approach has serious problems: Markdown plans are text, not structured data, and need to be parsed and interpreted—this places a high cognitive load on the model."
Beads solved this by treating tasks as structured, queryable data stored in Git. The system uses a directed acyclic graph (DAG) with explicit dependencies and priority levels. Agents can identify "ready work" and maintain context across sessions without the cognitive overhead of parsing markdown.
Key Beads Principles That Influenced Tasks
Structured > Unstructured
- • Tasks as data, not prose
- • Queryable dependencies
- • Machine-readable metadata
- • No parsing overhead for the model
Persistent > Ephemeral
- • Survive session boundaries
- • Git-backed (Beads) / File system (Tasks)
- • Build work queues automatically
- • Enable multi-agent coordination
The fact that Anthropic explicitly acknowledges community projects like Beads shows a healthy feedback loop. The Claude Code community identifies problems, builds solutions, and those solutions inform the official tooling. This is how open ecosystems should work.
04.When to Use Tasks vs. Just Letting Claude Work
Thariq's announcement contains an important nuance: you don't always need Tasks. For smaller tasks that fit within a single context window, Opus 4.5 handles state tracking internally. Tasks shine when projects exceed that boundary.
When to Use Tasks
| Scenario | Use Tasks? | Why |
|---|---|---|
| Quick bug fix | No | Single session, Claude tracks internally |
| Multi-day feature | Yes | Spans sessions, needs persistent state |
| Single file refactor | No | Contained scope, single context |
| API + frontend + tests | Yes | Dependencies between components |
| Parallel subagent work | Yes | Multiple agents need coordination |
| Code review | Usually no | Read-heavy, single pass |
The key insight: Tasks are for projects, not tasks. If your work has dependencies, spans multiple sessions, or involves coordination between agents, Tasks provide the infrastructure to manage that complexity.
05.Tasks + Subagents: The Multi-Agent Sweet Spot
Thariq specifically mentions that Tasks are "especially useful when spinning up subagents." This is where the design really shines—multiple specialised agents working on different parts of a project, all coordinating through a shared Task List.
Multi-Agent Workflow Example
Imagine refactoring a large codebase with multiple subagents:
# Main orchestrator creates the task list
CLAUDE_CODE_TASK_LIST_ID=refactor-auth claude
> "Create tasks for refactoring the auth system"
# Subagent 1: API layer (separate terminal)
CLAUDE_CODE_TASK_LIST_ID=refactor-auth claude
> "Work on API endpoint tasks"
# Subagent 2: Database migrations (separate terminal)
CLAUDE_CODE_TASK_LIST_ID=refactor-auth claude
> "Handle database migration tasks"
# Subagent 3: Test coverage (separate terminal)
CLAUDE_CODE_TASK_LIST_ID=refactor-auth claude
> "Write tests for completed tasks"All four sessions share the same Task List. When Subagent 1 completes an API task, Subagent 3 immediately sees it's ready for testing. Dependencies resolve automatically.
Task Tool vs. Tasks Primitive
Don't confuse the new Tasks primitive with the existing Task tool. They serve different purposes:
Task Tool (Existing)
- • Spawns ephemeral worker agents
- • ~20k token overhead per spawn
- • For parallel operations
- • Temporary, single-use
Tasks Primitive (New)
- • Persistent work items
- • Stored in file system
- • For project coordination
- • Survive across sessions
06.What This Means for Echofold Users
For the Echofold community building AI automation systems and agentic applications, Tasks provide infrastructure that was previously DIY. Here's what changes:
Complex Automation Pipelines
Multi-step automations that span hours or days can now maintain state natively. No more hacky workarounds with markdown files or external databases—Tasks provide first-class support for long-running processes.
Team AI Development
Multiple developers can work with AI agents on the same project simultaneously. The shared Task List ensures everyone—human and AI—is coordinated on priorities and dependencies.
Custom Tooling Opportunities
Since Tasks are stored in ~/.claude/tasks, you can build additional utilities on top. Dashboards, progress reporters, integration with external project management tools—the file-based approach enables extensibility.
LaunchLoop Project Management
For LaunchLoop community members building startups with AI assistance, Tasks provide the backbone for managing complex builds that span multiple coding sessions.
07.Frequently Asked Questions
What are Claude Code Tasks?
Claude Code Tasks are a new primitive that replaces the TodoWrite tool. Tasks support dependencies, blockers, and metadata storage in the file system (~/.claude/tasks), enabling coordination across multiple sessions and subagents. Unlike Todos, Tasks are designed for longer, more complex projects that span multiple context windows.
Why did Anthropic replace TodoWrite with Tasks?
With Opus 4.5's improved autonomous capabilities, Claude can now track its own state better for smaller tasks without needing explicit Todos. However, for longer projects spanning multiple sessions or subagents, the community needed something more robust. Tasks emerged to handle dependency tracking, cross-session coordination, and the complexity of real-world projects.
How do I share Tasks across Claude Code sessions?
Set the CLAUDE_CODE_TASK_LIST_ID environment variable before starting Claude Code: CLAUDE_CODE_TASK_LIST_ID=groceries claude. This works with both the CLI and the AgentSDK. All sessions using the same ID will share and sync the same Task List.
Where are Claude Code Tasks stored?
Tasks are stored in ~/.claude/tasks on your file system. This persistent storage enables multiple sessions and subagents to access and update the same tasks. You can build additional utilities on top of this file structure.
How did Steve Yegge's Beads inspire Claude Code Tasks?
Steve Yegge's Beads is an open-source task management system designed specifically for AI coding agents. It solves the "50 First Dates" problem where agents wake up with no memory. Anthropic took inspiration from Beads' approach of using structured, queryable task data stored in Git rather than unstructured markdown files.
Can Tasks be used with Claude Code subagents?
Yes, Tasks are especially useful when spinning up subagents. Multiple subagents can work on the same Task List, with updates automatically broadcast to all active sessions. This enables sophisticated multi-agent workflows where different specialists handle different parts of a project.
What's the difference between Tasks and the Task tool?
The Task tool spawns ephemeral worker agents for parallel operations with ~20k token overhead each. Tasks (the new primitive) are persistent work items with dependencies stored in the file system. Think of Tasks as the project management layer, while the Task tool is for spinning up temporary helpers.
Building Blocks for Autonomous Development
Tasks represent Anthropic's response to a fundamental challenge: as AI agents become more capable, they need infrastructure that matches their ambition. The evolution from Todos to Tasks isn't about adding features—it's about enabling a new class of development workflows that simply weren't possible before.
The design choices here are instructive. By storing Tasks in the file system, Anthropic enables community extensions. By supporting the environment variable pattern for shared Task Lists, they make multi-agent coordination accessible without complex setup. By acknowledging community inspiration from projects like Beads, they demonstrate that the best tools emerge from real-world usage patterns.
For developers using Claude Code to build real projects—not just demos—Tasks provide the coordination layer that's been missing. And for those learning to work with AI agents, understanding Tasks is now essential curriculum.