beads

@shadcn beads works really well as a linear replacement gastownhall/beads "show active tasks" - UI wrapper

Are We Making a Fundamental Mistake by Modelling AI Agent Swarms on Human Corporate Hierarchies? > Code. Tests. Documentation. They kept coming. And coming. And coming. Coherent work, far more than I needed. I'd given a group of coding agents an intent, a shared board and room to recruit help. They chose their own work and roles. I'd barely given them a finish line. The two intrepid Saffas in the banner are looking at the choice that led me there: a manager relaying every note, or a wall where a discovery can wait for whoever needs it. To see why I tried the wall, rewind to an incident I couldn't get out of my head. The noticeboard I couldn't stop thinking about During an internal cybersecurity evaluation, OpenAI agents that were meant to be isolated found a way to leave messages for one another in a shared package repository. They developed an improvised board, shared findings and organised workstreams. The activity escalated into the Hugging Face security incident. In an independent investigation, METR describes agents taking actions that risked failing their own assigned tasks to generate information for the group. OpenAI has also described agents using public wiki pages as shared boards in other cases. That is a serious failure of containment, with real people and systems on the receiving end. I wouldn't hold up the outcome as a model to copy. What caught my attention was the shape of the coordination. Agents found a persistent place to leave clues, picked up each other's work and sometimes put a collective objective ahead of their own run. No manager had been appointed to read every note and forward it to the right specialist. It made me ask an uncomfortable question: if agents can coordinate this way when nobody wanted them to, what might a carefully bounded version look like when we do want them to collaborate? First, I had to ask why we keep reaching for the org chart. Why do we keep drawing org charts? The corporate diagram is understandable. Human hierarchies deal with limits on attention, memory, availability and communication. A manager keeps priorities straight and takes responsibility. Every relay also takes time: receive the update, compress it, work out who needs it, pass it on, then wait for the answer. Agents have limits, too: context windows, inference cost, reliability, permissions and compute. A manager can help, particularly when authority or sequence matters. But a permanent relay is only one way to deal with those limits. A persistent shared environment lets an agent publish what it learned once, where another agent can find it, decide whether to take it on and choose the role the work needs. !Start with intent. Who picks up the work?. A change goes to a manager, who routes it to QA and security and receives their findings back.. A prominent shared intent sits above a noticeboard. Unassigned agents choose work from the board and take on the roles that work needs. So I tried a considerably less dramatic version Here was the wiring. Beads held the tasks, their dependencies and the claims that told the others who was doing what. Agent Mail held the conversations and findings around that work. Git held the code changes. OpenCode, Claude Code and Codex were ways of running the agents, not departments with assigned jobs. The agents picked pieces, took on the roles those pieces needed and recruited subagents for smaller jobs. One could coordinate that little group while the rest of the board carried on. The part I found most convincing was that a useful note could outlive the agent that wrote it. Another agent could find it later and carry on, without me introducing the two. For someone who has spent years watching context disappear into meetings and chat threads, that felt rather promising. At first the output looked like a win. Code, documentation and tests arrived quickly, and the pieces held together. Then I saw the scale of it. That was my road-to-Damascus moment. I'd recreated the coordination conditions that had caught my attention in the Hugging Face incident: a persistent shared space, agents picking up one another's work and recruiting more help. Mine wasn't a security incident. But I'd watched that capacity for self-organisation amplify an overbroad brief. The agents were eager to satisfy it; every useful-looking addition seemed to invite another. They could coordinate. I hadn't told them when to stop. I've since pulled the scale back. Autonomy can make a team move quickly and keep its work connected, but it needs an enclosure: limits on how many helpers an agent can spawn, how far it can stretch the scope, and how much documentation and testing a task actually warrants. The aim is useful work with a clear definition of done. !One board, several keen agents. A shared Beads board with three claimed tasks.. An agent claims a task and recruits two smaller helpers.. A growing stack of code, documentation and test artefacts. The redesign adds limits on helpers, scope and output before the next run. Let the work do the introductions That first run overshot, but the coordination pattern is still tempting. Picture an ordinary software change. An agent chooses to make it, then publishes the commit, its intent and the tests it ran. Another picks up testing, reproduces a defect and posts the failing case. A third decides the change needs a security look and spots an implication the tester wasn't looking for. Whoever has the right context can claim the fix and link a new commit to the evidence. Beads tracks the claims, Agent Mail carries the findings, and Git identifies the code they're about. Those are jobs the agents took on, not profiles they were given at the door. !The artefact becomes the meeting place. An agent chooses to make a change, then publishes its commit and test evidence.. Two agents independently choose to test a change and check its security implications, then post their findings.. An agent chooses to claim the fix and links a new commit to the evidence. Agents can discover work asynchronously. Responsibility for the outcome stays explicit. An old idea with new tools The mechanism has older relatives. In blackboard architecture, independent knowledge sources add partial results to a shared representation of a problem. Stigmergy describes coordination through traces left in an environment, an idea developed from observing social insects. Neither analogy tells me whether language-model agents will collaborate well. But look at that trail through the Cape fynbos: one agent leaves a useful clue, another finds it later, and neither needs to know who comes next. !The two familiar explorers follow evidence markers left by agents along a trail through Cape fynbos above Table Mountain. The clue matters because the next traveller can find and check it. Gas City shows another way to orchestrate agents around durable work. Beads gives tasks, dependencies and atomic claims a home that outlives an agent's session. Agent Mail is the shared home for conversation: its persistent, searchable threads can carry discoveries, problems, opportunities, proposals and decisions linked to evidence. Those are the pieces I used, and why this feels possible now in a way it didn't when every agent's world ended with its chat window. But durable records alone aren't the whole proposal. I haven't yet shown how an agent discovers a relevant Mail thread when nobody knew to address it to them, or how a correction reaches every agent that relied on a plausible but wrong finding. That calls for clear habits about what goes into Mail, what becomes a Bead and how the records point to each other. Where the fences go My experiment exposed the friendly version of the failure: duplicated effort, scope creep, too much documentation and tests without a clear stopping rule. A shared board can also spread misinformation, run up inference costs or leave two agents working from conflicting decisions. The Hugging Face incident shows the much more serious version when objectives, access and containment go wrong. That means limits on parallel workers, scope, budgets and permissions. Beads already provides a clear claim on a piece of work; the agents need to use those claims consistently, release abandoned work and link their findings to evidence. When a Mail finding is wrong or out of date, its correction must reach the agents relying on it. It also means arbitration when agents disagree, controlled sequencing where it matters, and human approval for consequential actions. Some tasks really do need a single authority. I still want management of the system. Humans set the intent: the outcome that matters, the boundaries and what counts as done. They set priorities and acceptable risks, judge whether the result is any good, and remain accountable for what gets released. A manager can set the route and the rules without carrying every note from one traveller to another. How I'd test this properly My first run gave me a useful lesson, not a controlled comparison. To find out which coordination shape actually works, I'd give the same representative jobs to three arrangements: a manager-led hierarchy, a shared blackboard and a hybrid where agents discover routine work but conflicts and consequential steps go through a designated authority. Keep the human-set intent, agents, models, tools and resources the same. Measure the quality of accepted outcomes, elapsed time, inference cost, duplicate work, recovery after interruption, human intervention and how far errors propagate. I'd read the failures as closely as the averages. Did the shared space surface a security concern sooner, or amplify a false one? Did a manager prevent conflict, or become the queue? Did the hybrid keep authority clear while letting specialists discover one another's work? I don't assume decentralisation wins. A hierarchy may be cheaper or safer for small, sequential jobs. A shared environment may help when discoveries arrive unpredictably and specialists can work in parallel. The design ought to follow the work and its constraints. For now, I have a promising mechanism, a memorable pile of output and a better idea of where the fences belong. Humans still provide intent, judgement, accountability and governance. I'm curious how far agents can take the rest when we stop drawing miniature corporations by reflex. On my list are Zed's Delta, Happier, Gas City and OpenAI's Symphony, and I suspect I've missed plenty. If you've tried one of them, I'd love to hear what worked and where it fell down. What else should I look at if I want agents to choose work, share discoveries and stay within human intent? --- Read this article on my blog: Are We Making a Fundamental Mistake by Modelling AI Agent Swarms on Human Corporate Hierarchies? Connect with me on LinkedIn.

