wal.sh
home > research > multi-agent-workflow-frameworks · Dec 21, 2025

Multi-Agent Workflow Frameworks for AI-Assisted Software Development

multi-agent systemssoftware engineeringAI assistantsworkflow coordinationLLM agents

Multi-Agent Workflow Frameworks for AI-Assisted Software Development
A Comparative Analysis of Synchronous and Asynchronous Coordination Patterns

Table of Contents

1. Abstract

This paper presents a comparative analysis of two distinct approaches to multi-agent workflow management: the CONTINUE framework, which emphasizes real-time synchronous coordination through inter-process communication primitives, and the Beads issue tracking system, which provides asynchronous coordination through persistent state and label-based filtering. We examine the architectural differences, operational characteristics, and integration patterns of each approach, proposing a hybrid model that leverages the strengths of both paradigms. Our analysis suggests that effective multi-agent AI development environments require both real-time coordination for concurrent session work and persistent state management for cross-session continuity.

2. Introduction

2.1. Motivation

However, as projects scale in complexity, single-agent interactions prove insufficient for managing the cognitive and organizational demands of modern software engineering.

Multi-agent architectures offer a promising solution by distributing responsibilities across specialized agents with distinct roles, constraints, and communication patterns. This specialization mirrors human team structures where architects, implementers, reviewers, and project managers collaborate through defined interfaces.

2.2. Research Questions

This research addresses three primary questions:

  1. RQ1: What are the fundamental architectural differences between synchronous and asynchronous multi-agent coordination frameworks?
  2. RQ2: How do these architectural choices affect agent behavior, communication patterns, and development workflow outcomes?
  3. RQ3: Can a hybrid approach combining both paradigms provide superior workflow management for AI-assisted development?

2.3. Contributions

This paper makes the following contributions:

  • A formal characterization of the CONTINUE synchronous coordination framework
  • An analysis of the Beads asynchronous issue tracking system for multi-persona workflows
  • A proposed integration pattern combining real-time and persistent coordination
  • Practical implementation guidance for production multi-agent development environments

3. Background and Related Work

3.1. Multi-Agent Systems in Software Engineering

corrected · pilot-annotation-pass · 2026-10-08

Multi-agent systems (MAS) have been studied extensively in distributed artificial intelligence literature [Wooldridge, 2009].

Recent work on LLM-based agents [Wang et al., 2024] catalogs systems such as MetaGPT and ChatDev that assign specialized roles to collaborating agents, though the survey documents application outcomes rather than controlled comparisons against monolithic agents.

3.2. Coordination Paradigms

Agent coordination mechanisms can be broadly classified into two categories:

3.2.1. Synchronous Coordination

Synchronous coordination involves real-time message passing between concurrently executing agents. This approach is characterized by:

  • Low-latency communication channels
  • Immediate feedback and response cycles
  • Tight coupling between agent activities
  • Shared temporal context

Examples include blackboard architectures, tuple spaces, and named pipe (FIFO) communication.

3.2.2. Asynchronous Coordination

Asynchronous coordination decouples agent execution through persistent shared state. Key characteristics include:

  • Durable message storage
  • Eventual consistency models
  • Loose coupling between agent activities
  • Cross-session state preservation

Examples include issue trackers, message queues, and distributed databases.

3.3. Persona-Based Agent Design

The concept of agent personas derives from human-computer interaction research on user modeling [Pruitt & Adlin, 2006]. Applied to LLM agents, personas provide:

  • Behavioral constraints that focus agent activities
  • Communication style specifications
  • Domain expertise boundaries
  • Interaction pattern definitions

4. The CONTINUE Framework

4.1. Overview

CONTINUE (CONcurrent Task INterface for Unified Execution) is a synchronous multi-agent coordination framework designed for real-time collaboration during active development sessions. The framework implements a role-based architecture where specialized agents communicate through Unix named pipes (FIFOs) and IRC-style messaging.

4.2. Agent Roles

4.2.1. Builder Agent

