AI agents like Claude Code and Perplexity Computer can be incredibly useful, but they all have one big issue when tackling large projects. Perhaps I should say they all have a small problem that turns into a big one, because the context window is one setting you can't change, but controls how your experience goes.

The other thing is that it's never a static target. It depends on the task, the information the model needs to keep in viewable memory, and the model itself. It's honestly a pain, because you move onto a new session, that valuable context is gone. If you need to make changes to that specific code change, you're starting from scratch again, which is expensive in wasted tokens (at a minimum), and at worst, the coding agent can't get back to the state you need and fails.

A new way of working was necessary, and that's one of the things Beads aims to solve.

What is Beads, and why would you use it?

Integrated task tracking for coding agents is neat

Beads is a command line tool that helps your coding agents manage their tasks. It's essentially a memory upgrade that operates outside the context window in which LLMs do their thinking, creating a structured, dependency-aware work graph for future use.

Or in a way that makes sense to humans, Beads is Jira, but designed for AI agents to read. It turns frustration into coding agents that are good at long-horizon planning and work discovery, as if they graduated from junior SWE status.

What does the architecture look like?

Beads has a two-layer data model; after that, it simplified life by using Dolt instead of SQLite and GitHub. The CLI layer works where your agent is, supports --JSON for programmatic use, and has direct database access to the Dolt SQL server. Even remote collaborators use the same Dolt DB, and it's a faster, more integrated loop than the old system was.

To prevent collision issues, it uses a hash-based ID system, so when multiple agents try to create new issues, they each receive unique UUIDs. There is a ton more interesting stuff in the architecture, but you can ignore that because it's for your agent to read, not you.

The problem with coding agents like Claude Code...

They have terrible short-term memory loss

There are two main users of tools like Claude Code — those who run "one shot" prompts and move on, and those who have set up multistep tasks, either through orchestration tools or the planning mode. For the former group, context windows only matter when the task can't be done within them, but for the latter group of power users, they're everything.

The problem only gets worse when Anthropic reduces the default prompt cache time, changes API access rules, or does any of the other things that it has done to streamline operations. I'm not picking on Anthropic, BTW, though it may seem that way. Those are just the most recent changes to usage restrictions by any of the AI providers, and they're the tools I use most. I could have pointed at GitHub pausing sign-ups for its paid Copilot plans instead.

It's also that Claude is one of the better tools for surviving past a context window, as it compacts the chat as you get near, hoping to preserve the essence of the chat, even if it doesn't keep all the data. In that way, it carries context into the next window, but that still has knock-on effects.

The better route is to take context about issues outside the chat, and store it in an agent-readable format. It's a little like commenting your code, or taking meeting minutes, but it's done by the AI, for the AI, and isn't really designed to be user-readable.

Beads fixes this by creating agent-optimized, persistent, structured memory to use

Beads was created for AI to use, not humans. It automatically creates issues, adds priorities, types, labels, and dependencies, and stores them in a hash-based database for future use.

It doesn't have to be a single agent, either. Issues can be set to be worked on, then handed off to another agent for code review. It's designed to use comments to provide context on what was worked on and to create a full issue-tracking system for agentic development.

The thing is, Beads is so simple to use. Once you run the installation script from GitHub, all it takes is two lines in Claude Code:

cd my-project bd init # Done. Claude handles the rest.

Workflows are declarative, either in TOML (below) or JSON, and while they're human-readable, they're designed for the coding agent to scan and work from.

formula = "feature-workflow"
description = "Standard feature development workflow"
version = 1
type = "workflow"

[vars.feature_name]
description = "Name of the feature"
required = true

[[steps]]
id = "design"
title = "Design {{feature_name}}"
type = "human"
description = "Create design document"

[[steps]]
id = "implement"
title = "Implement {{feature_name}}"
needs = ["design"]

[[steps]]
id = "review"
title = "Code review"
needs = ["implement"]
type = "human"

[[steps]]
id = "merge"
title = "Merge to main"
needs = ["review"]

It's a To-Do list, or Jira, or Kanban board, but one you don't have to manage, because your agents will. Replace Markdown plans with Beads, your AI will thank you (and you'll see the results almost immediately).

Now my coding agents don't forget what they were working on when they restart

Whether I'm running a single-agent or a multi-agent build, using Beads means they all share the same pool of institutional knowledge throughout the process, including the issues that have come up and the list of issues to fix. No more wrestling with "AI amnesia" or painstakingly re-outlining what needs fixing; Claude can reconstruct context without my intervention. It's fantastic, and means that bugs discovered during the implementation process are no longer 'lost' until the QC stages.