Beads: a dependency-graph task tracker as memory for coding agents

Everything worth knowing about gastownhall/beads: a distributed issue tracker, with dependencies and git sync, that gives coding agents structured, persistent memory instead of markdown lists. As of September 3, 2026 it carries 26,858 stars.

What Beads is

Beads is a dependency-graph issue tracker built for coding agents (Claude Code, Codex, GitHub Copilot, Gemini, Factory Droid, and others) to keep a structured, persistent record of their work. The core product is a command-line binary called bd, written in Go and licensed under MIT, which per its README offers “persistent, structured memory for coding agents,” replacing “messy markdown plans” with a dependency-aware graph.

It isn’t a model, an agent server, or a plugin — it’s an embedded task database (Dolt, a version-controlled SQL) that lives inside the project’s repository. The README’s badge syntax and release notes indicate the project is also distributed as an npm package (@beads/bd) and as an MCP server (beads-mcp on PyPI). The stated platforms are macOS, Linux, Windows, and FreeBSD.

Origin

The repository was created on October 12, 2025 by Steve Yegge, an engineer known for his tech essays and the term “brotopp.” The GitHub API confirms that steveyegge/beads permanently redirects (HTTP 301, same repository ID) to gastownhall/beads: the project moved from a personal account to the Gas Town Hall organization (gastownhall), which is now home to the whole ecosystem.

The launch timeline is verifiable in the author’s own Medium articles, listed in the repository’s ARTICLES.md file: “Introducing Beads: A Coding Agent Memory System” frames the project as a solution to agents’ “50 First Dates” problem — agents that don’t remember what was done between sessions. “The Beads Revolution” recounts that Yegge built Beads in six days using Claude, and “Beads Blows Up” describes the first three weeks and the protocol dubbed “land the plane” (session cleanup on wrap-up). In launch week, Hacker News threads 45566423 (12 points, 0 comments, October 13, 2025) and 45566864 (19 points, 1 comment) appeared, with a modest initial reception compared to the project’s later popularity.

Philosophy and principles

The principles that can be inferred from the README, CONTRIBUTING.md, and the author’s articles:

Structured memory, not improvised: instead of markdown task lists the agent re-reads and forgets, Beads maintains a dependency graph where each task (“bead”) has hierarchical IDs, state, priority, and blockers. The bd ready command automatically computes which tasks have no pending blockers, so the agent always knows what to do next.
Optimized for agents, not humans: output is JSON by default on the key commands (bd ready --json, bd list --json), meant for an LLM to process without parsing tables or free text.
Collision-free identifiers: IDs are bd- plus four or more characters (bd-a1b2), with a length chosen per the birthday paradox to avoid collisions in multi-agent, multi-branch workflows. HN user simonw explicitly flagged this in the main thread as one of the more interesting design details.
Compaction as memory decay: the README documents “Compaction: Semantic memory decay,” a mechanism that summarizes old closed tasks to save context window.
Git is optional: per the README, Beads works without git via the BEADS_DIR variable and the --stealth flag; the Dolt database is the real backing store and git is just the optional transport.
ZFC (Zero Framework Cognition): CONTRIBUTING.md requires anyone contributing orchestration code to follow the author’s ZFC principles: intelligence must live in the AI model, and orchestration code must stay “dumb” (no heuristics, no semantic analysis, no ranking in application code).

How it works

The basic flow documented in the README:

bd init in the project creates or updates AGENTS.md so the agent discovers the workflow, and installs Claude Code and Codex integrations by default (unless --skip-agents or --stealth).
bd prime prints the working context and the project’s persistent memories; it’s the entry point of every session.
bd ready lists tasks with no open blockers.
bd update <id> --claim atomically claims a task (assigns an owner and moves it to in-progress), preventing two agents from working on the same one.
bd close <id> "comment" closes the task and releases its blockers, so dependent tasks move into bd ready.
bd remember "insight" saves a project memory that bd prime will inject into future sessions; the README explicitly states that persistent memory should use this rather than creating MEMORY.md files.

A cinematic dark-mode flow diagram showing the Beads CLI lifecycle, with six neon stations arranged in a circular pipeline: bd init installing agent integrations, bd prime injecting persistent context, bd ready lighting up unblocked beads, bd update --claim placing an atomic lock, bd close releasing downstream dependencies, and bd remember storing a glowing memory shard

