How to Build a Manager-Worker Multi-Agent System

With the advent of increasingly powerful Large Language Models (LLMs), multi-agent systems are becoming more relevant and are expected to be particularly valuable in scenarios requiring high-levels of autonomy and/or processing of diverse sources of information.

There are various types of multi-agent systems, each serving different purposes and applications. Some notable examples include hierarchical structures, agent swarms, and mixtures of agents.

A hierarchical multi-agent system (also known as manager-worker or orchestrator-worker pattern) is a multi-agent pattern in which a central manager coordinates one or more worker agents by assigning tasks, and aggregating results.

When to use the Manager-Worker pattern?

Manager-Worker pattern is particularly suitable when tasks can be decomposed into specialized subtasks that benefit from dedicated agents with distinct expertise or tools. Compared to the Swarm pattern, the manager-worker pattern provides centralized coordination and explicit control flow between agents, making it more effective for workflows that require maintaining global context and aggregated results.

In the hierarchical pattern, a route User → Manager → Worker → Manager → User will require:

• The manager to analyze the user request and decide which worker agent should handle it.

• The selected worker agent to process the assigned subtask.

• The worker to return its output to the manager.

• The manager to consolidate and deliver the final response back to the user.

---

This guide demonstrates an example of a hierarchical multi-agent system for customer service automation, where a Customer Service Manager agent manages a team of two specialized agents — the Refund Specialist for processing refunds and the Satisfaction Surveyor for collecting feedback.

It will walk you through the following steps:

1. Define the configuration of an LLM model

2. Define expert agents equipped with tools

3. Define a manager agent

4. Define a ManagerWorkers of the defined agents

Basic implementation

1. Define the LLM model

The decision mechanism of Agents is powered by a Large Language Model. Defining the agent with Agent Spec requires to pass the configuration for the LLM. There are several options such as using OCI GenAI Service or self hosting a model with vLLM.

Start by defining the LLM configuration to be shared across all agents.

OCI GenAIvLLMOllama

from pyagentspec.llms import OciGenAiConfig
from pyagentspec.llms.ociclientconfig import OciClientConfigWithApiKey

client_config = OciClientConfigWithApiKey(
    name="Oci Client Config",
    service_endpoint="https://url-to-service-endpoint.com",
    auth_profile="DEFAULT",
    auth_file_location="~/.oci/config"
)

llm_config = OciGenAiConfig(
    name="Oci GenAI Config",
    model_id="provider.model-id",
    compartment_id="compartment-id",
    client_config=client_config,
)

2. Define expert agents

Refund specialist agent

The refund specialist agent is equipped with two tools.

from pyagentspec.property import (
    BooleanProperty,
    StringProperty,
    NumberProperty,
    DictProperty,
    UnionProperty,
    IntegerProperty,
    NullProperty,
)
from pyagentspec.tools import ServerTool

check_refund_eligibility = ServerTool(
    name="Check refund eligibility",
    description="Checks if a given order is eligible for a refund based on company policy.",
    inputs=[StringProperty(title="order_id"), StringProperty(title="customer_id")],
    outputs=[
        DictProperty(
            title="refund_eligibility",
            value_type=UnionProperty(
                any_of=[BooleanProperty(), NumberProperty(), StringProperty()]
            ),
        )
    ],
)

process_refund = ServerTool(
    name="Process refund",
    description="Processes a refund for a specific order and amount.",
    inputs=[
        StringProperty(title="order_id"),
        NumberProperty(title="amount"),
        StringProperty(title="reason"),
    ],
    outputs=[
        DictProperty(
            title="refund_status",
            value_type=UnionProperty(any_of=[StringProperty(), BooleanProperty()]),
        )
    ],
)

API Reference: ServerTool

The first tool is used to check whether a given order is eligible for a refund, while the second is used to process the specific refund.

Note

To require user confirmation for a tool, set requires_confirmation=True (see Tool). This signals that execution environments should require user approval before running the tool, which is useful for tools performing sensitive actions.

The system prompt is defined as follows:

