Orchestrating Multi-Agent Workflows: Leveraging ACP and Context Harvesting via Buzz

The landscape of Large Language Model (LLM) interaction is shifting from single-prompt, single-model interfaces toward complex, multi-agent orchestration. While traditional platforms like ChatGPT or Claude provide isolated chat environments, a new open-source paradigm is emerging: the "context harvester." Enter Buzz, an agentic orchestration layer developed by Block (founded by Jack Dorsey). Buzz functions less like a standard messaging app and as more of a centralized command center for managing disparate AI agents, CLI tools, and local compute resources.

The Architecture of Agent Orchestration: ACP and Harnesses

At the core of Buzz's technical utility is its ability to interface with various "harnesses"—local or remote execution environments running specific LLM implementations. Unlike traditional SaaS models where data is siloed within a proprietary database, Buzz utilizes what is referred to as the Agent Client Protocol (ACP) (or Agent Connect Protocol).

This protocol allows Buzz to act as a bridge between high-level user commands and low-level CLI tools running on a local machine or a remote relay. When you connect an agent like Codex or Claude Code, Buzz isn't just mirroring a chat; it is injecting context into the underlying terminal session. This enables "context harvesting," where the shared state of a conversation—including files, previous outputs, and tool-use logs—is preserved across different model instances.

For developers, this means you can bridge specialized tools like Cursor, Devin, or Grok Build into a single unified interface. If an agent is running as a CLI tool on your system, Buzz leverages the ACP to facilitate communication between that local process and the broader team of agents in a specific channel.

Multi-Model Synergy and Context Transfer

One of the most significant technical advantages of the Buzz architecture is its ability to maintain session continuity during model switching. In a standard workflow, moving from Claude 3.5 Sonnet to Codex would require manual context re-injection (copy-pasting logs or file contents). In Buzz, because the platform acts as the central state manager, you can swap the underlying "harness" without losing the conversation's historical trajectory.

This enables sophisticated multi-agent workflows:

1. The Lead Agent Pattern: You designate a high-capability model (e.g., Codex) with extensive "skills" (Notion integration, file system access, etc.) as the lead.
2. Specialized Sub-Agents: You can tag other agents in a thread to perform specific critiques or parallel tasks. For example, you might instruct Codex to generate a landing page via Vercel, then explicitly @mention an agent running Sonnet to review the code for architectural flaws.

The platform also supports advanced parallelism settings. Within the agent configuration, users can define how many concurrent sessions a single harness is allowed to spin up. By increasing parallelism (e.g., setting a limit of 10 instead of 1), a user with a robust Codex subscription can effectively run multiple parallel sub-tasks under a single unified command, significantly increasing throughput for high-volume tasks like thumbnail generation or data scraping.

Integrating OpenRouter and Custom LLM Endpoints

For power users, Buzz provides the flexibility to integrate any OpenAI-compatible API via OpenRouter. This allows the platform to transcend the limitations of local hardware by accessing frontier models like Meta's Muse or specialized fine-tunes.

The integration process requires precise configuration of the base_url and authentication headers. To successfully route requests through OpenRouter, users must modify the agent settings to point to the specific endpoint (e.g., using the underscore prefix for _base_url) and configure the "thinking effort" parameters to ensure the model handles complex reasoning tasks appropriately. This level of granular control allows developers to build bespoke agents that are specifically tuned for either high-speed, low-cost inference or deep-reasoning, high-latency tasks.

Beyond Chat: The Future of Agentic Repositories and Compute Sharing

Buzz is positioning itself as more than a "Slack killer"; it aims to challenge the dominance of GitHub through its Projects feature. By utilizing a relay/server architecture, Buzz allows users to push code directly to their community's relay rather than just a remote cloud repository. This creates an environment where agents can manage version control (Git-like functionality) within a localized or shared ecosystem.

Furthermore, the platform introduces the concept of shared compute. Through the "Compute" settings, a user can opt to share their local machine's resources with their community relay. If you have high-end GPUs capable of running powerful local models, you can host these models on your machine and allow other members of your Buzz organization to call upon them as agents. This paves the way for an "agent-to-agent economy," where specialized models might eventually pay micro-fees in tokens or currency to higher-level models to complete delegated tasks.

Conclusion: The Shift Toward Agentic Autonomy

The ultimate goal of this architecture is to move from "human-prompting" to "task-delegation." While current limitations exist—such as the difficulty in creating reliable, non-looping automated workflows (the "workflow reliability gap")—the foundation laid by Buzz's open protocol and context-centric design is transformative. As we move toward a future of continuous-mode agents that can monitor emails, scrape social data, and execute code autonomously, the ability to orchestrate these entities within a unified, transparent framework will be the defining technical challenge of the next decade.