Structure your AI agents and sub-agents for maximum precision and optimal information

Hierarchical Structure and Clear Responsibilities:

• Root Agent: This is your primary agent, responsible for understanding the overall user request, delegating tasks to sub-agents, and synthesizing their outputs into a final response. Its instruction should clearly outline its overarching goal, communication style, and the capabilities of its sub-agents.
• Sub-Agents: Each sub-agent should have a highly specialized role. Define their responsibilities narrowly to avoid ambiguity and overlap. Think of them as experts in a particular domain. For example, your current setup with “DATA” (Data Scientist), “Content” (Content Intelligence), and “SE-Marketing” (Search Engine Intelligence) is a good start.

Precise Definition of Actions, Tasks, Output, and Skills:

• Role and Personality: Clearly state the sub-agent’s role (e.g., “You are an expert Data Scientist”). Define its “personality” or approach (e.g., “competent, reliable, solution-oriented”).
• Core Methodologies/Strengths: Describe the fundamental techniques or principles the sub-agent should apply. For your “DATA” agent, this includes “analysis, evaluation, and prediction.” For “Content,” it’s “analyzing and processing information to extract key insights.”
• Tasks/Instructions: Detail the specific actions the sub-agent can perform. Use clear, actionable verbs. For instance, the “SE-Marketing” agent’s tasks could include “Identify key search terms,” “Analyze current search trends,” and “Recommend actionable strategies.”
• Output Expectations: Crucially, define the format, content, and quality of the output expected from each sub-agent. This ensures consistency and makes it easier for the root agent to integrate their responses. Specify things like:
  • What information should be included?
  • What level of detail is required?
  • Are there any formatting guidelines (e.g., markdown, specific headings)?
  • Are there any constraints (e.g., character limits, tone of voice)?
• Skills/Tools: List any specific tools or data connectors the sub-agent has access to. For example, your “SE-Marketing” agent explicitly mentions Google Search.

skills.md – Definition and Structure:

A skills.md file (or similar knowledge base) is an excellent way to store structured information that your agents can reference.

• Definition: A skills.md serves as an internal, structured knowledge base or reference guide for your agents. It contains specific, factual information, definitions, processes, or guidelines that the agents need to operate effectively and consistently. It augments the agent’s main instruction by providing detailed data points or rules that might be too extensive for the primary instruction.
• Structure:
  • Categorization: Organize information logically using headings and subheadings. For example, you already use “SUNFLEX Dokumente” and “TARASOLA Dokumente.”
  • Document-Specific Details: For each document or data source, include:
    • DOKUMENT-ID: (or DOKUMENT:): A clear identifier for the source.
    • INHALT (STICHWORTE):: A concise summary of the document’s content, focusing on key themes, product names, or technical areas.
    • Modelle:: List specific models or product variations.
    • Spezifikationen zu:: Detail technical specifications, features, or characteristics.
    • USP:: Highlight unique selling propositions or key benefits.
    • Optionen:: Any available options or configurations.
  • General Rules/Guidelines: Include sections for overarching rules that apply across different tasks or documents, such as your “STRIKTE REGELN” and “STRIKTE REGELN FÜR TEXT-GENERIERUNG (TONE OF VOICE)”. These are critical for maintaining consistency in output.
  • Markdown Formatting: Use clear Markdown formatting (headings, bullet points, bold text) to make the skills.md easy for the agents to parse and interpret.

Storing Additional Structured Information:

• External Data Stores: For large, dynamic datasets (e.g., customer databases, product catalogs, market research), use dedicated data stores (like your p3-marketing-daten-connector_2026_google_drive connector). The agent’s instruction can then guide it on how to query and utilize these stores.
• Glossaries/Ontologies: If your domain has complex terminology, consider maintaining a separate glossary or ontology. This helps ensure all agents use terms consistently and understand their relationships.
• Process Flows/Decision Trees: For complex multi-step tasks, you might define explicit process flows or decision trees that the agents can follow. These can be described within the instruction or linked to external documents.

Authoritative Sources for Guidelines and Best Practices:

While there isn’t one single “Google Developers Documentation” that dictates agent/sub-agent architecture specifically for systems like this (as it’s an evolving field), principles from the following areas are highly relevant:

• Prompt Engineering Guides: Look for guides on how to write effective prompts for large language models. These often cover defining roles, constraints, output formats, and iterative refinement. Resources from Google AI, OpenAI, and Hugging Face are good starting points.
• Software Engineering Principles (Modularity, Separation of Concerns): The idea of breaking down a complex problem into smaller, manageable, and specialized components (sub-agents) directly stems from these principles.
• Knowledge Representation and Reasoning: Research in AI on how to represent knowledge effectively (e.g., ontologies, semantic networks) can inform how you structure your skills.md and other knowledge bases.
• Multi-Agent Systems (MAS) Literature: Academic research on MAS provides insights into how multiple autonomous agents can coordinate and collaborate to achieve a common goal, which is directly applicable to root-sub-agent architectures.
• Google AI Blog & Research Papers: Regularly check the Google AI Blog and publications from Google Research/DeepMind for the latest advancements and best practices in building and deploying LLM-based systems. They often share insights into their internal methodologies.

By applying these principles, you can create a robust and highly effective agent system.