A detailed dark-mode dependency graph illustrating Beads as a structured tracker instead of disordered markdown lists, with a faded markdown checklist dissolving into particles on the left and a crisp neon graph of beads with hierarchical IDs, state chips, priority rings, and lock icons on the right, next to a CLI window showing bd list --json output

Dependencies are created with bd dep add <child> <parent> (blocker, relates-to, parent-child), and hierarchical IDs (bd-a3f8 epic, bd-a3f8.1 task, bd-a3f8.1.1 sub-task) let you structure epics. There are also knowledge links (relates-to, duplicates, supersedes, replies-to) and a “message” issue type with threads (--thread) for agent-to-agent communication.

Storage uses Dolt in two modes: embedded (default, in-process Dolt, data in .beads/embeddeddolt/, single writer) and server (bd init --server, connected to an external dolt sql-server for multiple concurrent writers). Cross-machine sync happens via bd dolt push / bd dolt pull against the refs/dolt/data reference on the git remote; the .beads/issues.jsonl file is an export for visualization and exchange, not the source of truth. A “schema version guard” detects if a database was migrated by a newer binary than the one opening it and refuses to continue with an actionable error, instead of throwing SQL queries that would fail with cryptic messages.

A technical illustration of Beads storage using Dolt in two modes: on the left, an embedded in-process Dolt core with a single writer and data in .beads/embeddeddolt/; on the right, an external dolt sql-server serving multiple concurrent writers, with neon sync lines toward a git remote and an issues.jsonl file marked as export, not source of truth

A cyberpunk origin-story image for the Beads project showing a repository migration from a personal account to the Gas Town Hall organization, with a glowing timeline marking October 12, 2025, a 301 redirect arrow transforming a small personal repository icon into a larger neon city-hall structure labeled gastownhall, early Hacker News thread bubbles, and a rising star and fork graph

The ecosystem

Beads is the work-record layer of a family of projects under the gastownhall (Gas Town Hall) organization. Star counts from the GitHub API consulted on September 3, 2026:

gastownhall/gastown — Gas Town, the multi-agent workspace manager built on Beads: coordinates 20-30 agents (Claude Code, Copilot, Codex, Gemini), with its own concepts (Mayor, Rigs, Crew Members, Polecats, Convoys). Its README states that work state is saved in “the Beads ledger.” 17,922 stars, 1,650 forks.
gastownhall/gascity — an orchestration build SDK for multi-agent flows. 1,217 stars.
gastownhall/wasteland — a federation protocol between “Gas Towns” (a federated work economy over Dolt/DoltHub). 87 stars.
gastownhall/marketplace — the project’s plugin marketplace for Claude Code (the Wasteland plugin). 18 stars.
gastownhall/homebrew-beads — the Homebrew tap for the bd binary. 21 stars.

Ports and community tools

The repository maintains an official docs/community-tools.md file that lists and classifies community tools by maturity. Among the most relevant:

