98 Expert Agents Working in Concert: A Deep Dive into an Open-Source Multi-Agent Orchestration Framework

A multi-agent orchestration framework surging in popularity on GitHub comes packed with 98 expert agents covering the entire development pipeline—from architecture design to operations—with the ability to learn and evolve autonomously. How does it transform Claude Code into a super-powered development team? Let's take a deep dive.

Swarm Orchestration: How 98 Agents Work Together

The most striking design of this open-source project is its "swarm"-like multi-agent orchestration mechanism. Unlike traditional single-agent tools, it ships with 98 expert agents covering the complete software development lifecycle—from architecture design, documentation, development, and testing to deployment and operations—forming a comprehensive end-to-end capability chain.

Multi-Agent Systems (MAS) are a core research area in distributed artificial intelligence, with theoretical roots tracing back to distributed problem-solving research in the 1980s. In the era of large language models, this architecture has leaped from academic concept to engineering reality. Since 2023, projects like Stanford's Generative Agents, Microsoft's AutoGen, and CrewAI have demonstrated the superiority of multi-agent collaboration on complex tasks. The core idea is straightforward: rather than burdening a single generalist agent with all responsibilities, let multiple agents—each equipped with specialized prompts and toolchains—divide and conquer, achieving emergent capabilities through carefully designed communication protocols and scheduling strategies. This paradigm shift is analogous to the evolution from monolithic to microservice architectures in software engineering.

More importantly, these agents don't operate in isolation. The framework employs a hierarchical scheduling mechanism akin to a "queen bee leading the hive": a core agent acts as the orchestrator, responsible for task decomposition and dispatch, enabling all agents to share collective memory and reach consensus through consensus algorithms to complete complex tasks in an orderly and stable manner.

Swarm Intelligence originated from observing and modeling collective behavior in nature, first proposed by Gerardo Beni and Jing Wang in 1989. In a natural bee colony, the queen doesn't directly command each worker bee; instead, coordination is achieved in a decentralized fashion through chemical signals like pheromones. This framework draws on that concept but adopts a more hierarchical scheduling model—the core agent plays the queen bee role, handling global task orchestration. On the consensus algorithm front, classic algorithms like Raft and PBFT in distributed systems ensure state consistency across multiple nodes; in multi-agent scenarios, consensus mechanisms ensure that multiple agents agree on task objectives, execution order, and output standards, preventing conflicting outputs or semantic contradictions between agents.

This design delivers three significant advantages:

• Smarter task decomposition: The core agent understands the global context and can break complex requirements into multiple subtasks
• More efficient collaboration: Each expert agent handles its specialty, avoiding redundant work
• More consistent results: Consensus algorithms ensure outputs from multiple agents don't contradict each other

Sub-Millisecond Memory Retrieval and Autonomous Learning Evolution

On the performance front, this framework integrates a vector memory system based on HNSW indexing, capable of sub-millisecond memory retrieval. HNSW (Hierarchical Navigable Small World) is one of the most efficient algorithms in vector search today, widely used across various AI systems.

From a technical standpoint, the HNSW algorithm was proposed by Yury Malkov et al. in 2016. Its core idea is to build a multi-layer graph structure: the bottom layer contains all data points forming a dense small-world network, while upper layers become progressively sparser, retaining only key nodes as "highways." During retrieval, the algorithm starts a greedy search from the top layer, descending layer by layer to refine the search scope, ultimately finding the nearest neighbor at the bottom layer. This hierarchical strategy reduces search complexity from O(n) to O(log n), achieving sub-millisecond responses even at million-scale vector volumes. HNSW is widely used in mainstream vector databases like Faiss, Milvus, and Qdrant. In this framework, the HNSW index stores and retrieves agents' historical experience vectors, enabling the system to quickly match current tasks with historically similar scenarios.

But what truly sets this framework apart is its autonomous learning mechanism. The system automatically extracts successful patterns from historical tasks, distills them into reusable experience, and applies them to future work. Specifically:

• The more you use the framework, the better it performs
• Team best practices are automatically accumulated and passed on
• Task processing accuracy continuously improves

This "gets smarter with use" characteristic is essentially an engineered implementation of Experience Replay and knowledge distillation. In cognitive science, Japanese scholar Ikujiro Nonaka's SECI model describes the conversion process between tacit and explicit knowledge: Socialization, Externalization, Combination, and Internalization. The framework's autonomous learning maps neatly onto this process—extracting successful patterns from historical task execution (Externalization), storing them as structured vector memories (Combination), and automatically retrieving and applying them in new tasks (Internalization). This shares similarities with traditional RAG (Retrieval-Augmented Generation) but goes further: it doesn't just retrieve static documents—it dynamically distills and updates experiential knowledge gained from actual execution feedback.