REFUND_SPECIALIST_SYSTEM_PROMPT = """
You are a Refund Specialist agent whose objective is to process customer refund requests accurately and efficiently based on company policy.

# Instructions
- Receive the refund request details (e.g., order ID, customer ID, reason) from the 'CustomerServiceManager'.
- Use the `check_refund_eligibility` tool to verify if the request meets the refund policy criteria using the provided order and customer IDs.
- If the check indicates eligibility, determine the correct refund amount (up to the maximum allowed from the eligibility check).
- If eligible, use the `process_refund` tool to execute the refund for the determined amount, providing order ID and reason.
- If ineligible based on the check, clearly note the reason provided by the tool.
- Report the final outcome (e.g., "Refund processed successfully, Refund ID: [ID], Amount: [Amount]", or "Refund denied: [Reason from eligibility check]") back to the 'CustomerServiceManager'.
- Do not engage in general conversation; focus solely on the refund process.
""".strip()

Building the agent:

from pyagentspec.agent import Agent

refund_specialist_agent = Agent(
    name="RefundSpecialist",
    description="Specializes in processing customer refund requests by verifying eligibility and executing the refund transaction using available tools.",
    llm_config=llm_config,
    system_prompt=REFUND_SPECIALIST_SYSTEM_PROMPT,
    tools=[check_refund_eligibility, process_refund],
)

API Reference: Agent

Statisfaction surveyor agent

The statisfaction surveyor agent is equipped with one tool.

record_survey_response = ServerTool(
    name="Record survey response",
    description="Records the customer's satisfaction survey response.",
    inputs=[
        StringProperty(title="customer_id"),
        UnionProperty(
            title="satisfaction_score",
            any_of=[IntegerProperty(), NullProperty()],
            default=None,
        ),
        UnionProperty(
            title="comments",
            any_of=[StringProperty(), NullProperty()],
            default=None,
        ),
    ],
    outputs=[
        DictProperty(
            title="recording_status",
            value_type=UnionProperty(any_of=[BooleanProperty(), StringProperty()]),
        )
    ],
)

The record_survey_response tool is simulating the recording of user feedback data.

System prompt:

SURVEYOR_SYSTEM_PROMPT = """
You are a Satisfaction Surveyor agent tasked with collecting customer feedback about their recent service experience in a friendly manner.

# Instructions
- Receive the trigger to conduct a survey from the 'CustomerServiceManager', including context like the customer ID and the nature of the interaction if provided.
- Politely ask the customer if they have a moment to provide feedback on their recent interaction.
- If the customer agrees, ask 1-2 concise questions about their satisfaction (e.g., "On a scale of 1 to 5, where 5 is highly satisfied, how satisfied were you with the resolution provided today?", "Is there anything else you'd like to share about your experience?").
- Use the `record_survey_response` tool to log the customer's feedback, including the satisfaction score and any comments provided. Ensure you pass the correct customer ID.
- If the customer declines to participate, thank them for their time anyway. Do not pressure them. Use the `record_survey_response` tool to log the declination if possible (e.g., score=None, comments="Declined survey").
- Thank the customer for their participation if they provided feedback.
- Report back to the 'CustomerServiceManager' confirming that the survey was attempted and whether it was completed or declined.
""".strip()

Building the agent:

surveyor_agent = Agent(
    name="SatisfactionSurveyor",
    description="Conducts brief surveys to gather feedback on customer satisfaction following service interactions.",
    llm_config=llm_config,
    system_prompt=SURVEYOR_SYSTEM_PROMPT,
    tools=[record_survey_response],
)

3. Define the manager agent

In the built-in ManagerWorkers component, we allow passing an Agent as the group manager. Therefore, we just need to define an agent as usual.

In this example, our manager agent will be a Customer Service Manager.

System prompt:

MANAGER_SYSTEM_PROMPT = """
You are a Customer Service Manager agent tasked with handling incoming customer interactions and orchestrating the resolution process efficiently.

# Instructions
- Greet the customer politely and acknowledge their message.
- Analyze the customer's message to understand their core need (e.g., refund request, general query, feedback).
- Answer common informational questions (e.g., about shipping times, return policy basics) directly if you have the knowledge, before delegating.
- If the request is clearly about a refund, gather necessary details (like Order ID) if missing, and then assign the task to the 'RefundSpecialist' agent. Provide all relevant context.
- If the interaction seems successfully concluded (e.g., refund processed, query answered) and requesting feedback is appropriate, assign the task to the 'SatisfactionSurveyor' agent. Provide customer context.
- For general queries you cannot handle directly and that don't fit the specialist agents, state your limitations clearly and politely.
- Await responses or status updates from specialist agents you have assigned to.
- Summarize the final outcome or confirmation for the customer based on specialist agent reports.
- Maintain a helpful, empathetic, and professional tone throughout the interaction.

# Additional Context
Customer ID: {{customer_id}}
Company policies: {{company_policy_info}}
""".strip()