Dicklesworthstone/beads_rust — a Rust port, “local-first, non-invasive,” storing tasks in SQLite with JSONL export; 1,078 stars. It has its own Hacker News thread (46674515, 3 points).
beadbox/beadbox — a native macOS/Windows/Linux dashboard (Tauri + Next.js) with per-epic progress and inline editing; 118 stars.
AvivK5498/beads-web — a visual kanban interface for the CLI (Next.js + Rust) with epic tracking; 97 stars.
boardthatpowder/BeadSpec — a desktop app with OpenSpec integration; 7 stars (per the API at the time of consultation).
jedarden/NEEDLE — a headless Rust orchestrator that processes the beads queue and dispatches to any LLM CLI; 20 stars.
w3dev33/beads-task-issue-tracker — a cross-platform desktop app (Tauri/Vue).
quietpublish/mardi-gras — a parade-themed TUI with real-time updates, tmux integration, and Claude Code dispatch.
zjrosen/perles — a search and kanban TUI with its own query language (BQL).
jeanpfs/bd-board — a local-first web dashboard (TanStack Start/React).
zenchantlive/beadboard — a multi-agent orchestration system with agent-to-agent messaging and a DAG graph.
brendan-appstart/bead-me-up-scotty — a multi-project web interface with human/agent attribution; public demo at beadmeupscotty.com.
cuongbphv/beads-dashboard — a VS Code extension with a summary view, roadmap, and board; also on Open VSX.
harry-miller-trimble/Lista Beads — a VS Code extension with multi-tracker sync (Azure DevOps, GitHub, Jira, Linear, GitLab).
joshuadavidthomas/opencode-beads — an OpenCode plugin with /bd-* commands.
jklenk/thread — a read-only forensic and analytics layer over the Dolt history (fidelity scores, rework cost, HTML report).
beadhub/beadhub — a coordination server for agent teams: work claiming, file reservation, presence, and messaging; with a free hosted service at beadhub.ai.
acartine/foolery — a web interface for orchestrating Claude Code over Beads (Show HN 47075901, 7 points, 2 comments).
davetashner/stringer — a “codebase archaeology” CLI that extracts TODOs and friction points from git and imports them into Beads.
conallob/jira-beads-sync — Jira sync to and from beads.
DyrtyJax/embeadings — a read-only coordination CLI that textually embeds issues for local semantic retrieval.
HerbCaudill/beads-sdk — a typed TypeScript SDK with no runtime dependencies.

The official docs/related-projects.md file lists prmichaelsen/scry, a recall and knowledge-graph layer for coding agents (what was decided and why), complementary to Beads (what to do next); both arrived independently at the same hash-based ID convention.

Official and semi-official status

There’s no formal standard designation, but two verifiable facts define its status:

Stated Anthropic endorsement: an Anthropic engineer, Antoine Brugeat, said in connection with Claude Code’s task system (v2.1.16) that “We took inspiration from projects like Beads by Steve Yegge.” The quote appears in Paddo’s article “From Beads to Tasks: Anthropic Productizes Agent Memory” (January 23, 2026), which transcribes the original tweet; the tweet itself couldn’t be retrieved directly in this research, so the quote should be read as secondhand testimony, though the article links to it. Claude Code’s own Tasks system is session-level (saved in ~/.claude/tasks), while Beads is project-level and multi-agent: Paddo’s analysis presents them as complementary layers, not competitors.
De facto standard for multi-agent work tracking: Gas Town (17,922 stars), Gascity, BeadHub, NEEDLE, Thread, and the two dozen tools in the official community list are built on the bd CLI or its format. The official list also warns that tools that read the old .beads/issues.jsonl format directly are incompatible with current versions and should use the CLI (bd list --json), which reinforces bd’s position as the canonical interface.

In practice, this means adopting Beads means aligning with the record-keeping layer most open-source multi-agent orchestration systems assume as a dependency; but none of the companies mentioned certifies its outcomes, and the presence in the gastownhall/marketplace marketplace is a catalog maintained by the project itself, not by a third party.

Quick-start guide

Installation and first boot

Prerequisites: macOS, Linux, Windows, or FreeBSD. Methods documented in the README:

brew install beads           # macOS / Linux (recommended)
npm install -g @beads/bd     # Node.js users
curl -fsSL https://raw.githubusercontent.com/gastownhall/beads/main/scripts/install.sh | bash

There’s also go install github.com/steveyegge/beads/cmd/bd@latest (the README still keeps the steveyegge path even after the move to the organization) and an Arch (AUR) install. The README asks you to verify the downloaded binary’s checksum against the release’s checksums.txt before trusting it.

First boot in a project:

cd your-project
bd init
bd prime

bd init creates or updates AGENTS.md and installs the project’s Claude Code/Codex integrations (skippable with --skip-agents or --stealth). bd prime shows the workflow context and accumulated memories; on a freshly initialized project, it will show an empty list of available tasks.

Common workflows

