Multi-agent System Examples

Below are some examples of Multi-agent system Use Case

Multi-agent Software Testing Use Case

This guide walks through a real-world implementation of a multi-agent software testing system using Coral Protocol, an open infrastructure that enables agents from different frameworks to seamlessly communicate and collaborate.

In this setup, we automate the process of testing a pull request (PR) using four independently built agents. Each agent is written in a different framework LangChain, CAMEL-AI, and CrewAI and yet, they operate as a unified system with no glue code or manual orchestration. Coral handles everything under the hood: message routing, delegation, task tracking, and thread management.

This is a fully working, cross-framework testing system, powered end-to-end by Coral.

Here’s what happens:

1. Start with a Natural Language Query

   This instruction is received by a Coralised Interface Agent, built using LangChain. This agent acts as the entry point for the workflow it doesn’t perform tasks directly, but delegates intelligently to other agents.

2. Clone the Repository (CrewAI Agent)

   The Interface Agent sends the first task to the Git Clone Agent, which is built using CrewAI.

   • This agent clones the GitHub repository.
   • It fetches the specific PR branch.
   • It returns the local repo path to the Interface Agent.

   By speaking the Coral Protocol, the agent knows exactly when to act and where to send the result.

3. Analyse Code Changes (CAMEL-AI Agent)

   Next, the Interface Agent calls the Code Diff Reviewer Agent, which runs on CAMEL-AI.

   • It compares the updated code with the base branch.
   • It identifies changed files, affected logic, and modification types.
   • It returns a structured summary of the code diffs.

   This allows the system to focus only on what has changed saving time and making downstream testing more efficient.

4. Run Targeted Unit Tests (LangChain Agent)

   The Interface Agent now invokes the Unit Test Runner Agent, also built with LangChain.

   • It selects the appropriate test files based on the code diffs.
   • It executes the relevant tests using a Python test runner.
   • It captures the results — including failures, errors, and assertions.

   This makes the testing process modular, scalable, and accurate only the necessary tests are run.

Watch the Demo

Without Coral, you’d have to manually integrate LangChain, CAMEL-AI, and CrewAI agents using APIs, callbacks, or wrappers. But here, they operate independently and plug into a single shared protocol. You can swap or reuse agents across projects, scale them out, or replace them without breaking the pipeline.

This example proves that Coral isn’t just theoretical it can power real-world, cross-framework workflows for developers.

Voice-Controlled Multi-Agent System Use Case

This guide showcases a real-world multi-agent use case where a user gives a voice command, and three independent agents collaborate to complete a task: analysing spreadsheet data and emailing the results. Each agent runs on a different framework and communicates using Coral Protocol.

The entire process from voice input to analysis to automated email happens through one persistent Coral Communication Thread.

Here is what happens:

1. Clone Repos & Start Agents

   Start the Coral Server and all 3 agents:

   • Voice Interface Agent
   • Pandas AI Agent
   • ACI Dev Agent

   Make sure each agent is properly registered and running.

2. Speak Your Instruction

   The user gives a voice command:

   “Can you ask the Pandas agent to describe the columns in the Titanic dataset?”

   The Voice Interface Agent, built on LiveKit, captures the audio, converts it to text, and sends it into a Coral Communication Thread.

3. Dataset Analysis

   Coral routes the request to the Pandas AI Agent, built with LangChain.

   This agent:

   • Parses the command
   • Loads the Titanic dataset
   • Returns a list of all columns, including:
     Passenger ID, Survival status, Ticket class, Name, Sex, Age, Number of siblings/spouses aboard, etc.

   This response is structured and posted into the same thread.

4. Email the Results

   The user gives a follow-up command:

   “Ask the ACI Dev Agent to email this info to ******@gmail.com.”

   Coral picks this up and routes it to the ACI Dev Agent, built with Pydantic AI.

   This agent:

   • Receives the structured summary
   • Composes an email with the content
   • Sends it to the specified address using an integrated Gmail API

   All without any human handoff.

5. Final Output

   The column summary is extracted
   The email is sent automatically
   All agent messages and interactions are recorded inside a single Coral thread

   This proves that:

   • Voice inputs can trigger multi-agent workflows
   • Agents across frameworks (LangChain, Pydantic AI, LiveKit) can collaborate
   • Coral Protocol handles routing, delegation, and state — no glue logic needed

Watch the Demo

In a typical system, you’d need to manually integrate speech-to-text, data parsing, and email APIs each using a different SDK or library.

With Coral:

• Each function is handled by a specialised agent
• Agents can be reused across projects
• You can swap out the email agent or data agent without breaking the system

This is composable AI in practice the kind Coral Protocol is designed to enable.