Building the agent:

customer_service_manager = Agent(
    name="CustomerServiceManager",
    description="Acts as the primary contact point for customer inquiries, analyzes the request, routes tasks to specialized agents (Refund Specialist, Satisfaction Surveyor), and ensures resolution.",
    llm_config=llm_config,
    system_prompt=MANAGER_SYSTEM_PROMPT,
)

4. Define the ManagerWorkers of Agents

from pyagentspec.managerworkers import ManagerWorkers

assistant = ManagerWorkers(
    name="managerworkers",
    group_manager=customer_service_manager,
    workers=[refund_specialist_agent, surveyor_agent],
)

API Reference: ManagerWorkers

The ManagerWorkers has two main parameters:

• group_manager The agent that is used as the group manager, responsible for coordinating and assigning tasks to the workers.

• workers - List of agents These agents serve as the workers within the group and are coordinated by the manager agent.

  • Worker agents cannot interact with the end user directly.

  • When invoked, each worker can leverage its equipped tools to complete the assigned task and report the result back to the group manager.

Agent Spec Serialization

You can export the assistant configuration using the AgentSpecSerializer.

from pyagentspec.serialization import AgentSpecSerializer

serialized_assistant = AgentSpecSerializer().to_json(assistant)

# you can print the serialized form or save it to a file
print(serialized_assistant)

Here is what the Agent Spec representation will look like ↓

Click here to see the assistant configuration.

JSONYAML