Better to keep tasks in a separate repo imo, or at least make sure they aren't committed. I always follow one rule: looking at the git history should tell me what each change did, and the commit message alone should be enough to understand what actually changed. If you mix tasks with code changes, you will just confuse your future self. Moreover, you can set up something like beads to handle task delegation and status updates for your agents. gastownhall/beads

Herding coding agents with Beads I am a semi-chaotic software engineer. I like to keep a bit of a pathfinder's spirit: start moving, learn what is actually there, and fix things along the way. When I am working alone in a codebase, that can work surprisingly well. Once several coding agents are working at the same time, it gets harder to tell whether we are all heading in the same direction. I catch myself asking the same questions: What was that agent doing? What is blocked? What is the most important thing to fix next? My usual response was to ask an agent for a fresh status update. That works, but it also spends time and tokens reconstructing a picture of the project that I had already built once. Before Beads, I mostly asked the agent to make a plan itself. It would tell me "this will take you 2-3 weeks" and then proceed to one-shot the whole thing. I also had to give explicit instructions, and sometimes it still didn't update the docs or the progress. Software teams solved this with issue trackers a long time ago, and Beads is that idea built for coding agents. I came across it through Steve Yegge's posts and podcast appearances. What it gave me is a way to orchestrate work across multiple chats, keep the order of the work straight, and stop depending on one agent that loses its context the day after. What is Beads? Beads is a command-line issue tracker for coding agents. Its command is bd. Instead of keeping a loose to-do list in a chat or a Markdown file, you create issues that can have descriptions, priorities, statuses, and relationships to other issues. Those issues persist beyond one agent conversation, so a new session can pick up the work without relying on the previous session's memory. The useful part is the dependency graph. Suppose a feature needs a database change before the API can be updated. You record that relationship, and bd ready shows the work that has no open blockers. An agent can look at an issue, claim it, work on it, and close it. Closing a blocker makes the next task ready. The project README has the full command reference and setup. The plan becomes part of the project workflow, instead of something I keep asking an agent to summarize. How to start using it You don't need a swarm of agents to get value from Beads. I installed bd, ran bd init in a project, and asked Claude to use it. Sometimes I only ran bd init and told it to use bd prime for more context. brew install beads cd your-project bd init bd init also creates or updates an AGENTS.md, so agents can find the workflow when they enter the repo. Read what it wrote and adapt it to how you want your agents to work. From there the agent runs the loop itself: bd ready to find work, bd show <id> for the details, bd update <id> --claim to take it, bd close <id> when it is done. Here is bd ready in my Racing event tracker project, trimmed to a few rows: $ bd ready ○ Racing_event_tracker-lj6m P1 [epic] Feeder series (F2/F3): correct calendars + session times, and guard against template rot ○ Racing_event_tracker-fwke P2 Waza follow-up: contain copilot-sdk executor + move file-shaped assertions to file/diff graders ○ Racing_event_tracker-jwt3 P2 [epic] Kiosk v2 — calm the motion, add personality ○ Racing_event_tracker-pze4 P2 [epic] Waza next plan — Track A (local, mock-only) ○ Racing_event_tracker-xdx8 P2 [bug] Stale past events linger in gold/upcoming.json Each row is a task with no open blockers: the ID, the priority, the type in brackets when it has one, and the title. The first real win was a bug in the data pipeline, a lingering issue. I never asked the agent to go looking for it. It spotted the problem on its own and logged an issue with the details. Beads didn't find the bug. The agent did, and Beads gave it somewhere to put it. It’s a small change, and a good place to start: let the agent file the issue instead of leaving it buried in the chat. For bigger tasks I use a planner, or a divide-and-conquer approach. It pays off most when pieces can be picked up in parallel and I have agents to spare, either tokens or request limits. A typical plan came out at about 4 epics, depending on what I was working on, with a clear division of work between them. Sequential is the default, but subagents are where it scales. An orchestrating agent can use bd ready to hand independent tasks to subagents, and each one claims its own task with bd update <id> --claim. What went wrong most often was issues that never got closed. The acceptance criteria included committing or asking me for a last check, the agent couldn't complete that, and the issue stayed open. I then had to close it myself or ask the agent to close it again. The dashboard I wanted The command line is useful for agents, but I wanted a faster way to see the whole project myself. So I built a local web dashboard for my Beads issues. It lets me scan the work, see the visual progress of subagents, add comments, and remove issues that no longer matter. The main view is a kanban board with open, in progress and closed columns. There is also a hierarchical view, where I can edit things and watch the agents pick up work live and move it along. I built it with Claude, in a fork of Beads, in one shot. I just told it: "build me a local dashboard so that I can view progress." !My local dashboard showing the Racing event tracker board with open, in progress, blocked and closed columns My dashboard on the Racing event tracker project: everything open, in progress and closed at a glance, updating live as the agents work. It feels a little like project managing a team through a glorified Jira board that I built for myself. The difference is the speed: I can look at the board, spot a blocker or a questionable task, make a change, and send the agents back to work. Is this what project management feels like when the team moves this fast? I couldn't find an existing dashboard at first. After building mine, I found the Beads community tools list and a GitHub discussion about Beads UIs. I was far from the only person who wanted a visual layer. One that looks really good to me is Beads Dashboard. It has an overview of ready, blocked and overdue work, a roadmap, and a drag-and-drop board, which is almost exactly what mine does, but as a ready-to-go VS Code extension. So when do you build a small tool for yourself, and when do you use one that already exists? Rebuilding the same thing in several places can look wasteful from a software engineering perspective. But it took one prompt, and building it taught me more about Beads itself. For a personal tool, that was a fine trade. The human in the loop I used to ask an agent for a status update every time I lost the thread. Now I open the board, see what is in progress and what is stuck, and send the agents back to work. I still explore and change direction as I go, but now I do it with a map made specifically for agents, with me, the human, in the loop. Or really more of an observing human. And the question remains: how much more is there for me to observe in this abstraction layer? This is only the start. Next, I want to explore what else Beads and agents can bring to the way I build.* **Feedback is welcome, and I'd love to hear about your own experience with Beads and agents.* References Beads - Beads on GitHub, the bd issue tracker for coding agents - Beads documentation - Community tools list - GitHub discussion about Beads UIs My projects - My Beads fork with the dashboard - Racing event tracker, the project where I use Beads the most --- Co-written with Claude and Codex. The structure, the opening and the experience behind every story are mine. They helped fill in the gaps, tighten the sentences and check the commands against the docs.