To have the agent work through a queue: run bd ready; the result lists tasks with no blockers. The agent claims one with bd update <id> --claim and closes it with bd close <id> "comment"; once closed, its dependents appear in bd ready on the next call.
To plan an epic: bd create "Epic title" -p 0 and then child tasks with bd dep add <child> <epic>. The hierarchical IDs (bd-xxxx.1.1) reflect the structure.
To remember a decision across sessions: bd remember "the API uses cursor-based pagination"; on the next session bd prime will inject it into context. The README prohibits creating MEMORY.md files for this.
To sync between two machines or agents: bd dolt push and bd dolt pull against the git remote (refs/dolt/data reference). In server mode (bd init --server), multiple concurrent writers point at the same dolt sql-server.

A conceptual image of Beads' agent-first philosophy, with a large dark-mode brain-circuit made of beads and dependency edges representing structured memory, one section showing bd ready automatically selecting unblocked tasks, collision-free ID chips, a compaction chamber compressing old closed beads into a semantic memory crystal, and a ZFC zone of a dumb pipeline with no ranking logic

Essential configuration

AGENTS.md (created by bd init): the agent’s discovery point; a minimal snippet can be added for agents not covered by bd setup, with bd prime, bd ready, bd update --claim, bd close, and bd remember.
BEADS_DIR: an environment variable that locates the .beads/ folder and disables git-based discovery; useful for monorepos, CI/CD, and non-git VCS (Sapling, Jujutsu, Piper).
--stealth (with bd init): a local mode with no file commits to the repository; disables git hooks.
--contributor (with bd init): for a cloned (fork) repository, routes planning issues to a separate repository (e.g., ~/.beads-planning) so experimental work doesn’t leak into PRs.
BD_IGNORE_SCHEMA_SKEW=1: an escape hatch to continue if the database schema is ahead of the binary; the README recommends it only when migrations are additive.

Common pitfalls and fixes

Accidental v1.2.1 release and “schema version mismatch”: the v1.2.2 release notes (August 15, 2026) document that v1.2.0 and v1.2.1 were published by mistake on August 11, 2026 without release testing; running v1.2.1 even once migrates the local schema from v53 to v65, and 1.1/1.2.2 binaries refuse to open the database. The recovery guide (docs/RECOVERY-1.2.1.md) recommends rolling the schema cursor back to v53 with a dolt sql command; as a safe stopgap in that range, BD_IGNORE_SCHEMA_SKEW=1. The notes insist on updating all machines to v1.2.2 before recovering, because a leftover 1.2.1 binary would re-migrate the database.
Incompatible community tools: the official list warns that tools reading .beads/issues.jsonl directly no longer work with current versions; they must use bd list --json. The JSONL file is an export, not the source of truth.
Windows antivirus false positives: the README links docs/reference/antivirus.md with the verification flow (checksums, signature preserved in the macOS install, local re-signing only via BEADS_INSTALL_RESIGN_MACOS=1).
Nix vendorHash issues: CONTRIBUTING.md documents that if go.mod is updated past the nixpkgs revision pinned in flake.lock, Nix CI fails; the fix is ./scripts/update-nix-vendorhash.sh or the documented Docker script.

Integrations and migration

Agents: bd setup codex, bd setup claude, bd setup factory, bd setup cursor, bd setup mux, and others (see bd setup --list) install skills, hooks, and AGENTS.md guides per agent. For agents not covered, bd onboard prints a snippet to paste into the agent’s instruction file.
MCP: beads-mcp on PyPI (version 1.2.2 at the time of consultation) exposes the tracker as an MCP server.
Editors: VS Code extensions (Beads Dashboard, Lista Beads, vscode-beads), Neovim (beads.nvim, nvim-beads), and a JetBrains plugin (beads-manager), per the official list.
Jira / external trackers: jira-beads-sync (CLI + Claude Code plugin) and Lista Beads (sync with Azure DevOps, GitHub, Jira, Linear, GitLab).
HTTP API: the v1.3.0-rc.1 release notes (August 31, 2026, pre-release) announce bd serve, a server with 41 OpenAPI operations (claim, close, dependencies, memory, events). Being a release candidate, its status is experimental.
Migrating from flat files: to import TODOs and friction points extracted from git, there’s stringer (JSONL output compatible with bd init --from-jsonl, per the official list). Migration toward simpler alternatives is documented by the community itself: wedow’s ticket project (see comparisons) was born from a user who removed Beads after several months of use, per their Show HN.

Current metrics

Measured: September 3, 2026, GitHub API and package registries.

