Manage AI Teams & Agent Delegation: Building Your Collaborative AI Workforce

Learn how to create and manage teams of AI agents in Portal One, enabling them to collaborate and delegate tasks for sophisticated automation and improved performance.

(Think of it like: Building and managing a team of specialized digital employees who can pass tasks to each other.)

As your AI automation needs grow, you'll encounter tasks that are too complex or multifaceted for a single agent to handle efficiently. Portal One's AI Teams and Agent Delegation capabilities allow you to construct a collaborative workforce of specialized AI agents. This approach not only enables you to tackle more sophisticated projects but also enhances performance and modularity.

Why Use AI Teams & Agent Delegation?

Creating teams of agents offers several key advantages:

• Manage Complexity & Boost Performance: As an agent's responsibilities, toolset, and memory grow, its performance can degrade. Dividing tasks among multiple, specialized agents keeps each one focused and efficient.
• Enhanced Specialization: Each agent in a team can be given highly specific instructions and tools tailored to its unique role (e.g., a research specialist, a data analyst, a content writer). This leads to more accurate and effective task execution.
• Modularity and Reusability: Specialized agents can be reused across different teams and workflows. If you create a highly effective "Google Search Specialist" agent, it can be a valuable contact for multiple Lead Agents.
• Structured Workflows: Complex processes can be broken down into a logical sequence of tasks handled by different agents, creating a clear and manageable workflow.

How It Works: The Core Mechanics

Understanding how teams and delegation function in Portal One is key to leveraging their power:

1. Lead Agents and Contact Agents:
   • An AI Team is formed when one agent (the "Lead Agent") has other agents assigned to it as "Contacts."
   • The Lead Agent is responsible for the overall goal and orchestrates the workflow, delegating specific sub-tasks to its Contact Agents.
   • Contact Agents are specialists, designed and instructed to perform a particular function.
2. Automatic Tool Creation for Delegation:
   • When you add an agent (e.g., "Data Miner") as a Contact to a Lead Agent (e.g., "Research Lead"), Portal One automatically creates a new tool for the Lead Agent. This tool will be named hey_data_miner.
   • The Lead Agent can then use this hey_data_miner tool to send a notification to the Data Miner agent who then joins the conversation.
3. The Delegation Flow:
   • The Lead Agent (Agent A) receives or determines a task.
   • Based on its instructions, Agent A decides to delegate a part of this task. It uses the hey_agent_b tool to ping Agent B, passing along necessary information and instructions for Agent B.
   • Agent B is then enqueued and processes its assigned sub-task.
   • Upon completion, Agent B generates a response.
   • Agent A is automatically re-enqueued and receives Agent B's response. It can then continue its main task, incorporating Agent B's output.
   • This process can be nested: Agent B might delegate to Agent C, and the responses will flow back up the chain (C to B, then B to A).
   • Error Handling: If a Contact Agent (Agent B) fails to complete its task, it will state this in its response. The Lead Agent (Agent A) can then be instructed on how to adapt to this failure, perhaps by trying a different approach or notifying a user.

Example Use Case: The Automated Research Team

To see these concepts in action, imagine creating a "Chief Researcher" Lead Agent. Its goal is to produce comprehensive research reports.

1. You first design and test specialist agents:
   • Info Gatherer: Expert at broad topic discovery.
     • This agent might itself have Contacts: Google Search Pro (uses Google search tool) and Perplexity Search Pro (uses a Perplexity AI search tool).
   • Report Writer: Expert at structuring and writing reports.
     • This agent might have a Contact: Docu Gen Agent (has a tool to save text to Google Docs).
   • Fact Checker Editor: Expert at verifying information and ensuring adherence to style guides.
2. In Portal One, you add Info Gatherer, Report Writer, and Fact Checker Editor as Contacts to your Chief Researcher Lead Agent. This automatically provides Chief Researcher with hey_info_gatherer, hey_report_writer, and hey_fact_checker_editor tools.
3. You instruct Chief Researcher (perhaps via an SOP in a Memory file – a file where persistent instructions or information for an agent are stored) to:
   • First, delegate to Info Gatherer to find all relevant data.
   • Then, pass that data to Report Writer to draft the report.
   • Finally, have Fact Checker Editor review and polish the draft before Chief Researcher presents the final output.

This multi-layer delegation allows for highly specialized and robust automated workflows, managed by the Chief Researcher.

Setting Up Your AI Team: A Step-by-Step Guide

Building effective AI teams is an iterative process. It's generally best to create and thoroughly test each specialist agent individually before integrating them into a team structure.

Step 1: Create Your Specialist Agent(s)