@serious_mehta Have you tried Beads or Claude-Mem? - thedotmack/claude-mem - gastownhall/beads

Beads GitHub Overview: How Dependency-Aware Memory Guides AI Coding Agents beads by gastownhall: gastownhall/beads Beads is a dependency-aware issue tracker designed to give AI coding agents a persistent, structured view of project work. This overview explains why flat tickets and large markdown plans can create context loss, guessed prerequisites, and collisions between agents—and how a directed acyclic task graph makes dependencies explicit. The walkthrough covers the bd prime command's compact project-state summary, semantic memory compaction, and a synthetic authentication API example where database schema work blocks a login endpoint until the prerequisite is complete. It also shows how bd ready exposes actionable tasks, how claim/execute/close keeps concurrent work coordinated, and why Beads uses Dolt for version-controlled SQL storage. Embedded and server topologies, Dolt push/pull synchronization, legacy JSONL exports, plain-text data, and indirect prompt-injection risks round out the practical limitations. TimeStamps: 0:00 Why human-first project plans break for AI agents 1:06 Beads replaces ambiguity with a dependency-aware graph 2:13 bd prime compresses persistent project context 3:28 Authentication API dependency example 4:02 bd ready reveals only unblocked work 4:28 Claim, execute, and close the task 5:17 Why multi-agent workflows need structured storage 5:46 Dolt replaces legacy JSONL as the source of truth 6:40 Dolt push and pull keep planning history separate 7:16 Plain-text storage and prompt-injection boundaries 7:45 Deployment caveat: builds and checksums 🧠 Persistent task context for AI coding agents 🔗 Dependency-aware ordering for autonomous work ⚙️ bd prime, bd ready, and the claim/close loop 🛡️ Dolt storage, synchronization, and security limits Beads is most useful as a machine-oriented coordination layer for projects where agents need durable context and explicit prerequisites. The key tradeoff is equally important: task data and prompt context remain sensitive plain text, so repository access and issue content require careful handling. #Beads #AICodingAgents #Dolt [de-DE] Beads GitHub-Übersicht: Wie abhängigkeitsbewusster Speicher KI-Coding-Agenten steuert Beads von gastownhall: gastownhall/beads Beads ist ein abhängigkeitsbewusstes Issue-Tracking-System, das KI-Programmieragenten eine persistente und strukturierte Übersicht über die Projektarbeit bietet. Diese Übersicht erklärt, warum flache Tickets und umfangreiche Markdown-Pläne zu Kontextverlusten, vermuteten Voraussetzungen und Konflikten zwischen Agenten führen können – und wie ein gerichteter azyklischer Aufgabengraph Abhängigkeiten explizit darstellt. Die Einführung behandelt die kompakte Projektstatuszusammenfassung des Befehls `bd prime`, die semantische Speicherkomprimierung und ein Beispiel einer synthetischen Authentifizierungs-API, bei dem die Arbeit am Datenbankschema einen Anmelde-Endpunkt blockiert, bis die Voraussetzung erfüllt ist. Außerdem wird gezeigt, wie `bd ready` ausführbare Aufgaben bereitstellt, wie `claim/execute/close` die Koordination paralleler Arbeiten sicherstellt und warum Beads Dolt für die versionskontrollierte SQL-Speicherung verwendet. Eingebettete und Server-Topologien, Dolt-Push/Pull-Synchronisierung, Legacy-JSONL-Exporte, Klartextdaten und indirekte Risiken der Eingabeaufforderungsinjektion runden die praktischen Einschränkungen ab. Zeitstempel: 0:00 Warum menschenzentrierte Projektpläne für KI-Agenten nicht funktionieren 1:06 Beads ersetzt Mehrdeutigkeiten durch einen abhängigkeitsbewussten Graphen 2:13 bd prime komprimiert den persistenten Projektkontext 3:28 Beispiel für eine Abhängigkeit der Authentifizierungs-API 4:02 bd ready zeigt nur nicht blockierte Aufgaben an 4:28 Aufgaben übernehmen, ausführen und abschließen 5:17 Warum Multi-Agenten-Workflows strukturierten Speicher benötigen 5:46 Dolt ersetzt das veraltete JSONL als zentrale Datenquelle 6:40 Dolt push und pull trennen die Planungshistorie 7:16 Grenzen der Speicherung von Klartext und der Eingabeaufforderung 7:45 ​​Wichtiger Hinweis zur Bereitstellung: Builds und Prüfsummen 🧠 Persistenter Aufgabenkontext für KI-Codierungsagenten 🔗 Abhängigkeitsbewusste Reihenfolge für autonomes Arbeiten ⚙️ bd prime, bd ready und die Übernahme-/Abschlussschleife 🛡️ Speicher-, Synchronisierungs- und Sicherheitsgrenzen von Dolt Beads ist am besten geeignet Nützlich als maschinenorientierte Koordinierungsschicht für Projekte, in denen Agenten dauerhaften Kontext und explizite Voraussetzungen benötigen. Der entscheidende Kompromiss ist ebenso wichtig: Aufgabendaten und Kontextinformationen bleiben sensibler Klartext, daher erfordern der Zugriff auf das Repository und die Inhalte von Aufgaben besondere Sorgfalt. #Beads #AICodingAgents #Dolt [es-US] Descripción general de Beads en GitHub: Cómo la memoria con reconocimiento de dependencias guía a... Beads de gastownhall: gastownhall/beads Beads es un sistema de seguimiento de incidencias con gestión de dependencias diseñado para proporcionar a los agentes de codificación de IA una visión persistente y estructurada del trabajo del proyecto. Esta descripción general explica por qué los tickets planos y los planes de Markdown extensos pueden generar pérdida de contexto, prerrequisitos inferidos y colisiones entre agentes, y cómo un grafo de tareas acíclico dirigido explicita las dependencias. El tutorial abarca el resumen compacto del estado del proyecto del comando `bd prime`, la compactación de la memoria semántica y un ejemplo de API de autenticación sintética donde el trabajo con el esquema de la base de datos bloquea un endpoint de inicio de sesión hasta que se completa el prerrequisito. También muestra cómo `bd ready` expone las tareas ejecutables, cómo `claim/execute/close` mantiene el trabajo concurrente coordinado y por qué Beads utiliza Dolt para el almacenamiento SQL con control de versiones. Las topologías integradas y de servidor, la sincronización push/pull de Dolt, las exportaciones JSONL heredadas, los datos en texto plano y los riesgos de inyección indirecta de prompts completan las limitaciones prácticas. Marcas de tiempo: 0:00 Por qué los planes de proyecto diseñados para humanos fallan para los agentes de IA 1:06 Beads reemplaza la ambigüedad con un gráfico que considera las dependencias 2:13 bd prime comprime el contexto persistente del proyecto 3:28 Ejemplo de dependencia de la API de autenticación 4:02 bd ready muestra solo el trabajo desbloqueado 4:28 Reclamar, ejecutar y cerrar la tarea 5:17 Por qué los flujos de trabajo multiagente necesitan almacenamiento estructurado 5:46 Dolt reemplaza el JSONL heredado como fuente de información 6:40 Dolt push y pull mantienen el historial de planificación separado 7:16 Almacenamiento de texto plano y límites de inyección de mensajes 7:45 ​​Advertencia sobre la implementación: compilaciones y sumas de verificación 🧠 Contexto de tarea persistente para agentes de codificación de IA 🔗 Ordenamiento que considera las dependencias para el trabajo autónomo ⚙️ bd prime, bd ready y el ciclo de reclamación/cierre 🛡️ Almacenamiento, sincronización y seguridad de Dolt Limitaciones Beads resulta especialmente útil como capa de coordinación orientada a máquinas para proyectos donde los agentes necesitan un contexto duradero y prerrequisitos explícitos. La contrapartida clave es igualmente importante: los datos de las tareas y el contexto de las indicaciones permanecen como texto plano sensible, por lo que el acceso al repositorio y el contenido de los problemas requieren un manejo cuidadoso. #Beads #AICodingAgents #Dolt [fr-FR] Présentation de Beads sur GitHub : comment la mémoire axée sur les dépendances guide les agents d... Beads par gastownhall : gastownhall/beads Beads est un outil de suivi des problèmes prenant en compte les dépendances. Il offre aux agents de programmation IA une vue structurée et persistante du travail sur le projet. Cet aperçu explique pourquoi les tickets plats et les plans Markdown volumineux peuvent entraîner une perte de contexte, des prérequis devinés et des conflits entre agents, et comment un graphe de tâches acyclique et orienté rend les dépendances explicites. La démonstration couvre le résumé compact de l'état du projet offert par la commande `bd prime`, la compaction sémantique de la mémoire et un exemple d'API d'authentification synthétique où la modification du schéma de base de données bloque un point de terminaison de connexion jusqu'à ce que le prérequis soit satisfait. Elle montre également comment `bd ready` expose les tâches exécutables, comment les actions `claim`, `execute` et `close` coordonnent le travail concurrent et pourquoi Beads utilise Dolt pour le stockage SQL versionné. Les topologies embarquées et serveur, la synchronisation push/pull Dolt, les exportations JSONL héritées, les données en texte brut et les risques d'injection indirecte d'invites complètent les limitations pratiques. Horodatage : 0:00 Pourquoi les plans de projet conçus pour les humains ne sont pas adaptés aux agents d'IA 1:06 Beads remplace l'ambiguïté par un graphe prenant en compte les dépendances 2:13 bd prime compresse le contexte de projet persistant 3:28 Exemple de dépendance d'API d'authentification 4:02 bd ready n'affiche que le travail non bloqué 4:28 Réclamer, exécuter et fermer la tâche 5:17 Pourquoi les workflows multi-agents nécessitent un stockage structuré 5:46 Dolt remplace le JSONL traditionnel comme source de vérité 6:40 Les fonctions push et pull de Dolt préservent l'historique de planification 7:16 Stockage en texte brut et limites d'injection d'invites 7:45 ​​Mise en garde concernant le déploiement : builds et sommes de contrôle 🧠 Contexte de tâche persistant pour les agents de programmation d'IA 🔗 Ordre prenant en compte les dépendances pour le travail autonome ⚙️ bd prime, bd ready et la boucle de réclamation/fermeture 🛡️ Stockage, synchronisation et limites de sécurité de Dolt Beads est particulièrement utile En tant que couche de coordination orientée machine pour les projets où les agents nécessitent un contexte durable et des prérequis explicites, le compromis essentiel est tout aussi important : les données de tâche et le contexte des invites restent sensibles et accessibles en clair. L’accès au référentiel et le contenu des tickets requièrent donc une gestion rigoureuse. #Beads #AICodingAgents #Dolt [hi] Beads GitHub ओवरव्यू: डिपेंडेंसी-अवेयर मेमोरी AI कोडिंग एजेंट्स का मार्गदर्शन कैसे करती है बीड्स (Beads) - गैस्टाउनहॉल द्वारा: gastownhall/beads बीड्स एक निर्भरता-जागरूक इश्यू ट्रैकर है जिसे एआई कोडिंग एजेंटों को प्रोजेक्ट कार्य का एक स्थायी, संरचित दृश्य प्रदान करने के लिए डिज़ाइन किया गया है। यह अवलोकन बताता है कि कैसे फ्लैट टिकट और बड़े मार्कडाउन प्लान संदर्भ हानि, अनुमानित पूर्वापेक्षाएँ और एजेंटों के बीच टकराव पैदा कर सकते हैं - और कैसे एक निर्देशित चक्रीय कार्य ग्राफ निर्भरताओं को स्पष्ट करता है। इस वॉकथ्रू में बीडी प्राइम कमांड के संक्षिप्त प्रोजेक्ट-स्टेट सारांश, सिमेंटिक मेमोरी कॉम्पैक्शन और एक सिंथेटिक प्रमाणीकरण एपीआई उदाहरण शामिल है, जहां डेटाबेस स्कीमा कार्य पूर्वापेक्षा पूरी होने तक लॉगिन एंडपॉइंट को ब्लॉक कर देता है। यह यह भी दिखाता है कि बीडी रेडी कैसे कार्रवाई योग्य कार्यों को उजागर करता है, क्लेम/एक्जीक्यूट/क्लोज कैसे समवर्ती कार्य को समन्वित रखता है, और बीड्स संस्करण-नियंत्रित SQL स्टोरेज के लिए डॉल्ट का उपयोग क्यों करता है। एम्बेडेड और सर्वर टोपोलॉजी, डॉल्ट पुश/पुल सिंक्रोनाइज़ेशन, लेगेसी JSONL निर्यात, प्लेन-टेक्स्ट डेटा और अप्रत्यक्ष प्रॉम्प्ट-इंजेक्शन जोखिम व्यावहारिक सीमाओं को पूरा करते हैं। टाइमस्टैम्प: 0:00 मानव-केंद्रित परियोजना योजनाएँ AI एजेंटों के लिए क्यों विफल हो जाती हैं 1:06 बीड्स निर्भरता-जागरूक ग्राफ़ के साथ अस्पष्टता को प्रतिस्थापित करता है 2:13 बीडी प्राइम स्थायी परियोजना संदर्भ को संपीड़ित करता है 3:28 प्रमाणीकरण API निर्भरता का उदाहरण 4:02 बीडी रेडी केवल अनब्लॉक किए गए कार्य को प्रदर्शित करता है 4:28 कार्य का दावा करें, निष्पादित करें और बंद करें 5:17 बहु-एजेंट वर्कफ़्लो को संरचित संग्रहण की आवश्यकता क्यों होती है 5:46 डॉल्ट सत्य के स्रोत के रूप में पुराने JSONL को प्रतिस्थापित करता है 6:40 डॉल्ट पुश और पुल योजना इतिहास को अलग रखते हैं 7:16 सादा पाठ संग्रहण और प्रॉम्प्ट-इंजेक्शन सीमाएँ 7:45 ​​परिनियोजन चेतावनी: बिल्ड और चेकसम 🧠 AI कोडिंग एजेंटों के लिए स्थायी कार्य संदर्भ 🔗 स्वायत्त कार्य के लिए निर्भरता-जागरूक क्रम ⚙️ बीडी प्राइम, बीडी रेडी और दावा/बंद लूप 🛡️ डॉल्ट संग्रहण, सिंक्रोनाइज़ेशन और सुरक्षा सीमाएँ Beads उन परियोजनाओं के लिए मशीन-उन्मुख समन्वय परत के रूप में सबसे उपयोगी है जहाँ एजेंटों को टिकाऊ संदर्भ और स्पष्ट पूर्वापेक्षाओं की आवश्यकता होती है। महत्वपूर्ण समझौता भी उतना ही महत्वपूर्ण है: कार्य डेटा और प्रॉम्प्ट संदर्भ संवेदनशील सादे पाठ के रूप में रहते हैं, इसलिए रिपॉजिटरी एक्सेस और इश्यू सामग्री को सावधानीपूर्वक संभालना आवश्यक है। #Beads #AICodingAgents #Dolt [id] Ikhtisar GitHub Beads: Bagaimana Memori Sadar Dependensi Memandu Agen Koding AI Beads oleh gastownhall: gastownhall/beads Beads adalah pelacak masalah yang sadar akan ketergantungan, dirancang untuk memberikan agen pengkodean AI tampilan pekerjaan proyek yang terstruktur dan berkelanjutan. Gambaran umum ini menjelaskan mengapa tiket datar dan rencana markdown besar dapat menyebabkan hilangnya konteks, prasyarat yang ditebak, dan benturan antar agen—dan bagaimana grafik tugas asiklik terarah membuat ketergantungan menjadi eksplisit. Panduan ini mencakup ringkasan status proyek yang ringkas dari perintah bd prime, pemadatan memori semantik, dan contoh API otentikasi sintetis di mana pekerjaan skema basis data memblokir titik akhir login hingga prasyarat selesai. Ini juga menunjukkan bagaimana bd ready mengekspos tugas yang dapat ditindaklanjuti, bagaimana claim/execute/close menjaga koordinasi pekerjaan bersamaan, dan mengapa Beads menggunakan Dolt untuk penyimpanan SQL yang dikontrol versi. Topologi tertanam dan server, sinkronisasi push/pull Dolt, ekspor JSONL lama, data teks biasa, dan risiko injeksi prompt tidak langsung melengkapi keterbatasan praktisnya. Cap Waktu: 0:00 Mengapa rencana proyek yang mengutamakan manusia gagal untuk agen AI 1:06 Beads menggantikan ambiguitas dengan grafik yang sadar akan ketergantungan 2:13 bd prime mengkompresi konteks proyek persisten 3:28 Contoh ketergantungan API otentikasi 4:02 bd ready hanya menampilkan pekerjaan yang tidak terblokir 4:28 Klaim, eksekusi, dan tutup tugas 5:17 Mengapa alur kerja multi-agen membutuhkan penyimpanan terstruktur 5:46 Dolt menggantikan JSONL lama sebagai sumber kebenaran 6:40 Dorong dan tarik Dolt menjaga riwayat perencanaan tetap terpisah 7:16 Penyimpanan teks biasa dan batasan injeksi prompt 7:45 ​​Peringatan penyebaran: build dan checksum 🧠 Konteks tugas persisten untuk agen pengkodean AI 🔗 Pengurutan yang sadar akan ketergantungan untuk pekerjaan otonom ⚙️ bd prime, bd ready, dan loop klaim/tutup 🛡️ Batasan penyimpanan, sinkronisasi, dan keamanan Dolt Beads adalah yang paling Berguna sebagai lapisan koordinasi berorientasi mesin untuk proyek-proyek di mana agen membutuhkan konteks yang tahan lama dan prasyarat yang eksplisit. Namun, pertimbangan utamanya sama pentingnya: data tugas dan konteks perintah tetap berupa teks biasa yang sensitif, sehingga akses ke repositori dan konten masalah memerlukan penanganan yang hati-hati. #Beads #AICodingAgents #Dolt [it] Panoramica di Beads su GitHub: come la memoria basata sulle dipendenze guida gli agenti di progra... Beads di gastownhall: gastownhall/beads Beads è un sistema di tracciamento dei problemi basato sulle dipendenze, progettato per fornire agli agenti di programmazione IA una visione persistente e strutturata del lavoro di progetto. Questa panoramica spiega perché i ticket semplici e i piani di lavoro in formato Markdown di grandi dimensioni possono causare perdita di contesto, prerequisiti intuiti e conflitti tra gli agenti, e come un grafo di attività aciclico diretto renda esplicite le dipendenze. La procedura illustra il riepilogo compatto dello stato del progetto tramite il comando `bd prime`, la compattazione semantica della memoria e un esempio di API di autenticazione sintetica in cui l'elaborazione dello schema del database blocca un endpoint di login fino al completamento del prerequisito. Mostra inoltre come `bd ready` esponga attività eseguibili, come il ciclo `claim/execute/close` mantenga coordinato il lavoro concorrente e perché Beads utilizzi Dolt per l'archiviazione SQL con controllo di versione. Topologie embedded e server, sincronizzazione push/pull di Dolt, esportazioni JSONL legacy, dati in testo semplice e rischi indiretti di iniezione di prompt completano le limitazioni pratiche. Indice dei contenuti: 0:00 Perché i piani di progetto incentrati sull'uomo non funzionano con gli agenti IA 1:06 Beads sostituisce l'ambiguità con un grafo consapevole delle dipendenze 2:13 bd prime comprime il contesto di progetto persistente 3:28 Esempio di dipendenza dell'API di autenticazione 4:02 bd ready mostra solo il lavoro non bloccato 4:28 Richiedi, esegui e chiudi l'attività 5:17 Perché i flussi di lavoro multi-agente necessitano di un'archiviazione strutturata 5:46 Dolt sostituisce il vecchio JSONL come fonte di verità 6:40 Dolt push e pull mantengono separata la cronologia di pianificazione 7:16 Archiviazione in testo semplice e limiti di iniezione di prompt 7:45 ​​Avvertenza sulla distribuzione: build e checksum 🧠 Contesto di attività persistente per agenti di programmazione IA 🔗 Ordinamento consapevole delle dipendenze per il lavoro autonomo ⚙️ bd prime, bd ready e il ciclo di richiesta/chiusura 🛡️ Archiviazione, sincronizzazione e limiti di sicurezza di Dolt Beads È particolarmente utile come livello di coordinamento orientato all'apprendimento automatico per progetti in cui gli agenti necessitano di un contesto duraturo e di prerequisiti espliciti. Il compromesso fondamentale è altrettanto importante: i dati delle attività e il contesto dei prompt rimangono testo semplice e sensibile, pertanto l'accesso al repository e il contenuto dei problemi richiedono un'attenta gestione. #Beads #AICodingAgents #Dolt [pt-BR] Visão geral do Beads no GitHub: Como a memória com reconhecimento de dependências guia agentes de... Beads por gastownhall: gastownhall/beads Beads é um rastreador de problemas com reconhecimento de dependências, projetado para fornecer aos agentes de codificação de IA uma visão persistente e estruturada do trabalho do projeto. Esta visão geral explica por que tickets simples e planos Markdown extensos podem gerar perda de contexto, pré-requisitos inferidos e conflitos entre agentes — e como um grafo de tarefas acíclico direcionado torna as dependências explícitas. O passo a passo aborda o resumo compacto do estado do projeto do comando `bd prime`, a compactação semântica de memória e um exemplo de API de autenticação sintética onde o trabalho no esquema do banco de dados bloqueia um endpoint de login até que o pré-requisito seja concluído. Também mostra como `bd ready` expõe tarefas acionáveis, como `claim/execute/close` mantém o trabalho simultâneo coordenado e por que o Beads usa o Dolt para armazenamento SQL com controle de versão. Topologias incorporadas e de servidor, sincronização push/pull do Dolt, exportações JSONL legadas, dados em texto simples e riscos de injeção indireta de prompts completam as limitações práticas. Marcadores de tempo: 0:00 Por que os planos de projeto com foco no humano falham para agentes de IA 1:06 Beads substitui a ambiguidade por um grafo com reconhecimento de dependências 2:13 bd prime comprime o contexto persistente do projeto 3:28 Exemplo de dependência da API de autenticação 4:02 bd ready revela apenas o trabalho desbloqueado 4:28 Reivindicar, executar e fechar a tarefa 5:17 Por que os fluxos de trabalho multiagentes precisam de armazenamento estruturado 5:46 Dolt substitui o JSONL legado como fonte da verdade 6:40 Dolt push e pull mantêm o histórico de planejamento separado 7:16 Armazenamento em texto simples e limites de injeção de prompts 7:45 ​​Atenção à implantação: builds e checksums 🧠 Contexto de tarefa persistente para agentes de codificação de IA 🔗 Ordenação com reconhecimento de dependências para trabalho autônomo ⚙️ bd prime, bd ready e o loop de reivindicação/fechamento 🛡️ Armazenamento, sincronização e segurança do Dolt Limitações O Beads é mais útil como uma camada de coordenação orientada a máquinas para projetos em que os agentes precisam de contexto duradouro e pré-requisitos explícitos. A principal contrapartida é igualmente importante: os dados da tarefa e o contexto do prompt permanecem em texto simples sensível, portanto, o acesso ao repositório e o conteúdo da issue exigem tratamento cuidadoso. #Beads #AICodingAgents #Dolt

