Claude Conference vs. RabbitMQ — Coordination Experiment

A small, evidence-bound test of whether Claude's agent-spawning mechanics ("Conference" / Agent Teams) can replace a RabbitMQ + SQLite multi-agent coordination system. Start with EXPERIMENT_REPORT.md for the full narrative — this README covers structure and reproduction only. See CHANGELOG.md for the revision history, including a post-publication correction.

Licensed under MIT.

What this tests

Whether Claude's "Conference / Agent Team" style collaboration can replace a previous RabbitMQ + SQLite multi-agent coordination system, across ten specific dimensions: agent addressability, message durability, task correlation, independent execution, inspector synchronization, observability, reproducibility, failure handling, external worker compatibility, and best-use boundary. This is a coordination test, not a content-quality test — see experiment_plan.md for the full test matrix and pass/fail criteria.

How to reproduce

1. Spawn two agents in parallel (conference_advocate, rabbitmq_advocate), each instructed to run a self-diagnostic of its own tool access (check for shared task-list tools, direct-messaging tools, and cross-session visibility tools) before writing its memo.
2. Relay both outputs into a third agent (hybrid_architect) that designs a hybrid split and responds to specific claims from each.
3. Relay the full trace into a fourth agent (inspector) that applies the strict seven-point rule in experiment_plan.md and produces a verdict.
4. Persist every output to the file structure below.

This was actually run once, in this folder, on 2026-06-21. The prompts used are summarized in experiment_plan.md; rerunning will produce fresh (non-deterministic) LLM text but should reproduce the same structural finding, since it depends on tool availability, not on model phrasing.

Was native Conference / Agent Teams available?

Partially, in this session. Independent subagent dispatch (the Agent tool) is real and was used to spawn four genuinely separate execution contexts. What is not available in this Cowork session, confirmed by direct empirical testing by three independent agents plus the orchestrator: no agent-to-agent messaging tool (no SendMessage/mailbox/notify_agent), no shared task list visible to spawned teammates (a task list exists, but only for the top-level orchestrator), and no native file persistence by the teammates themselves during their own runs. See logs/conference_trace.md for the full breakdown of NATIVE_CONFERENCE vs. SIMULATED_CONFERENCE vs. UNAVAILABLE, and logs/limitations.md for everything that was searched for and confirmed absent.

Correction: Anthropic's real "Agent Teams" feature (Claude Code, experimental, gated by CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) does support genuine peer-to-peer messaging via a documented SendMessage tool and Mailbox, plus a shared, file-locked task list — confirmed directly against https://code.claude.com/docs/en/agent-teams. This was not detectable as active in this session (no matching tools found via ToolSearch, no team_name parameter on the Agent tool here). The verdict below reflects what was reachable in this session, not a claim that Anthropic's broader product lacks peer messaging. Full correction in logs/limitations.md.

Final verdict

HYBRID_REQUIRED

Agent-spawning is genuinely good at the discussion/drafting/synthesis layer of small, fixed-role, short-lived workflows with a human or orchestrator supervising synchronously. It does not reproduce RabbitMQ's peer addressability, durable queue/retry semantics, cross-process audit trail, or external (non-Claude) worker support. Full reasoning in outputs/inspector_verdict.md and outputs/final_report.md.

Supplementary evidence: is subagent spawning actually parallel?

agentic_parallism/ (moved into this repo from a separate folder on 2026-06-23) is a related but distinct experiment: it asks whether the Agent tool's independent-execution-context claim — used above to justify NATIVE_CONFERENCE for "independent execution" in logs/conference_trace.md — holds up, or whether it's actually one process running agents one after another and presenting them as independent.

It contains two different things, and they should not be conflated:

• anchor_parallelism_test.py / anchor_parallelism_trace.json — a synthetic asyncio baseline (no real LLM agents involved) showing what true sequential vs. parallel execution looks like in timing data: ~30s sequential vs. ~3s parallel, a 9.99x speedup, 100% pairwise time-window overlap in the parallel run vs. 0% in the sequential run. This exists purely as a reference shape for what real concurrency evidence would look like, not as a claim about Claude.
• subagent_evidence/ — ten real Agent tool spawns (agent_01–agent_10), each independently inspecting the shared folder and writing its own evidence file. Full writeup and conclusion in subagent_spawn_results.md.

What this evidence actually supports: genuine independent execution and judgment — no two agents produced templated or colliding output, later agents (07–10) read and reacted to earlier agents' files in ways a single centralized script wouldn't produce, and agent_10's own filesystem stat capture (subagent_evidence/agent_10_mtime_observation.txt) shows 7 sibling files written within a ~32-second span in an order that doesn't match numeric agent_id order — consistent with overlapping, independently-timed writes rather than one strictly sequential loop.

What it does not establish, per subagent_spawn_results.md's own stated limitation: rigorous wall-clock concurrency. The orchestrator issued all 10 Agent calls in one batch, but the underlying scheduling (true concurrent, interleaved, or fast-sequential) isn't directly observable from the orchestrator's side. The mtime evidence is suggestive of overlap, not a formal proof. Read it as "independent and non-templated, with timing data suggestive of overlap" — not as "proven parallel" in the same rigorous sense as the synthetic asyncio anchor test.

File structure

README.md
EXPERIMENT_REPORT.md
CHANGELOG.md
LICENSE
.gitignore
experiment_plan.md
outputs/
  conference_advocate_memo.md
  rabbitmq_advocate_memo.md
  hybrid_architect_memo.md
  inspector_verdict.md
  final_report.md
logs/
  conference_trace.md
  limitations.md
data/
  test_matrix.csv
agentic_parallism/
  anchor_parallelism_test.py
  anchor_parallelism_trace.json
  subagent_spawn_results.md
  subagent_evidence/
    agent_01.md ... agent_10.md (+ 4 optional artifacts)
live_test/        # populated once the Agent Teams CLI follow-up test runs (see CHANGELOG.md)