Metric	Value
Stars	26,858
Forks	1,812
Subscribers	93
Open issues per the API	920
Commits (main branch)	≈ 10,770
Primary language	Go
License	MIT
Created	October 12, 2025
Last update	September 3, 2026
Latest stable release	v1.2.2, August 15, 2026
Latest pre-release	v1.3.0-rc.1, August 31, 2026
npm `@beads/bd`, weekly downloads	6,060 (Aug 23-29, 2026)
npm `@beads/bd`, monthly downloads	22,861 (Jul 31 - Aug 29, 2026)
PyPI `beads-mcp`, weekly downloads	1,218
PyPI `beads-mcp`, monthly downloads	10,268

Top contributors returned by the API, by contribution count: steveyegge (4,797), maphew (772), coffeegoddd (616), julianknutsen (268), dependabot[bot] (121), quad341 (111), harry-miller-trimble (99), turian (98), and kevglynn (95). The API’s open_issues_count field may include open pull requests, so it shouldn’t be read as an issues-only count. The commit count was calculated from API pagination (107 pages of 100 plus 70 on the last page) and is approximate: it may vary between query and reading. The concentration of contributions in the original author (4,797 of ≈ 10,770 commits) is consistent with Yegge’s own account of maintaining a very high, agent-assisted pace of development.

Community reception

The evidence gathered shows real adoption, enthusiasm for the design, and also concrete criticism about complexity and cost of use:

The main Hacker News thread, 46075616 “Beads – A memory upgrade for your coding agent” (submitted by latchkey on November 28, 2025), reached 111 points and 68 comments. Highlights:
- simonw underlined the design details (birthday paradox for ID length, JSONL storage in .beads/) and proposed moving the data to a dedicated git branch; in another comment, he documented that the project uses Beads on itself and linked its own open issues in Datasette Lite.
- iand675 reported combined use with github/spec-kit: “set up spec-kit first, then updated its templates to tell it to use beads to track features… quality-of-life improvement,” citing recent LLMs’ tendency to write everything into files.
- thih9 questioned the README’s wording (“agents enjoy working with Beads and use it spontaneously”): “Can a trained LLM develop a preference for a given tool…?” — objecting that an agent’s reported satisfaction isn’t evidence of quality.
- mbanerjeepalmer proposed the minimal alternative: give agents Taskwarrior, because “most LLMs already understand Taskwarrior. They’ve never heard of Beads.”
- wowamit and iddan agreed the README was so long it was hard to identify the core problem the tool solves; CuriouslyC was blunter: “I don’t understand the point of this project. We already have github/gitlab for tasks.”
- pbw offered the more favorable reading: the project marks the shift from “teaching AIs to use tools designed for humans” to “inventing new tools designed specifically for AI use.”
- aschearer said he was working on something similar with a local SQLite index and asked how the quality gate (conformance) gets resolved when checks require intelligence.
The most concrete criticism came from the Show HN 46487580 “I replaced Beads with a faster, simpler Markdown-based task tracker” (84 points, 51 comments, January 4, 2026, the wedow/ticket project). User wild_egg, ticket’s author, recounted: “I’ve been running long duration coding agents with Claude Code for about 6 months… giving Claude tools for proper task tracking was a massive unlock. But Beads grew massively in a short time and every release made it slower and more frustrating to use. I started battling it several times a week as its background daemon took to syncing the wrong things at the wrong times.” The conversation also included khimaros asking why not use git-bug, jannniii asking why not GitHub Issues, and code_martial recounting that his own agent offered to use Beads and declined it: “it declined as beads is a task tracker and what we needed was a spec tracker.”
The Rust port has its own thread, 46674515 “A fast Rust port of Steve Yegge’s beads” (3 points, submitted by sorenbs, January 19, 2026), and the Dicklesworthstone/beads_rust project has accumulated 1,078 stars, a sign of demand for a lighter version.
The derivative ecosystems also show up on HN: “Beadhub.ai – Real time coord for coding agents” (47099148), “Foolery – a web UI for orchestrating Claude Code agents on top of Beads” (47075901, 7 points, 2 comments), and “GuardRails – a new coding agent task tool inspired by Beads” (47074034).
The sibling project Gas Town generated much bigger threads, which contextualizes the scope of the ecosystem: “Welcome to Gas Town” (354 points, 224 comments, January 1, 2026), “Gas Town’s agent patterns, design bottlenecks, and vibecoding at scale” (403 points, 433 comments, January 23, 2026), and “Gas Town: From Clown Show to v1.0” (113 points, 164 comments, April 14, 2026).