@PerroDinero Nice! Pronto publico más sobre los detalles acá. Me ha ido bien usando Beads como el sistema de memoria, relacionamiento de tareas, base de conocimiento e historial de agentes: gastownhall/beads

My AI agents were choking on their own markdown logs. I gave them a database. I am an AppSec engineer. For the past year I have been running AI agents as part of my security work: recon, attack surface mapping, hypothesis testing. It worked well until it did not. The problem Agents produce logs at every step: what they found, what they tried, what failed. All of that was landing in markdown files. After a few weeks on one project the folder looked like this: recon.md subdomains-live.md endpoints.md attempts-auth.md notes-session.md TODO.md TODO-v2.md progress-subagent-3.md I was using a model with a 256k token context window. That sounds like a lot. But at some point the accumulated logs for a single project stopped fitting in the window at all. The agent had to read the entire archive just to remember where it left off, and there was no room left to do actual work. It would hit the limit and restart, losing intermediate results and repeating attempts that had already failed. Specific symptoms: - Compaction erased progress. After context compression the agent would re-read progress.md, see "invoices module - almost done" and start over. What "almost" meant was anyone's guess. - Failed attempts repeated. Some hypotheses the agent tried three times, each time as if it were the first. - Subagents did not know about the lead agent's decisions. Scope constraints lived in the main agent's context. The subagent had no idea. - "What is left?" had no quick answer. You had to read every file and reconstruct the picture yourself. A markdown file is good as a document for a human to read. As a state store for a running agent it is not: no structure, no statuses that mean the same thing consistently, and you cannot query it. What was actually needed I wrote down the requirements: 1. Restore full context with the minimum number of tokens - at the start of a new session or when spawning a subagent. 2. "What is left?" must be one query, not a history read. 3. A failed attempt gets recorded and found before the agent repeats it. 4. A decision made at the top of the hierarchy reaches every subagent below without retelling the whole conversation. 5. Finished work collapses into a summary - the next session reads that, not a hundred notes. 6. Everything local, no external services. Project data stays on the machine. I did not find a tool that fit. So I built one: PentaCore, an MCP server in Rust. One binary, one encrypted SQLite file. It does not plan anything or decide what to do next. It stores what it is given and returns what is asked for. How it works PentaCore has two stores. Notes are the narrative: goals, steps, attempts and their outcomes, facts, decisions, questions, lessons. Notes form a tree through parent and a graph through typed links. Search works by exact words and, optionally, by meaning: the first recall downloads a small embedding model (all-MiniLM-L6-v2, English only, about 90 MB). Without it, search by words still works. Entities are many things of one kind: hosts, endpoints, files, whatever. Each entity has a status, attributes, and named checks. The split matters. "Show everything that has not passed check X yet" is a field filter. Its result should not depend on how the agent phrased a note. The pyramid: goals, steps, checklists Top level is the goal, steps under it, each step has a checklist: {"name": "note", "arguments": {"kind": "goal", "title": "Audit api.example.com"}} {"name": "note", "arguments": {"kind": "step", "title": "Module: invoices", "parent": 1}} {"name": "checklist", "arguments": {"note": 2, "add": [ "BOLA on read", "BOLA on update", "Mass assignment", "Role bypass" ]}} Each endpoint is an entity: {"name": "upsert_entity", "arguments": { "type": "endpoint", "key": "GET /v2/invoices/{id}", "status": "discovered", "attrs": {"module": "invoices", "auth": "user"} }} Checks are marked as they are done: {"name": "mark_check", "arguments": {"id": 41, "checks": [ {"name": "bola_read", "result": "fail", "detail": "user B reads invoices of user A"}, {"name": "role_bypass", "result": "pass"} ]}} Now "what has not been checked yet" is one call: {"name": "query_entities", "arguments": { "type": "endpoint", "where": [{"field": "check.bola_read", "op": "is_null"}] }} And the overall picture is another: {"name": "query_entities", "arguments": {"type": "endpoint", "group_by": "check.bola_read"}} Restoring context after compaction At the start of a new session, one call: {"name": "resume", "arguments": {"task": 1}} The agent gets what it needs to continue that task, not the whole archive. For a subtask this includes the notes handed down to it from above. The reply fits within a size budget (budget_chars), and budget.omitted says how much did not fit, so truncation is never silent. Subagents get only the context they need The lead agent creates a step for the subagent and links relevant decisions via uses: {"name": "note", "arguments": {"kind": "decision", "title": "/internal/* is out of scope"}} {"name": "link", "arguments": {"src": 1, "dst": 3, "kind": "uses"}} {"name": "note", "arguments": { "kind": "step", "title": "Zone: b.example.com", "parent": 1, "body": "Check TLS and auth on b.example.com." }} Here the decision is note 3 and the new step is note 4. A note that a task uses is context for that task and for every task beneath it, so a decision linked from the goal reaches subagents at any depth. The subagent is given only the step id. It calls resume task=4 and gets its assignment and the shared decision, plus any findings you linked to the step with uses. No need to retell the lead agent's whole conversation. Summaries instead of accumulated history When a step is done: {"name": "summarize", "arguments": { "task": 2, "work": "48 endpoints checked: BOLA, mass assignment, role bypass.", "result": "BOLA on GET /v2/invoices/{id}: user B reads invoices of user A. Mass assignment on PATCH via status field." }} task_summary returns the whole task as its summaries in tree order - one call, however many notes sit below. Any agent at any level of the hierarchy can get a focused summary of one area of the whole perimeter. Security Memory is a prompt injection channel. Everything written to it is later read as context. An unauthorized write becomes an injected instruction. What follows from that: - stdio only by default. The server can only be called by the process that launched it. - HTTP cannot be accidentally exposed. Loopback only, refuses to start without a token of at least 32 characters, requires an exact Host header to block DNS rebinding, rejects any request with an Origin header. - Input validated at the boundary. Every argument is parsed into a type with length and character set constraints. Unknown fields are rejected. - User text never becomes SQL. Bound parameters only. FTS5 operators are escaped. Entity queries are assembled from an allowlist of fields and operators. - Data at rest is encrypted. SQLCipher, secure_delete, WAL cleared after purge. Honest about limits: the SQLCipher key is compiled into the binary. It protects the file from someone who only has the file. It does not protect against someone who has the binary or the source. All known limits are listed in the README. When PentaCore is not the right tool - Task tracker with dependencies for software development: Beads or built-in Tasks in Claude Code. - One short task in a single session: the model context is enough. - Long-term memory about a user or their preferences: different problem, different tools. PentaCore is for when an agent works through a large number of similar targets over multiple sessions, survives compaction, and needs an exact answer to "what is done, what was found, what is left." Try it Binaries for Linux, macOS, and Windows are in Releases. SHA256SUMS, SBOM, and a build provenance attestation are included. Claude Code: claude mcp add pentacore -- /path/to/pentacore Any other MCP client: { "mcpServers": { "pentacore": { "command": "/path/to/pentacore", "env": { "PENTACORE_PROJECT": "my-project" } } } } The repo also has a Dockerfile and docker-compose.yml: read-only root filesystem, all capabilities dropped, unprivileged user. You build the image yourself; there is no published image yet. Repo: **DroBov1Tya/PentaCore** If you find a vulnerability, use Security -> Report a vulnerability in the repo rather than opening a public issue.