{
    "component_type": "ManagerWorkers",
    "id": "4d3a0013-284f-4ec9-82e2-6e081eca7e39",
    "name": "managerworkers",
    "description": null,
    "metadata": {},
    "inputs": [],
    "outputs": [],
    "group_manager": {
        "component_type": "Agent",
        "id": "d78cbb31-9961-4f1a-ab63-75bed2920547",
        "name": "CustomerServiceManager",
        "description": "Acts as the primary contact point for customer inquiries, analyzes the request, routes tasks to specialized agents (Refund Specialist, Satisfaction Surveyor), and ensures resolution.",
        "metadata": {},
        "inputs": [
            {
                "title": "customer_id",
                "type": "string"
            },
            {
                "title": "company_policy_info",
                "type": "string"
            }
        ],
        "outputs": [],
        "llm_config": {
            "$component_ref": "2154580d-d991-4df9-9888-e4b69eea6922"
        },
        "system_prompt": "You are a Customer Service Manager agent tasked with handling incoming customer interactions and orchestrating the resolution process efficiently.\n\n# Instructions\n- Greet the customer politely and acknowledge their message.\n- Analyze the customer's message to understand their core need (e.g., refund request, general query, feedback).\n- Answer common informational questions (e.g., about shipping times, return policy basics) directly if you have the knowledge, before delegating.\n- If the request is clearly about a refund, gather necessary details (like Order ID) if missing, and then assign the task to the 'RefundSpecialist' agent. Provide all relevant context.\n- If the interaction seems successfully concluded (e.g., refund processed, query answered) and requesting feedback is appropriate, assign the task to the 'SatisfactionSurveyor' agent. Provide customer context.\n- For general queries you cannot handle directly and that don't fit the specialist agents, state your limitations clearly and politely.\n- Await responses or status updates from specialist agents you have assigned to.\n- Summarize the final outcome or confirmation for the customer based on specialist agent reports.\n- Maintain a helpful, empathetic, and professional tone throughout the interaction.\n\n# Additional Context\nCustomer ID: {{customer_id}}\nCompany policies: {{company_policy_info}}",
        "tools": [],
        "toolboxes": [],
        "human_in_the_loop": true
    },
    "workers": [
        {
            "component_type": "Agent",
            "id": "e455c3c6-bded-454c-8315-559c3e617ae1",
            "name": "RefundSpecialist",
            "description": "Specializes in processing customer refund requests by verifying eligibility and executing the refund transaction using available tools.",
            "metadata": {},
            "inputs": [],
            "outputs": [],
            "llm_config": {
                "$component_ref": "2154580d-d991-4df9-9888-e4b69eea6922"
            },
            "system_prompt": "You are a Refund Specialist agent whose objective is to process customer refund requests accurately and efficiently based on company policy.\n\n# Instructions\n- Receive the refund request details (e.g., order ID, customer ID, reason) from the 'CustomerServiceManager'.\n- Use the `check_refund_eligibility` tool to verify if the request meets the refund policy criteria using the provided order and customer IDs.\n- If the check indicates eligibility, determine the correct refund amount (up to the maximum allowed from the eligibility check).\n- If eligible, use the `process_refund` tool to execute the refund for the determined amount, providing order ID and reason.\n- If ineligible based on the check, clearly note the reason provided by the tool.\n- Report the final outcome (e.g., \"Refund processed successfully, Refund ID: [ID], Amount: [Amount]\", or \"Refund denied: [Reason from eligibility check]\") back to the 'CustomerServiceManager'.\n- Do not engage in general conversation; focus solely on the refund process.",
            "tools": [
                {
                    "component_type": "ServerTool",
                    "id": "ce0731ff-1dc3-4832-bcae-d5209f2f17bd",
                    "name": "Check refund eligibility",
                    "description": "Checks if a given order is eligible for a refund based on company policy.",
                    "metadata": {},
                    "inputs": [
                        {
                            "title": "order_id",
                            "type": "string"
                        },
                        {
                            "title": "customer_id",
                            "type": "string"
                        }
                    ],
                    "outputs": [
                        {
                            "title": "refund_eligibility",
                            "additionalProperties": {
                                "anyOf": [
                                    {
                                        "type": "boolean"
                                    },
                                    {
                                        "type": "number"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            },
                            "properties": {},
                            "type": "object"
                        }
                    ]
                },
                {
                    "component_type": "ServerTool",
                    "id": "cfb441a2-647d-45ce-8a46-f7773d17dd85",
                    "name": "Process refund",
                    "description": "Processes a refund for a specific order and amount.",
                    "metadata": {},
                    "inputs": [
                        {
                            "title": "order_id",
                            "type": "string"
                        },
                        {
                            "title": "amount",
                            "type": "number"
                        },
                        {
                            "title": "reason",
                            "type": "string"
                        }
                    ],
                    "outputs": [
                        {
                            "title": "refund_status",
                            "additionalProperties": {
                                "anyOf": [
                                    {
                                        "type": "string"
                                    },
                                    {
                                        "type": "boolean"
                                    }
                                ]
                            },
                            "properties": {},
                            "type": "object"
                        }
                    ]
                }
            ],
            "toolboxes": [],
            "human_in_the_loop": true
        },
        {
            "component_type": "Agent",
            "id": "c048a72d-da2a-4288-b3c6-d5af7c1b5bd6",
            "name": "SatisfactionSurveyor",
            "description": "Conducts brief surveys to gather feedback on customer satisfaction following service interactions.",
            "metadata": {},
            "inputs": [],
            "outputs": [],
            "llm_config": {
                "$component_ref": "2154580d-d991-4df9-9888-e4b69eea6922"
            },
            "system_prompt": "You are a Satisfaction Surveyor agent tasked with collecting customer feedback about their recent service experience in a friendly manner.\n\n# Instructions\n- Receive the trigger to conduct a survey from the 'CustomerServiceManager', including context like the customer ID and the nature of the interaction if provided.\n- Politely ask the customer if they have a moment to provide feedback on their recent interaction.\n- If the customer agrees, ask 1-2 concise questions about their satisfaction (e.g., \"On a scale of 1 to 5, where 5 is highly satisfied, how satisfied were you with the resolution provided today?\", \"Is there anything else you'd like to share about your experience?\").\n- Use the `record_survey_response` tool to log the customer's feedback, including the satisfaction score and any comments provided. Ensure you pass the correct customer ID.\n- If the customer declines to participate, thank them for their time anyway. Do not pressure them. Use the `record_survey_response` tool to log the declination if possible (e.g., score=None, comments=\"Declined survey\").\n- Thank the customer for their participation if they provided feedback.\n- Report back to the 'CustomerServiceManager' confirming that the survey was attempted and whether it was completed or declined.",
            "tools": [
                {
                    "component_type": "ServerTool",
                    "id": "0db02ef0-4e9c-426b-8005-69b813dd32e9",
                    "name": "Record survey response",
                    "description": "Records the customer's satisfaction survey response.",
                    "metadata": {},
                    "inputs": [
                        {
                            "title": "customer_id",
                            "type": "string"
                        },
                        {
                            "title": "satisfaction_score",
                            "default": null,
                            "anyOf": [
                                {
                                    "type": "integer"
                                },
                                {
                                    "type": "null"
                                }
                            ]
                        },
                        {
                            "title": "comments",
                            "default": null,
                            "anyOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "null"
                                }
                            ]
                        }
                    ],
                    "outputs": [
                        {
                            "title": "recording_status",
                            "additionalProperties": {
                                "anyOf": [
                                    {
                                        "type": "boolean"
                                    },
                                    {
                                        "type": "string"
                                    }
                                ]
                            },
                            "properties": {},
                            "type": "object"
                        }
                    ]
                }
            ],
            "toolboxes": [],
            "human_in_the_loop": true
        }
    ],
    "$referenced_components": {
        "2154580d-d991-4df9-9888-e4b69eea6922": {
            "component_type": "VllmConfig",
            "id": "2154580d-d991-4df9-9888-e4b69eea6922",
            "name": "vllm-llama-4-maverick",
            "description": null,
            "metadata": {},
            "default_generation_parameters": null,
            "url": "http://url.to.my.vllm.server/llama4mav",
            "model_id": "llama-4-maverick"
        }
    },
    "agentspec_version": "25.4.2"
}

