From Beads to Tasks: Anthropic Productizes Agent Memory

An Anthropic engineer tweeted about the new task system in Claude Code v2.1.16:

We took inspiration from projects like Beads by Steve Yegge.

— Antoine Brugeat, Anthropic

That single line says everything. The community builds patterns. Anthropic productizes them. The pattern-to-product cycle continues.

Why Todos Weren’t Enough

Claude Code has had todos since forever. Opus 4.5 is good enough at tracking state that simple todos became redundant for small tasks.

But projects got longer. Multi-session work. Subagents. Context window boundaries. The problem shifted from “what do I need to do” to “how do I coordinate complex work across sessions and agents.”

Todos don’t solve that. You need:

• Dependencies - task A blocks task B
• Persistence - survives session boundaries
• Coordination - multiple agents, same source of truth

That’s what Beads solved. Now it’s what Tasks solves, built in.

What Tasks Actually Does

From the changelog: “Added new task management system, including new capabilities like dependency tracking.”

The key features:

• Dependencies and blockers - task A can block task B. Claude won’t start B until A is done.
• Persistent storage - tasks live in ~/.claude/tasks, surviving across sessions
• Multi-session coordination - updates broadcast to all sessions watching the same task list
• Shared task lists - CLAUDE_CODE_TASK_LIST_ID=groceries claude opens a shared list
• Subagent support - works with claude -p and the AgentSDK

This isn’t a Jira replacement. It’s session-level coordination for agentic workflows.

The Pattern Recognition

This validates a running thesis. Look at what’s been built:

• Beads: Agent memory via Git-native issue tracking. Wake up, ask what’s next, the agent knows.
• Flux: Task coordination via MCP-first Kanban. CLI-first, web dashboard, multi-project.
• Agent Harnesses: Anthropic’s two-agent pattern with progress files. External artifacts become agent memory.

Tasks is Anthropic’s answer to the same problem. The solution converged because the problem is real.

All they know is what’s on disk. If you got competing documents, obsolete documents, conflicting documents - they get dementia.

— Steve Yegge (via the Beads thesis)

Different Layers, Not Competition

The honest take: Tasks doesn’t obsolete Beads or Flux. They solve different layers.

Analogy: Tasks is SQLite. Beads/Flux are PostgreSQL. Different scale, both valid.

If you’re coordinating work within a Claude Code session or across a few terminals: Tasks.

If you need project memory that survives across weeks and works with multiple agents: Beads.

If you need team-level visibility with a web dashboard: Flux.

Caveats

Being honest about where this is:

• Early days - stored in ~/.claude/tasks, format may change
• No MCP server - unlike Flux, you can’t query tasks from other tools via MCP (yet)
• No web UI - unlike Flux, there’s no dashboard to visualize dependencies (yet)
• Tightly coupled - works with Claude Code and AgentSDK, not arbitrary agents

The “yet” qualifiers are intentional. This is v1. Anthropic ships fast.

The Moat Question

A friend sent me this today: Claude proactively offering to save a task for later. “Want me to add that now, or create a task for later?”

It’s in the system prompt now. That changes everything.

When behavior is baked into the model’s default prompting, wrappers become redundant. This is how Anthropic absorbs community innovations: spot the pattern, productize it, ship it as native behavior.

The CLI tooling layer has no moat. Any good pattern that fits in a system prompt becomes native. The real moat is the non-CLI human experience: IDEs, web UIs, dashboards, integrations that aren’t just Claude in a terminal.

Why This Matters

The CNC machine is taking shape.

Yegge predicted orchestrated swarms with external memory. Not one giant diver with a bigger oxygen tank, but specialized divers coordinated by something that understands the workflow.

Tasks is a piece of that. Built-in memory and coordination at the session level. Dependencies that block work until preconditions are met. State that survives context compaction.

The infrastructure for agentic work - memory, dependencies, coordination - is becoming core product. Not DIY scaffolding.

The next generation of tools needs to lower that barrier, not just expand context windows.

That’s happening. Patterns built by the community are becoming native features. The cycle continues.

Try It

Update to Claude Code 2.1.16+. Tasks are available via the TaskCreate, TaskUpdate, TaskList, and TaskGet tools.

For shared task lists across sessions:

CLAUDE_CODE_TASK_LIST_ID=my-project claude

Works with claude -p for scripted workflows and the AgentSDK for custom agents.

The broader pattern: external memory for agents is no longer optional. Anthropic agreeing with Yegge’s thesis enough to productize it tells you where this is going. The scaffolding becomes the foundation.