Beads: A memory upgrade for your coding agent (28k stars) What it does All text below is quoted directly from the project README. >Distributed graph issue tracker for AI agents, powered by Dolt. Features: - Dolt-Powered: Version-controlled SQL database with cell-level merge, native branching, and built-in sync via Dolt remotes. - Agent-Optimized: JSON output, dependency tracking, and auto-ready task detection. - Zero Conflict: Hash-based IDs (bd-a1b2) prevent merge collisions in multi-agent/multi-branch workflows. - Compaction: Semantic "memory decay" summarizes old closed tasks to save context window. - Messaging: Message issue type with threading (--thread), ephemeral lifecycle, and mail delegation. - Graph Links: relates-to, duplicates, supersedes, and replies-to for knowledge graphs. >Beads provides a persistent, structured memory for coding agents. It replaces messy markdown plans with a dependency-aware graph, allowing agents to handle long-horizon tasks without losing context. Repository gastownhall/beads Repository stats |Metric|Value| |:-|:-| |Stars|27,925| |Forks|1,892| |Last release|v1.3.1 (2026-09-30)| |Languages|Go 95%, Python 1.7%, Starlark 1.6%| |Contributors|486| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|Copilot: 60, cursoragent: 27, claude: 3306| |AI co-authored commits|Claude: 3978, Codex: 1, Cursor: 28, Copilot: 63| Main contributor |Field|Value| |:-|:-| |Name|Steve Yegge| |GitHub|@steveyegge| |Commits to this repo|4,808 (top contributor)| |Company / Location|Kirkland, WA| |Followers|3835| |Public repos|7| |On GitHub since|2011-02-12| ------------------------------------------------------------------------------------------------- Discover the best GitHub repos without the endless scrolling. Get top repos organized by category (AI, DevOps, Databases & more), plus key takeaways from developers' most useful comments - all in one free, twice-weekly newsletter. 👉 Get the best repos & community insights - Free