Recap

This guide covered how to define a manager-workers of agents in Agent Spec.

Below is the complete code from this guide.

# Copyright © 2025 Oracle and/or its affiliates.
#
# This software is under the Apache License 2.0
# (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0) or Universal Permissive License
# (UPL) 1.0 (LICENSE-UPL or https://oss.oracle.com/licenses/upl), at your option.
# isort:skip_file
# mypy: ignore-errors

# .. start-##_Define_the_LLM
from pyagentspec.llms import VllmConfig

llm_config = VllmConfig(
    name="vllm-llama-4-maverick",
    model_id="llama-4-maverick",
    url="http://url.to.my.vllm.server/llama4mav",
)
# .. end-##_Define_the_LLM

# .. start-##_Specialist_tools
from pyagentspec.property import (
    BooleanProperty,
    StringProperty,
    NumberProperty,
    DictProperty,
    UnionProperty,
    IntegerProperty,
    NullProperty,
)
from pyagentspec.tools import ServerTool

check_refund_eligibility = ServerTool(
    name="Check refund eligibility",
    description="Checks if a given order is eligible for a refund based on company policy.",
    inputs=[StringProperty(title="order_id"), StringProperty(title="customer_id")],
    outputs=[
        DictProperty(
            title="refund_eligibility",
            value_type=UnionProperty(
                any_of=[BooleanProperty(), NumberProperty(), StringProperty()]
            ),
        )
    ],
)

process_refund = ServerTool(
    name="Process refund",
    description="Processes a refund for a specific order and amount.",
    inputs=[
        StringProperty(title="order_id"),
        NumberProperty(title="amount"),
        StringProperty(title="reason"),
    ],
    outputs=[
        DictProperty(
            title="refund_status",
            value_type=UnionProperty(any_of=[StringProperty(), BooleanProperty()]),
        )
    ],
)

# .. end-##_Specialist_tools

# .. start-##_Specialist_prompt
REFUND_SPECIALIST_SYSTEM_PROMPT = """
You are a Refund Specialist agent whose objective is to process customer refund requests accurately and efficiently based on company policy.

# Instructions
- Receive the refund request details (e.g., order ID, customer ID, reason) from the 'CustomerServiceManager'.
- Use the `check_refund_eligibility` tool to verify if the request meets the refund policy criteria using the provided order and customer IDs.
- If the check indicates eligibility, determine the correct refund amount (up to the maximum allowed from the eligibility check).
- If eligible, use the `process_refund` tool to execute the refund for the determined amount, providing order ID and reason.
- If ineligible based on the check, clearly note the reason provided by the tool.
- Report the final outcome (e.g., "Refund processed successfully, Refund ID: [ID], Amount: [Amount]", or "Refund denied: [Reason from eligibility check]") back to the 'CustomerServiceManager'.
- Do not engage in general conversation; focus solely on the refund process.
""".strip()
# .. end-##_Specialist_prompt

# .. start-##_Specialist_agent
from pyagentspec.agent import Agent

refund_specialist_agent = Agent(
    name="RefundSpecialist",
    description="Specializes in processing customer refund requests by verifying eligibility and executing the refund transaction using available tools.",
    llm_config=llm_config,
    system_prompt=REFUND_SPECIALIST_SYSTEM_PROMPT,
    tools=[check_refund_eligibility, process_refund],
)
# .. end-##_Specialist_agent