The Builder agent serves as the primary implementation specialist with the following characteristics: 

Role:        Implementation Specialist
Color Code:  Green (ANSI: \033[32m)
Permissions: Full read/write access to codebase
Focus:       Writing code, fixing bugs, implementing features
Mindset:     Solution-oriented, practical, iterative

Core responsibilities:

  1. Feature implementation
  2. Bug fixes
  3. Test development
  4. Documentation updates

Operational constraints:

  • Must announce significant actions via IRC
  • Prohibited from using git add -A or similar bulk operations
  • Required to use conventional commit format

4.2.2. Observer Agent

The Observer agent provides analytical capabilities while maintaining strict read-only constraints: 

Role:        Analysis Specialist
Color Code:  Blue (ANSI: \033[34m)
Permissions: Read-only for source code; write to .claude/observations/
Focus:       Pattern recognition, documentation, architectural analysis
Mindset:     Analytical, reflective, systematic

Core responsibilities:

  1. Codebase analysis
  2. Pattern identification
  3. Technical debt cataloging
  4. Architecture documentation

Operational constraints:

  • Cannot modify source code files
  • Limited write access to observation directories
  • Must maintain objectivity in analysis

4.2.3. Meta-Observer Agent

The Meta-Observer provides system-level monitoring: 

Role:        System Monitor
Color Code:  Purple (ANSI: \033[35m)
Permissions: Read-only across all systems
Focus:       Communication patterns, system health, anomaly detection
Mindset:     Systematic, pattern-focused, documentation-oriented

Core responsibilities:

  1. Inter-agent communication monitoring
  2. Daily assessment report generation
  3. Role boundary violation detection
  4. System health tracking

4.3. Communication Architecture

4.3.1. FIFO-Based Messaging

CONTINUE uses Unix named pipes for inter-agent communication: 

# Project-scoped FIFO definitions
PROJECT_NAME=$(basename $(pwd))
OBSERVER_TO_BUILDER_FIFO="/tmp/${PROJECT_NAME}-observer-to-builder.fifo"
BUILDER_TO_OBSERVER_FIFO="/tmp/${PROJECT_NAME}-builder-to-observer.fifo"
SYSTEM_STATUS_FIFO="/tmp/${PROJECT_NAME}-system-status.fifo"

This design provides:

  • Process isolation between agents
  • Blocking read semantics for synchronization
  • Automatic cleanup on process termination
  • Namespace isolation per project

4.3.2. IRC Integration

Real-time announcements use IRC-style messaging through tmux sessions: 

# Announcement format
:[agent:project:branch] message

# Examples
:[builder:myproject:main] feat: implemented user authentication
:[observer:myproject:main] Detected circular dependency in services
:[meta-observer:myproject:main] Session complete, all changes pushed

4.4. Session Lifecycle

A typical CONTINUE session follows this lifecycle: 

┌─────────────────────────────────────────────────────────────┐
│                    Session Lifecycle                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. Dashboard Initialization                                 │
│     └─ Create FIFOs, announce readiness                     │
│                                                              │
│  2. Agent Startup                                            │
│     ├─ Builder: Check messages, git status, run tests       │
│     ├─ Observer: Analyze repository, review activity        │
│     └─ Meta-Observer: Begin communication monitoring        │
│                                                              │
│  3. Active Development                                       │
│     ├─ Builder: Implement features, fix bugs                │
│     ├─ Observer: Document patterns, identify issues         │
│     └─ Meta-Observer: Track coordination effectiveness      │
│                                                              │
│  4. Session Handoff ("Landing the Plane")                   │
│     ├─ Drain FIFO messages                                  │
│     ├─ Create issues for discovered work                    │
│     ├─ Sync and push all changes                            │
│     └─ Generate session summary                             │
│                                                              │
└─────────────────────────────────────────────────────────────┘

5. The Beads Framework

5.1. Overview

Beads (bd) is an asynchronous issue tracking system designed for persistent workflow management across development sessions. Unlike CONTINUE's real-time focus, Beads emphasizes durable state and label-based filtering for organizing work by persona.

5.2. Architecture

corrected · pilot-annotation-pass · 2026-10-08

Beads implements a hybrid storage model: 

┌─────────────────────────────────────────────────────────────┐
│                    Beads Architecture                        │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐  │
│  │   CLI (bd)   │───▶│   Dolt       │───▶│    JSONL     │  │
│  │              │    │   Database   │    │   Export     │  │
│  └──────────────┘    └──────────────┘    └──────────────┘  │
│         │                   │                    │          │
│         │                   │                    │          │
│         ▼                   ▼                    ▼          │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                    Git Integration                    │  │
│  │  - Pre-commit hooks for issue sync                   │  │
│  │  - Merge driver for JSONL conflicts                  │  │
│  │  - Automatic sync on pull/push                       │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

5.3. Persona-Based Workflow

Beads uses labels to implement persona-based filtering:

5.3.1. Architect Persona

# View architecture work
bd list --label architecture --status open

# Create architectural decision record
bd create "Design: New caching layer" -t epic -p 1
bd label add bd-abc123 architecture

# View high-priority decisions
bd list --label architecture --priority 0
bd list --label architecture --priority 1

5.3.2. Implementer Persona

# View implementation tasks
bd list --label implementation --status open

# Claim and start work
bd update bd-xyz789 --status in_progress

# Discover and track issues during implementation
bd create "Connection pool exhaustion under load" -t bug -p 1
bd label add bd-def456 implementation bug

5.3.3. Reviewer Persona

# View pending reviews
bd list --label review --status open

# Create review blockers
bd create "Add unit tests for retry logic" -t task -p 1
bd label add bd-test1 implementation testing
bd dep add bd-review1 bd-test1 --type blocks

5.3.4. Product Owner Persona

# View customer-facing work
bd list --label customer-facing

# Prioritize based on feedback
bd update bd-impl2 --priority 0

# Track user stories
bd create "As a user, I want faster page loads" -t feature -p 1
bd label add bd-story1 user-story customer-facing

5.4. Dependency Management

Beads provides rich dependency tracking: 

# Types of dependencies
bd dep add <issue> <target> --type blocks      # Issue blocks target
bd dep add <issue> <target> --type related     # Issues are related
bd dep add <issue> <target> --type discovered-from  # Issue discovered from target

This enables:

  • Blocking relationship enforcement
  • Traceability between related issues
  • Discovery chain documentation

5.5. Handoff Patterns

Beads formalizes handoff patterns between personas: 

Architecture → Implementation:
  1. Architect creates design spec
  2. Architect closes with reason documenting decision
  3. Implementation tasks created with related dependency
  4. Labels transfer ownership to implementer

Implementation → Review:
  1. Implementer closes implementation issue
  2. Review issue created with related dependency
  3. Review label transfers ownership to reviewer

Review → Product:
  1. Reviewer approves or creates blocking issues
  2. UAT issue created for product testing
  3. Product owner validates and closes epic

6. Comparative Analysis

diagram-workflow-topologies.png

6.1. Temporal Characteristics

Dimension CONTINUE Beads
Communication Synchronous Asynchronous
State Duration Session-scoped Persistent
Latency Milliseconds Seconds to minutes
Consistency Strong (within session) Eventual

6.2. Coordination Scope

Dimension CONTINUE Beads
Agent Coupling Tight Loose
Session Dependency Required Optional
Cross-session State Manual handoff Automatic
Conflict Resolution Real-time Merge-based

6.3. Use Case Alignment

6.3.1. CONTINUE Excels At:

  1. Concurrent agent operation: Multiple agents working simultaneously on related tasks
  2. Real-time feedback loops: Observer identifies issue, Builder responds immediately
  3. Session-specific coordination: Tight coupling during active development
  4. Communication tracing: IRC logs provide complete interaction history

6.3.2. Beads Excels At:

  1. Cross-session continuity: Work persists between development sessions
  2. Persona-based filtering: Each role sees only relevant work
  3. Dependency tracking: Complex relationships between issues
  4. Team coordination: Multiple developers working asynchronously

6.4. Failure Modes

6.4.1. CONTINUE Failure Modes

  • FIFO accumulation on unresponsive agent
  • Session state loss on unexpected termination
  • IRC session dependency for announcements
  • No recovery mechanism for interrupted sessions

6.4.2. Beads Failure Modes

  • Merge conflicts in JSONL on concurrent edits
  • Database/JSONL synchronization drift
  • Label inconsistency across team members
  • Stale issue accumulation without cleanup

7. Hybrid Integration Model

7.1. Proposed Architecture

We propose a hybrid model that combines real-time CONTINUE coordination with persistent Beads state management: 

┌─────────────────────────────────────────────────────────────┐
│                    Hybrid Architecture                       │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Active Session (CONTINUE)               │    │
│  │                                                      │    │
│  │   Builder ◄──FIFO──► Observer ◄──FIFO──► Meta      │    │
│  │      │                   │                   │       │    │
│  │      └───────────────────┴───────────────────┘       │    │
│  │                         │                            │    │
│  └─────────────────────────┼────────────────────────────┘    │
│                            │                                  │
│                            ▼ Handoff Points                  │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Persistent State (Beads)                │    │
│  │                                                      │    │
│  │   Issues ◄── Labels ──► Dependencies ──► Sync       │    │
│  │                                                      │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                              │
└─────────────────────────────────────────────────────────────┘

7.2. Integration Points

7.2.1. Session Start

#!/usr/bin/env bash
# hybrid-session-start.sh

# Initialize CONTINUE infrastructure
PROJECT_NAME=$(basename $(pwd))
for fifo in observer-to-builder builder-to-observer system-status; do
    [[ -p "/tmp/${PROJECT_NAME}-${fifo}.fifo" ]] || mkfifo "/tmp/${PROJECT_NAME}-${fifo}.fifo"
done

# Load Beads context
bd ready  # Show available work
bd list --status in_progress  # Resume in-progress items

○ www.wal.sh-ag1 P1 bare-metal revalidation after container publish passes
○ www.wal.sh-0ea P1 [bug] security: agentjacking via MCP tool output trust (Sentry DSN attack)
○ www.wal.sh-c5j P2 Integrate Dafny sketch and PBT generators into time-travel chat spec
○ www.wal.sh-535 P2 daily-publish: scheduled audit + publish pipeline for morning briefs
○ www.wal.sh-82f P2 research: agentic REPL-driven development with Emacs+CIDER+tmux+Claude Code
○ www.wal.sh-eaw P2 [bug] transform.core/thread: fix NullPointerException on keyword steps
○ www.wal.sh-x8i P2 Makefile: proper dependency graph for org/static/generated publish
○ www.wal.sh-4xq P2 [bug] atom feed: auto-regenerate research.atom during publish-daily
○ www.wal.sh-696 P2 deprecate scripts/*.py: migrate to Clojure or Emacs
○ www.wal.sh-htx P2 skill: container rebuild validation (podman/bastille)
○ www.wal.sh-36m P2 research: local-first LLM harness cost analysis (Claude Code / Ollama / bare metal)
○ www.wal.sh-80x P2 experience-report: sandbox credential isolation testing
○ www.wal.sh-fye P2 annotate sandbox-systems with Willison corpus (44 posts, 2024-2026)
○ www.wal.sh-pm9 P2 split agent-sandbox-practical-configs into 7 includes
○ www.wal.sh-mg0 P2 FreeBSD 15.1-RELEASE upgrade: revalidate harnesses + containers
○ www.wal.sh-7gp P2 migrate Python scripts to Clojure/bb: sitemap, security_check
○ www.wal.sh-5id P2 research: agent observability for one-operator labs (ClickHouse + LaPDOG + OTEL)
○ www.wal.sh-sue P3 Validate references.bib entries across research notes
○ www.wal.sh-oj8 P3 Banner generation as beads pipeline
○ www.wal.sh-llu P3 Audit begin_src text blocks — most should be begin_example
○ www.wal.sh-mgf P3 IIA events placeholder: TEDxBoston, IIA Summit, TekTrek 2026
○ www.wal.sh-84q P3 monit/supervisord: keep dev REPL stack alive across reboots
○ www.wal.sh-brb P3 nREPL stability: document JVM heap requirements for multi-project REPL
○ www.wal.sh-6g3 P3 research: PrologMCP + four-ways logic programming comparison
○ www.wal.sh-ac4 P3 content-type audit: .htaccess for atom/json/wsdl MIME types
○ www.wal.sh-adb P3 events: Boston July 4th + ECOOP/ICML July 2026
○ www.wal.sh-6xd P3 wal-sh.site.llms-txt: generate /llms.txt from read-all
○ www.wal.sh-vpt P3 update sandbox-systems note with LiteLLM credential proxy + Willison references
○ www.wal.sh-4e0 P3 migrate 119 standalone .dot files into org-mode src blocks
○ www.wal.sh-dux P3 OpenSearch: add /opensearch.xml for pocket-es browser integration
○ www.wal.sh-wue P3 research: org-publish as implicit dependency scanner (containerization experience)
○ www.wal.sh-b5j P3 research: FreeBSD container image for org-mode publishing
○ www.wal.sh-6xw P3 research: AI agent crawler economics (bot trap + cost analysis)
○ www.wal.sh-28k P3 research: personal infrastructure manifesto (heterogeneous computing)
○ www.wal.sh-8w4 P3 research: Makefile as build system API (120 targets, 3 tiers)
○ www.wal.sh-edg P4 Promote research/2016-developer-productivity.org to dir form
○ www.wal.sh-4dd P4 Promote research/2019-machine-learning.org to dir form
○ www.wal.sh-3wv P4 Promote research/2025-ai-agent-tool-systems.org to dir form
○ www.wal.sh-aw2 P4 Promote research/2025-scheme-llm-toolkit.org to dir form
○ www.wal.sh-ea2 P4 Promote research/2026-agent-permission-guardrails.org to dir form
○ www.wal.sh-7rc P4 Promote research/advanced-clojure.org to dir form
○ www.wal.sh-2x5 P4 Promote research/app-cache-expiration.org to dir form
○ www.wal.sh-by8 P4 Promote research/blockchain-border-bank.org to dir form
○ www.wal.sh-b9m P4 Promote research/ci-cd-2020.org to dir form
○ www.wal.sh-1hq P4 Promote research/clojure.spec.org to dir form
○ www.wal.sh-2vh P4 Promote research/clojure-graphql.org to dir form
○ www.wal.sh-ary P4 Promote research/deeplens.org to dir form
○ www.wal.sh-6f8 P4 Promote research/dynamodb.org to dir form
○ www.wal.sh-gpr P4 Promote research/event-driven-architectures-actor-model.org to dir form
○ www.wal.sh-b3s P4 Promote research/grunt-git-flow-puppet.org to dir form
○ www.wal.sh-bg6 P4 Promote research/javascript-ast-statistics.org to dir form
○ www.wal.sh-ido P4 Promote research/jsonapi-rails-angularjs.org to dir form
○ www.wal.sh-7z4 P4 Promote research/llm-agent-frameworks.org to dir form
○ www.wal.sh-tkt P4 Promote research/local-first.org to dir form
○ www.wal.sh-3ms P4 Promote research/model-interpretability-fairness-fintech.org to dir form
○ www.wal.sh-auh P4 Promote research/multi-agent-workflow-frameworks.org to dir form
○ www.wal.sh-q80 P4 Promote research/org-mode-productivity.org to dir form
○ www.wal.sh-jua P4 Promote research/rag-system.org to dir form
○ www.wal.sh-84h P4 Promote research/terraform-patterns.org to dir form
○ www.wal.sh-cux P4 Promote research/terraform.org to dir form
○ www.wal.sh-jry P4 editorial-workflow: publish as research note after 1-week trial
○ www.wal.sh-wdd P4 quarterly header/block auditor via Ollama mini.local:11434
○ www.wal.sh-rz1 P4 wire scratch/WebDAV inbox into tech-crawler or REPL
○ www.wal.sh-s7s P4 scratch-inbox: nREPL drill
○ www.wal.sh-mqj P4 scratch-inbox: Mutual Reasoning paper
○ www.wal.sh-5wx P4 scratch-inbox: Local-first models
○ www.wal.sh-4pw P4 speculative: flight event Atom feed from tracker warehouse
○ www.wal.sh-o34 P4 Clojars: verify com.defrecord group via DNS TXT record
○ www.wal.sh-czq P4 reference: arXiv:2606.19632 formal verification of multi-agent communication
○ www.wal.sh-wwo P4 banner: regenerate org-mode-titles banner via Ollama flux2-klein

--------------------------------------------------------------------------------
Ready: 70 issues with no active blockers

Status: ○ open  ◐ in_progress  ● blocked  ✓ closed  ❄ deferred
Priority: P0–P4 (label only; not a status icon)
◐ www.wal.sh-l6d P2 RSS/Atom feed: add Yahoo Media RSS (MRSS) for larger banner images
◐ www.wal.sh-3pg P3 cn: scaffold the 4-tier (core.cljc + cli.clj + bb.edn task + bin/cn wrapper) and retire crowsnest-*.py

--------------------------------------------------------------------------------
Total: 2 issues (0 open, 2 in progress)

Status: ○ open  ◐ in_progress  ● blocked  ✓ closed  ❄ deferred
Priority: P0–P4 (label only; not a status icon)

7.2.2. During Session

# Builder discovers issue during implementation
# CONTINUE: Announce to Observer
echo "🟢 Builder: Found connection leak" > "$BUILDER_TO_OBSERVER_FIFO" &

# Beads: Create persistent issue
bd create "Connection leak in database pool" -t bug -p 1
bd label add bd-leak123 implementation bug

# CONTINUE: Announce issue creation
tmux send-keys -t claude-irc ":[builder:$PROJECT:$BRANCH] Created bd-leak123" Enter

7.2.3. Session End

#!/usr/bin/env bash
# hybrid-session-end.sh

# Drain CONTINUE channels
timeout 2 cat "$OBSERVER_TO_BUILDER_FIFO" 2>/dev/null
timeout 2 cat "$BUILDER_TO_OBSERVER_FIFO" 2>/dev/null

# Update Beads state
bd list --status in_progress | while read issue; do
    echo "Review before closing: $issue"
done

# Sync and push
git pull --rebase
bd sync
git push

# Final announcements
tmux send-keys -t claude-irc ":[meta-observer:$PROJECT:$BRANCH] Session complete" Enter

Review before closing: ◐ www.wal.sh-l6d P2 RSS/Atom feed: add Yahoo Media RSS (MRSS) for larger banner images
Review before closing: ◐ www.wal.sh-3pg P3 cn: scaffold the 4-tier (core.cljc + cli.clj + bb.edn task + bin/cn wrapper) and retire crowsnest-*.py
Review before closing: 
Review before closing: --------------------------------------------------------------------------------
Review before closing: Total: 2 issues (0 open, 2 in progress)
Review before closing: 
Review before closing: Status: ○ open  ◐ in_progress  ● blocked  ✓ closed  ❄ deferred
Review before closing: Priority: P0–P4 (label only; not a status icon)
Current branch main is up to date.

7.3. Label Mapping

CONTINUE Agent Beads Labels
Builder implementation, bug, feature
Observer architecture, documentation, analysis
Meta-Observer meta, process, monitoring

8. Implementation Considerations

8.1. Resource Requirements

8.1.1. CONTINUE Requirements

  • Unix-like operating system (FreeBSD, Linux, macOS)
  • tmux for IRC session management
  • Named pipe support in /tmp filesystem
  • Multiple terminal sessions for concurrent agents

8.1.2. Beads Requirements

corrected · pilot-annotation-pass · 2026-10-08
  • Go runtime (single static binary; no separate interpreter install)
  • Dolt-backed SQL database support
  • Git repository with hook support
  • Disk space for JSONL exports

8.2. Security Considerations

8.2.1. FIFO Security

  • FIFOs created in /tmp are world-readable by default
  • Consider using restricted directories for sensitive projects
  • Named pipes do not persist data; no encryption needed for at-rest

8.2.2. Beads Security

  • Dolt database contains issue content
  • JSONL files committed to git are visible in history
  • Sensitive information should be referenced, not included

8.3. Performance Characteristics

8.3.1. CONTINUE Performance

FIFO Message Latency: < 1ms (local)
IRC Announcement: ~10-50ms
Session Startup: ~100ms
FIFO Drain: Blocking until data or timeout

8.3.2. Beads Performance

bd create: ~50-100ms
bd list: ~20-50ms (depends on filter complexity)
bd sync: ~200-500ms (includes git operations)
JSONL export: O(n) where n = issue count

9. Evaluation

9.1. Methodology

We evaluated both frameworks across three dimensions:

  1. Coordination Effectiveness: How well do agents stay synchronized?
  2. State Preservation: How reliably is work tracked across sessions?
  3. Developer Experience: How intuitive is the workflow?

9.2. Qualitative Findings

9.2.1. CONTINUE Strengths

  • Immediate feedback enables tight collaboration loops
  • Color-coded output improves visual parsing
  • IRC logs provide auditable history
  • Role constraints prevent scope creep

9.2.2. CONTINUE Weaknesses

  • Session dependency limits async work
  • Manual state handoff is error-prone
  • No built-in recovery from interrupted sessions
  • Requires multiple terminal setup

9.2.3. Beads Strengths

  • Persistent state enables cross-session continuity
  • Label filtering provides clear persona views
  • Dependency tracking shows work relationships
  • Git integration ensures durability

9.2.4. Beads Weaknesses

  • No real-time coordination mechanism
  • Label proliferation requires governance
  • Merge conflicts possible in team settings
  • Learning curve for CLI interface

9.3. Hybrid Model Benefits

The integrated approach provides:

  1. Best of both worlds: Real-time coordination with persistent state
  2. Graceful degradation: System remains useful if one component fails
  3. Flexibility: Choose synchronous or asynchronous based on context
  4. Completeness: No gaps in coordination or tracking capabilities

10. Future Work

10.1. Planned Extensions

  1. Automated Session Recovery: Use Beads state to reconstruct CONTINUE context after interruption
  2. Cross-Project Coordination: Enable agents to track work across multiple repositories
  3. Metrics Collection: Instrument both systems for quantitative performance analysis
  4. Natural Language Interface: Allow agents to query and update state conversationally

10.2. Research Directions

  1. Formal Verification: Model CONTINUE communication protocols for safety proofs
  2. Scalability Analysis: Evaluate performance with larger agent populations
  3. Human-Agent Teaming: Study how human developers interact with multi-agent systems
  4. Adaptive Personas: Dynamically adjust agent constraints based on project phase

11. Conclusion

The CONTINUE framework provides synchronous real-time coordination through FIFOs and IRC, while Beads offers asynchronous persistent state management through label-based issue tracking.

Our analysis reveals that these approaches are complementary rather than competing. CONTINUE excels during active development sessions where tight coordination is valuable, while Beads provides the cross-session continuity essential for sustained project work.

The proposed hybrid integration model combines the strengths of both systems for multi-agent AI development environments.

12. Acknowledgments

This research was conducted using Claude Code on FreeBSD 14.3. The CONTINUE framework was developed as part of the NexusHive multi-agent infrastructure project. Beads is an open-source project available at https://github.com/aygp-dr/beads.

13. References

  • Wooldridge, M. (2009). An Introduction to MultiAgent Systems (2nd ed.). Wiley.
  • Wang, L., et al. (2024). A Survey on Large Language Model based Autonomous Agents. arXiv preprint arXiv:2308.11432.
  • Pruitt, J., & Adlin, T. (2006). The Persona Lifecycle: Keeping People in Mind Throughout Product Design. Morgan Kaufmann.

14. Appendix A: CONTINUE Agent Templates

14.1. Builder Agent Configuration

---
name: builder
description: Feature implementation specialist
color: green
emoji: "🟢"
permissions:
  - read: "*"
  - write: "*"
constraints:
  - "No git add -A"
  - "Conventional commits required"
  - "IRC announcements mandatory"
---

14.2. Observer Agent Configuration

---
name: observer
description: Analysis and documentation specialist
color: blue
emoji: "🔵"
permissions:
  - read: "*"
  - write: ".claude/observations/*"
constraints:
  - "Read-only for source code"
  - "Must maintain objectivity"
  - "Document all significant findings"
---

15. Appendix B: Beads Label Taxonomy

15.1. Role Labels

Label Description
architecture Architectural decisions and design
implementation Code implementation work
review Code review tasks
product Product owner concerns

15.2. Type Labels

Label Description
bug Defect requiring fix
feature New functionality
task General work item
epic Large multi-issue effort

15.3. Status Labels

Label Description
critical Highest priority
blocked Cannot proceed
waiting-feedback Pending external input
needs-design Requires architectural decision

16. Appendix C: Integration Scripts

16.1. continue-dashboard.sh

set -euo pipefail

PROJECT_NAME=$(basename $(pwd))

OBSERVER_TO_BUILDER_FIFO="/tmp/${PROJECT_NAME}-observer-to-builder.fifo"
BUILDER_TO_OBSERVER_FIFO="/tmp/${PROJECT_NAME}-builder-to-observer.fifo"
SYSTEM_STATUS_FIFO="/tmp/${PROJECT_NAME}-system-status.fifo"

echo "Initializing CONTINUE framework for: ${PROJECT_NAME}"

for fifo in "$OBSERVER_TO_BUILDER_FIFO" "$BUILDER_TO_OBSERVER_FIFO" "$SYSTEM_STATUS_FIFO"; do
    if [[ ! -p "$fifo" ]]; then
        mkfifo "$fifo"
        echo "Created: $fifo"
    else
        echo "Exists:  $fifo"
    fi
done

echo ""
echo "FIFOs ready for ${PROJECT_NAME}"

Initializing CONTINUE framework for: research
Exists:  /tmp/research-observer-to-builder.fifo
Exists:  /tmp/research-builder-to-observer.fifo
Exists:  /tmp/research-system-status.fifo

FIFOs ready for research

16.2. landing-the-plane.sh

set -euo pipefail

PROJECT_NAME=$(basename $(pwd))
BRANCH=$(git branch --show-current)

echo -e "\033[35m🟣 Meta-Observer: Initiating session handoff\033[0m"

# Drain FIFOs
timeout 2 cat "/tmp/${PROJECT_NAME}-observer-to-builder.fifo" 2>/dev/null || true
timeout 2 cat "/tmp/${PROJECT_NAME}-builder-to-observer.fifo" 2>/dev/null || true

# Show in-progress
echo "In-progress issues:"
bd list --status in_progress 2>/dev/null || echo "  (none)"

# Sync and push
git pull --rebase
bd sync
git push

echo "Session complete."

🟣 Meta-Observer: Initiating session handoff
In-progress issues:
◐ www.wal.sh-l6d P2 RSS/Atom feed: add Yahoo Media RSS (MRSS) for larger banner images
◐ www.wal.sh-3pg P3 cn: scaffold the 4-tier (core.cljc + cli.clj + bb.edn task + bin/cn wrapper) and retire crowsnest-*.py

--------------------------------------------------------------------------------
Total: 2 issues (0 open, 2 in progress)

Status: ○ open  ◐ in_progress  ● blocked  ✓ closed  ❄ deferred
Priority: P0–P4 (label only; not a status icon)
Already up to date.