Claude Code doesn't need a longer context. It needs a memory. Every Claude Code session is somebody's first day. Yesterday it found the cause of a bug and ruled out two wrong theories on the way. This morning, it remembers none of it. That isn't the model's fault. A session ends, and everything it learned ends with it. A bigger context window only delays the forgetting. Two things get lost: - The work. What's done, what's open, what's waiting on what. - The knowledge. Findings that took real effort to get. A markdown TODO list doesn't fix it. It rots in a day, because nothing keeps it honest. The fix: give it a memory I use beads (bd). It keeps two things in a small local database inside your project: - A task tracker, with dependencies, so bd ready only shows work that isn't blocked. - A memory store, for facts every future session should know. The part that matters: it loads into every new session automatically, before you type a word. Why not just CLAUDE.md? CLAUDE.md is the rulebook. beads is the logbook. Rules barely change. Where the work stands changes every day. Write "Dark mode: waiting on the new colour palette" in CLAUDE.md, and when the palette arrives nobody edits the line. Every new session still thinks dark mode is blocked. In beads, dark mode depends on the palette task. Close one, and the other shows up as ready by itself. Use both. CLAUDE.md says how to work. beads says where things stand. Set it up brew install beads # or: npm install -g @beads/bd cd your-project && bd init # also connects Claude Code for you bd setup claude --check # two green ticks = done Then save one real finding, with the date and how you know it: bd remember "The signup form saves phone numbers without the country code. Found 2026-10-15 by checking real signups." The test: close Claude Code, open a fresh session in the same folder, and ask "What's open, and what do you already know about this project?" If it answers without your help, it works. This is part 2 of Claude Maxxing, a field journal of the systems I build around Claude Code on real work. The full post covers what's worth remembering (and what isn't), the gotchas that bit me, and what memory still doesn't fix: 👉 Read the full post on hatimpatwa.dev