In summary: the enthusiasm centers on the dependency-graph design and the cross-session memory use case; the criticism centers on growing complexity, the pace of releases (with the v1.2.1 incident as a documented example), and the question of whether the problem isn’t already solved by tools LLMs already know (Taskwarrior, git notes, GitHub Issues).

Comparison with similar projects

Project	Verifiable overlap	Verifiable difference
`wedow/ticket` (Show HN 46487580, 84 points)	A dependency-aware task manager for coding agents, explicitly inspired by Beads.	A single-file bash script over coreutils and flat files; no Dolt, no daemon, no git sync. Its author built it after abandoning Beads over its complexity.
`hmans/beans` (mentioned in the ticket thread by czottmann, a contributor to its agent rules)	A markdown-based task tracker inside the project, for humans, teams, and agents.	Flat markdown format instead of a Dolt database; no dependency graph with automatic blocker release.
Claude Code Tasks (v2.1.16+)	A task system with dependencies and persistent state, inspired by Beads per the Anthropic quote captured by Paddo.	Session-level (saved in `~/.claude/tasks`), Claude Code/Agent SDK only, no sync across machines or heterogeneous agents; can’t be queried via MCP.
`git-bug/git-bug` (mentioned in the ticket thread by khimaros)	A local command-line bug tracker with dependencies.	Designed for humans and git repositories, not agents; no LLM-oriented JSON output, no memory compaction.
Taskwarrior (mentioned in 46075616 by mbanerjeepalmer)	A local command-line task tracker.	No dependency graph between tasks, no sync, no semantic memory; its advantage is that LLMs already know it from training data.
Flux (mentioned in Paddo’s article)	Task coordination with a kanban board, MCP-first, web dashboard.	Team-oriented with a web dashboard; in Paddo’s table it’s presented as a team layer versus Beads’ project layer.
`Dicklesworthstone/beads_rust` (1,078 stars)	Same data model and flow, local-first.	Rust implementation over SQLite with JSONL export; a lightweight alternative when the Go CLI and Dolt are overkill.
`github/spec-kit` (mentioned in 46075616 by iand675)	Structured planning workflows for coding agents.	Complementary, not competing: spec-kit defines the process (specify → plan) and Beads can track the resulting tasks, as the cited user does.
`steveyegge/beads` → `gastownhall/beads`	—	Same project: the API confirms the old URL redirects (301) to the organization; the README’s badges and the `go install` path retain references to `steveyegge`.

How to contribute

CONTRIBUTING.md documents a detailed process:

Prerequisites: Go 1.26+ (per go.mod), git, a C compiler (CGO required for the embedded Dolt database), and a pinned golangci-lint v2.10.1.
Build and tests: make build, make test, make install (installs to ~/.local/bin); the canonical testing guide is engdocs/TESTING.md, with a “proportional validation budget” (docs-only changes → doc checks; Go changes → focused tests and a final make test).
Flow: fork → feature branch (git checkout -b feature/my-feature) → changes → tests → make ci-pr-lint (must pass cleanly) → PR. PR hygiene is strict: one issue per PR and one PR per issue, no incidental changes, no .beads/ data in the diff, and the PR must open with a plain-language “What” and “Why.”
ZFC: anyone contributing orchestration code must follow the Zero Framework Cognition principles: no heuristics, keyword matching, ranking, or semantic analysis in application code; cognitive decisions are delegated to the AI model.
Contributor protection against agents: the project states it uses AI agents for maintenance and sets explicit rules: contributor PRs take priority, agents must review and build on others’ work (not rewrite it), contributor tests are preserved, Co-authored-by: trailers are kept, and there are no silent closures. The triage guide is in PR_MAINTAINER_GUIDELINES.md.
Releases (for maintainers): bump version and CHANGELOG, tag vX.Y.Z, push the tag, and GitHub Actions builds and publishes.