• Design each agent to perform a specific, well-defined task (e.g., an agent that only searches Google, an agent that only drafts emails, an agent that uses a specific API).
• Provide clear, concise instructions in their primary prompt or through attached Memories.
• Equip them with any necessary tools (other than delegation tools, which are added later).
• Crucially, test each specialist agent in isolation to ensure it performs its task reliably and to a high standard.

Step 2: Create Your Lead Agent

• This agent will be the orchestrator. Define its overall objective.
• Its initial instructions should focus on the main goal and how it might break down the problem.

Step 3: Add Specialist Agents as Contacts to the Lead Agent

• Navigate to your Lead Agent's configuration.
• In the "Config" tab, find the "Contacts" section.
• Add your previously created specialist agents as Contacts.
• Remember, adding a Contact automatically creates the corresponding hey_<contact_agent_name> tool for the Lead Agent.

Step 4: Instruct the Lead Agent on How to Delegate
This is where you define the team's workflow. You have two main approaches:

• LLM-Driven Delegation: Within the Lead Agent's main instructions, you can describe the expertise of its Contact Agents and guide the LLM to decide when to use them. For example: "If you need to find current stock prices, use the hey_stock_ticker_agent tool. If you need to summarize a long document, use the hey_summarizer_agent tool."
• Standard Operating Procedure (SOP) with Memory: For more explicit control, create a Memory attached to the Lead Agent that outlines a step-by-step program. Here's an example SOP Memory snippet for a Lead Agent tasked with creating a market research report (this would be placed in a Memory attached to the Lead Agent):
  • Your task is to write a market research report. Follow these steps:
    1. Use the hey_data_gatherer tool to collect recent articles on topic X.
    2. Once you have the articles, use the hey_key_point_extractor tool to get bullet points from each article.
    3. Then, use the hey_draft_writer tool to create a first draft of the report using these key points.
    4. Finally, use the hey_proofreader tool to check the draft for errors before presenting it.

Step 5: Test and Iterate as a Team

• Initiate a task with the Lead Agent.
• Observe the delegation process. Does it follow your intended logic?
• Are the responses from Contact Agents being used effectively by the Lead Agent?
• Refine the instructions for the Lead Agent and/or the specialist agents as needed. If a specialist agent isn't performing well when called by the Lead Agent, you might need to adjust its standalone instructions or the way the Lead Agent is prompting it.

Best Practices for AI Teams

To get the most out of AI Teams and Agent Delegation, keep these key principles in mind:

• Start Simple: Begin with a two-agent team (one Lead Agent, one Contact Agent) before building more complex hierarchies. Master the basics first.
• Iterative Development: Build and test each agent individually before adding it to a team. Test the team at each new integration to catch issues early.
• Clear Instructions are Key: The more precise your instructions (for both Lead and Contact Agents), the better the team will perform. Ambiguity is the enemy of effective delegation.
• Descriptive Naming: Use clear and descriptive names for your agents so you can easily understand team structures and delegation tools (e.g., hey_data_validation_agent is clearer than hey_agent3).

Common Pitfalls to Avoid

When first setting up AI teams, users sometimes encounter these challenges:

• Vague Instructions: If the Lead Agent's instructions on when and how to delegate are unclear, or if a specialist Contact Agent's task isn't well-defined, the team may not function as expected.
• Overly Complex Initial Setup: Avoid creating deeply nested multi-agent teams before ensuring that simpler, two-agent delegations work perfectly.
• Skipping Individual Agent Testing: If a specialist agent doesn't work correctly on its own, it won't work correctly as part of a team. Always test agents in isolation first.
• Misunderstanding Information Flow: Ensure you understand how information (data, instructions) is passed from the Lead Agent to the Contact Agent and how the Contact Agent's response is returned and used.

Troubleshooting Team Workflows

• Isolate the Issue: If a team workflow fails, try testing each agent's part individually. Can the specialist Contact Agent perform its task correctly when invoked directly (not via delegation)?
• Check Lead Agent Instructions: Review the Lead Agent's prompt and any SOPs in its Memory files. Is it attempting to call the correct Contact Agent with the correct information?
• Verify Tool Creation and Availability: After adding a Contact, confirm that the hey_<contact_agent_name> tool has been automatically created and appears in the Lead Agent's prompt. You can find the message generation info panel by clicking the 'i' icon below the message in the chat view.
• Examine Agent Logs/History: Review the interaction history or logs for each involved agent to see the exact messages and tool calls being made. This can reveal where the process is breaking down.

Conclusion

AI Teams and Agent Delegation transform your Portal One agents from solo workers into a coordinated, powerful workforce. By strategically dividing labor and leveraging specialized skills, you can automate increasingly complex processes, improve the quality of AI outputs, and build more resilient and adaptable automation solutions.