By making a team's tacit knowledge explicit and systematic, it creates a continuously evolving AI development assistant. For teams maintaining large projects over the long term, this feature is invaluable.

Agent Federation: A Distributed Architecture for Cross-Machine Remote Collaboration

Beyond single-machine multi-agent coordination, the framework also supports an Agent Federation feature. This design allows agents deployed on different machines to connect and collaborate remotely on large-scale development projects while ensuring that each party's data remains isolated and unexposed.

Federated Learning was proposed by Google in 2016, originally to address privacy concerns in model training on mobile devices. Its core principle is "data stays put, models move"—each participant trains models locally and only uploads model parameters or gradients to a central server for aggregation, enabling collaborative learning without exposing raw data. This framework's Agent Federation borrows from this concept but extends the application from model training to task execution: agents on different machines can share task decomposition results, intermediate reasoning artifacts, and final outputs, while their respective codebases, private data, and local memories are never transmitted across nodes.

This federated architecture delivers three core advantages:

• Data isolation: Each node's data is never directly exposed to other nodes, ensuring data security and privacy
• Capability sharing: Agents on different machines can contribute their respective expertise, forming a more powerful collective capability
• Distributed scaling: Breaks through single-machine compute limitations, suitable for collaborative development on large-scale projects

This architecture is particularly well-suited for cross-department collaboration, outsourced development, and enterprise scenarios involving compliance requirements (such as GDPR and data localization regulations), aggregating capabilities while safeguarding data sovereignty. For distributed teams or enterprises handling sensitive data, this is an extremely practical feature.

Practical Usage: Two Flexible Integration Methods

The framework offers two flexible integration approaches:

Claude Code Plugin Mode

Install it as a plugin in Claude Code, and after installation, simply use Claude Code as usual. The framework works silently under the hood, intelligently dispatching the appropriate expert agents based on task type. The benefit of this approach is zero learning curve—developers don't need to change their existing workflows.

Claude Code is a command-line AI programming tool from Anthropic that allows developers to interact with the Claude model directly in the terminal for code writing, debugging, and refactoring. Unlike GitHub Copilot's inline completion model, Claude Code uses conversational interaction, capable of understanding project-level context and performing cross-file operations. Its plugin mechanism allows third-party tools to integrate via MCP (Model Context Protocol) or custom Hooks, extending Claude Code's capabilities. MCP is an open protocol proposed by Anthropic to standardize interactions between large models and external tools and data sources—think of it as a USB port for AI. By integrating through plugin mode, this framework means developers can gain enhanced multi-agent collaboration capabilities within their familiar environment without switching toolchains.

WebUI Chat Mode

Use the framework's built-in WebUI interface to launch the agent swarm through conversational chat. This approach is better suited for advanced users who need fine-grained control over agent scheduling strategies, offering a more intuitive way to observe and manage the multi-agent collaboration process.

Open-Source Ecosystem and Technical Value

The project is released under the MIT License, fully open-source and free for both individual developers and enterprises to use and build upon. The MIT License is one of the most permissive open-source licenses, requiring only that copyright and license notices be preserved while allowing anyone to freely use, modify, distribute, and even commercialize the software without open-sourcing derivative works. Compared to GPL's copyleft requirements and Apache 2.0's patent grant clauses, MIT's minimalist nature makes it the go-to choice for commercially friendly projects. For enterprise users, this means the framework can be integrated into proprietary products without legal concerns; from an ecosystem perspective, the MIT License also helps attract more developers to contribute code and build derivative tools, accelerating community-driven growth.

From a technology trend perspective, this project represents an important direction in AI-assisted development: moving from a single AI assistant to multi-agent collaboration systems. A single large model's capabilities have inherent limits, but through a well-designed orchestration framework that lets multiple specialized agents each handle their domain while working in concert, the overall result can far exceed what any single agent could achieve.

Key technical highlights worth noting:

1. Full-pipeline coverage with 98 expert agents demonstrates the team's deep understanding of every phase of software engineering
2. The combination of HNSW vector memory + autonomous learning gives the system the ability to continuously evolve
3. The Agent Federation's distributed architecture opens up possibilities for enterprise-grade application scenarios
4. Deep integration with Claude Code lowers the barrier to entry

For teams exploring AI-assisted development, this project is well worth studying and trying out. It's not just a tool—it represents the practical engineering implementation of the multi-agent collaboration paradigm.