Use cases and who this repository can help

Developers running coding agents for extended periods (Claude Code, Codex, Copilot, Gemini): bd prime at session start and the bd ready queue solve the core problem the author describes as “50 First Dates” — the agent knows what’s left, what’s blocking, and which project memories apply, without re-reading transcripts.
Teams orchestrating several agents over the same repository: atomic claiming (bd update --claim), collision-free IDs, and Dolt sync over git (bd dolt push/pull) are designed for multi-agent use; Gas Town (17,922 stars) and BeadHub demonstrate usage at the scale of 20-30 agents.
Maintainers of projects with institutional memory: bd remember accumulates decisions and lessons that get injected into every session, and automatic compaction limits long-term context cost. The fact that the project uses Beads on itself (documented by simonw on HN) is the most direct adoption.
Teams that also need human visibility: the official community list offers web dashboards (bd-board, beads-ui, Bead Me Up Scotty), desktop apps (Beadbox, Beadazzle, BeadSpec), editor extensions (Beads Dashboard, Lista Beads, beads.nvim), and analytics (Thread), so the ledger the agent handles can be read and audited by people.
Integrations with corporate trackers: jira-beads-sync and Lista Beads (Azure DevOps, GitHub, Jira, Linear, GitLab) let you use Beads as the agent’s working memory without abandoning the team’s official tracker.
Environments without git or CI: BEADS_DIR and --stealth let you use Beads with alternative VCS (Sapling, Jujutsu, Piper), in monorepo subdirectories, or in ephemeral databases for evaluation and testing, per the README.
Who shouldn’t use it: anyone looking for the simplest option for a single agent on a single project might prefer ticket, beans, or Claude Code’s native Tasks; the community itself (thread 46487580) documents the point at which Beads’ complexity becomes a cost rather than a benefit.

Resources

Repository: https://github.com/gastownhall/beads (the old steveyegge/beads redirects here)
Documentation: https://beads.gascity.com/ | installation: docs/getting-started/installation.md | troubleshooting: docs/reference/troubleshooting.md | FAQ: docs/reference/faq.md
Community tools (official list): https://github.com/gastownhall/beads/blob/main/docs/community-tools.md | https://github.com/gastownhall/beads/discussions/276
Official MCP server: https://pypi.org/project/beads-mcp/
npm packages: https://www.npmjs.com/package/@beads/bd
Ecosystem repos: https://github.com/gastownhall/gastown · https://github.com/gastownhall/gascity · https://github.com/gastownhall/wasteland · https://github.com/gastownhall/marketplace
Rust port: https://github.com/Dicklesworthstone/beads_rust
The author’s articles: Introducing Beads · The Beads Revolution · Beads Blows Up · Beads Best Practices
Third-party articles: An Introduction to Beads (Ian Bull) · Beads: Memory for Your Coding Agents (Paddo) · From Beads to Tasks: Anthropic Productizes Agent Memory (Paddo) · Beads: A Git-Friendly Issue Tracker for AI Coding Agents (Better Stack)
Hacker News threads: 46075616 (111 points, 68 comments) · 46487580 (84 points, 51 comments, ticket alternative) · 46674515 (Rust port) · 47075901 (Foolery) · 47099148 (Beadhub.ai)
Video (titles found via YouTube search; views/channels not verified): “Beyond Instructions: How Beads Lets AI Agents Build Like Engineers” · “The Evolution of Beads: From Markdown Chaos to Issue Tracking” · “I Gave Claude Code Permanent Memory - The Results Are Shocking” · “Beads vs SpecKit and Kiro” · “Beads - Structured Memory for Coding Agents - Brandon Harvey: AI in Action 13 Feb 2026”

Methodology note: this article draws on the README, CONTRIBUTING.md, ARTICLES.md, docs/community-tools.md, and docs/related-projects.md of gastownhall/beads, the v1.2.2 and v1.3.0-rc.1 release notes, the GitHub API, npm, PyPI, Hacker News (Algolia), and third-party articles consulted on September 3, 2026. The Antoine Brugeat (Anthropic) quote comes from a Paddo article transcribing a tweet; the tweet itself was not retrieved directly. Figures change over time.