# .. start-##_Surveyor_tools
record_survey_response = ServerTool(
    name="Record survey response",
    description="Records the customer's satisfaction survey response.",
    inputs=[
        StringProperty(title="customer_id"),
        UnionProperty(
            title="satisfaction_score",
            any_of=[IntegerProperty(), NullProperty()],
            default=None,
        ),
        UnionProperty(
            title="comments",
            any_of=[StringProperty(), NullProperty()],
            default=None,
        ),
    ],
    outputs=[
        DictProperty(
            title="recording_status",
            value_type=UnionProperty(any_of=[BooleanProperty(), StringProperty()]),
        )
    ],
)
# .. end-##_Surveyor_tools

# .. start-##_Surveyor_prompt
SURVEYOR_SYSTEM_PROMPT = """
You are a Satisfaction Surveyor agent tasked with collecting customer feedback about their recent service experience in a friendly manner.

# Instructions
- Receive the trigger to conduct a survey from the 'CustomerServiceManager', including context like the customer ID and the nature of the interaction if provided.
- Politely ask the customer if they have a moment to provide feedback on their recent interaction.
- If the customer agrees, ask 1-2 concise questions about their satisfaction (e.g., "On a scale of 1 to 5, where 5 is highly satisfied, how satisfied were you with the resolution provided today?", "Is there anything else you'd like to share about your experience?").
- Use the `record_survey_response` tool to log the customer's feedback, including the satisfaction score and any comments provided. Ensure you pass the correct customer ID.
- If the customer declines to participate, thank them for their time anyway. Do not pressure them. Use the `record_survey_response` tool to log the declination if possible (e.g., score=None, comments="Declined survey").
- Thank the customer for their participation if they provided feedback.
- Report back to the 'CustomerServiceManager' confirming that the survey was attempted and whether it was completed or declined.
""".strip()
# .. end-##_Surveyor_prompt

# .. start-##_Surveyor_agent
surveyor_agent = Agent(
    name="SatisfactionSurveyor",
    description="Conducts brief surveys to gather feedback on customer satisfaction following service interactions.",
    llm_config=llm_config,
    system_prompt=SURVEYOR_SYSTEM_PROMPT,
    tools=[record_survey_response],
)
# .. end-##_Surveyor_agent

# .. start-##_Manager_prompt
MANAGER_SYSTEM_PROMPT = """
You are a Customer Service Manager agent tasked with handling incoming customer interactions and orchestrating the resolution process efficiently.

# Instructions
- Greet the customer politely and acknowledge their message.
- Analyze the customer's message to understand their core need (e.g., refund request, general query, feedback).
- Answer common informational questions (e.g., about shipping times, return policy basics) directly if you have the knowledge, before delegating.
- If the request is clearly about a refund, gather necessary details (like Order ID) if missing, and then assign the task to the 'RefundSpecialist' agent. Provide all relevant context.
- If the interaction seems successfully concluded (e.g., refund processed, query answered) and requesting feedback is appropriate, assign the task to the 'SatisfactionSurveyor' agent. Provide customer context.
- For general queries you cannot handle directly and that don't fit the specialist agents, state your limitations clearly and politely.
- Await responses or status updates from specialist agents you have assigned to.
- Summarize the final outcome or confirmation for the customer based on specialist agent reports.
- Maintain a helpful, empathetic, and professional tone throughout the interaction.

# Additional Context
Customer ID: {{customer_id}}
Company policies: {{company_policy_info}}
""".strip()
# .. end-##_Manager_prompt

# .. start-##_Manager_agent
customer_service_manager = Agent(
    name="CustomerServiceManager",
    description="Acts as the primary contact point for customer inquiries, analyzes the request, routes tasks to specialized agents (Refund Specialist, Satisfaction Surveyor), and ensures resolution.",
    llm_config=llm_config,
    system_prompt=MANAGER_SYSTEM_PROMPT,
)
# .. end-##_Manager_agent

# .. start-##_Managerworkers_pattern
from pyagentspec.managerworkers import ManagerWorkers

assistant = ManagerWorkers(
    name="managerworkers",
    group_manager=customer_service_manager,
    workers=[refund_specialist_agent, surveyor_agent],
)
# .. end-##_Managerworkers_pattern

# .. start-##_Export_serialization
from pyagentspec.serialization import AgentSpecSerializer

serialized_assistant = AgentSpecSerializer().to_json(assistant)

# you can print the serialized form or save it to a file
print(serialized_assistant)
# .. end-##_Export_serialization

Next steps

Having learned how to define a manager-workers, you may now proceed to how to use the WayFlow runtime to execute it.