This article describes a multi-agent architecture running at scale, using LangGraph, CrewAI, and Harbor to handle goal agents, task coordination, and secure access with tracing.
Currently, we're running agents at org scale. There were multiple problems we faced, like the credential problem, the state problem, and the execution trace problem, during our initial days but we overcame it & here's our simplified architecture. Our setup runs three agent classes against a **shared context layer**. Observer agents sit at the edge pulling in external signals and writing structured events. Task agents pick up work from that stream, execute bounded actions, and write results back. Goal agents read the full execution history, build plans, sequence task agents, and re-plan when conditions shift. [LangGraph ](https://github.com/langchain-ai/langgraph)handles the goal agent layer. The stateful graph structure maps to how goal agents work: conditional branching, checkpointed state, and the ability to resume mid-plan when a task agent fails or returns a partial result. Hand-rolling that logic is how you end up with orchestration code nobody wants to touch six months later. [CrewAI ](https://crewai.com/)handles task coordination. Role-based agent assignment with shared short-term and long-term memory, plus a planning agent that sequences tasks before execution starts. The crew model maps closely enough to the task-oriented agent class that we use it without custom scaffolding. [Harbor ](https://tryharbor.io/)sits underneath all of it. Every agent in the fleet gets scoped access to tools, files, and workflows through Harbor's workspace model. Credentials stay in Harbor, not in model context. Every tool call produces a trace. When an agent calls a database, hits an external API, or triggers a downstream workflow, that action is logged with full provenance. At fleet scale, that trace layer is what lets you debug a failure in under an hour instead of a day. The ring-based protocol governs message routing on top of this. Kernel agents at Ring 0 manage agent lifecycle. Orchestrators at Ring 1 route messages by agent metadata and classification. Goal agents at Ring 2 decompose intents into task plans. Task agents at Ring 3 execute with least privilege. Observer agents at Ring 4 run continuously, posting events without making decisions. As the shared conversation deepens, newer agents start with a richer operational history than earlier ones did. Our best thing is that the coordination overhead per agent drops as the history grows.
The author shares practical lessons learned from deploying multi-agent orchestration frameworks (LangGraph, CrewAI, and A2A) in production, contrasting with simple notebook experiments.
A practical inquiry into the runtime architecture of multi-agent AI systems in production, discussing orchestration, memory, statefulness, and tool choices like Temporal, LangGraph, and custom approaches.
Anthropic details the architecture and engineering principles behind its new multi-agent research system, highlighting how parallel subagents using Claude Opus 4 and Sonnet 4 significantly outperform single-agent approaches in complex research tasks.
A discussion on the trade-offs between multi-agent systems and a single agent per brand, highlighting how organizational structure can influence product design.
Explains how multi-agent AI systems work to automate business processes, covering the architecture and benefits of using multiple AI agents for task orchestration.