## Workflow Diagram: Training and Executing Processes ### Overview The image presents a workflow diagram illustrating both the training and executing processes of a system designed to handle complex queries, specifically in the context of planning a trip. The diagram is divided into two main sections: (a) Training process and (b) Executing process. Each section outlines the steps involved, from initial input to final output, using various tools and techniques. ### Components/Axes **Section (a): Training Process** * **Multi Tools:** A list of tools labeled "Tool_1: Description1", "Tool_2: Description1", ..., "Tooln_: Description1". * **Workflow Generation:** The process of creating a workflow from the multi tools. * **Candidate Tools DAG:** A directed acyclic graph (DAG) representing tasks. Nodes are numbered 1 through 7, with "Task" at the top and "Finish" at the bottom. * **Query Reverse-Engineering:** The process of analyzing the DAG. * **Complex Query:** A query that requires multiple steps to resolve. * **Intent Analysis and Re-planning:** The process of analyzing the intent of the query and re-planning the workflow. * **New DAG:** A new DAG, similar to the first, but with nodes numbered 1 through 8. * **Training Dataset:** A dataset used for training the system. * **Filter:** The process of filtering the training dataset. * **Fine-tuning:** The process of fine-tuning the system using the filtered dataset. * **GRPO:** An acronym, likely referring to a specific algorithm or process. Represented by two robot icons. **Section (b): Executing Process** * **Query:** A user query, specifically: "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." * **Candidate Tools:** A collection of tools represented by icons, including Google (G), a map pin, an airplane, a yen symbol (¥), a hotel icon, and an email icon. * **Planning:** The initial stage of the execution process. * **find_city:** A function to find a city. * **get_flights:** A function to get flight information. * **get_hotels:** A function to get hotel information. * **make_report:** A function to create a final plan and budget. * **Executing:** The stage where the plan is executed. * **Step 1:** "Use find_city to find a destination for hiking." * **Step 2:** "In parallel, use get_flights and get_hotels to find costs." * **Step 3:** "Use make_report to create a final plan and budget." * **Final answer:** The final output of the execution process, represented by a travel plan icon. ### Detailed Analysis or ### Content Details **Training Process (a):** 1. **Multi Tools** are used for **Workflow Generation**, resulting in a **Candidate Tools DAG**. 2. The DAG undergoes **Query Reverse-Engineering** to handle a **Complex Query**. 3. **Intent Analysis and Re-planning** leads to a **New DAG**. 4. The **Training Dataset** is **Filtered** and used for **Fine-tuning** via **GRPO**. **Executing Process (b):** 1. A **Query** is input into the system. 2. The system uses **Candidate Tools** to perform **Planning**. 3. The planning stage involves the functions: `find_city`, `get_flights`, `get_hotels`, and `make_report`. 4. The **Executing** stage consists of three steps: * Step 1: Use `find_city` to find a destination for hiking. * Step 2: In parallel, use `get_flights` and `get_hotels` to find costs. * Step 3: Use `make_report` to create a final plan and budget. 5. The final output is the **Final answer**. ### Key Observations * The training process focuses on creating and refining workflows based on complex queries. * The executing process demonstrates how a specific query is handled using a set of predefined tools and functions. * The DAGs in the training process represent the structure of tasks and their dependencies. * The GRPO component suggests an iterative refinement process. ### Interpretation The diagram illustrates a system designed to automate the process of answering complex queries, specifically in the domain of travel planning. The training process focuses on learning and optimizing workflows, while the executing process applies these workflows to specific user queries. The use of DAGs suggests a structured approach to task management and dependency resolution. The GRPO component likely plays a role in improving the system's performance over time through fine-tuning and re-planning. The parallel execution of `get_flights` and `get_hotels` indicates an attempt to optimize the execution time.

## Diagram: AI Agent Training and Execution Process ### Overview This image is a technical diagram illustrating a two-part process for an AI agent: (a) Training process and (b) Executing process. The diagram uses flowcharts, directed acyclic graphs (DAGs), and various icons to depict the stages of workflow generation, query processing, planning, and execution using a set of tools. ### Components/Axes The image is divided horizontally into two main sections, each representing a distinct process: **Section (a): Training process** (Upper half, predominantly light blue and light purple background) This section is labeled "(a) Training process" at the bottom-center of its boundary. It describes the system's learning phase. * **Workflow Generation Stage** (Leftmost, light blue background): * **Multi Tools** box (top-left): A rectangular box containing a list of generic tools. * Content: * "Tool_1: Description1" * "Tool_2: Description1" * "......" (ellipsis indicating more tools) * "Tooln_: Description1" * **Candidate Tools DAG** (center-left): A directed acyclic graph (DAG) representing a potential workflow. * Label: "Candidate Tools DAG: Task" (at the top) * Nodes: * Start Node: "Task" (light blue circle at the top) * Intermediate Nodes: Numbered circles 1, 2, 3, 4, 5, 6, 7 (light yellow circles) * End Node: "Finish" (light green circle at the bottom) * Edges (arrows indicating flow): Task -> 1, Task -> 2; 1 -> 3, 1 -> 4; 2 -> 4, 2 -> 5; 3 -> 6; 4 -> 6, 4 -> 7; 5 -> 7; 6 -> Finish, 7 -> Finish. * **Query Reverse-Engineering Stage** (Middle, light purple background): * **Complex Query & Candidate Tools** box (center): A rectangular box containing two sub-labels. * Content: "Complex Query" (top sub-box), "Candidate Tools" (bottom sub-box) * **Intent Analysis and Re-planning Stage** (Rightmost, light blue background): * **New DAG** (center-right): Another directed acyclic graph (DAG), representing a refined workflow. * Label: "New DAG: Task" (at the top) * Nodes: * Start Node: "Task" (light blue circle at the top) * Intermediate Nodes: Numbered circles 1, 2, 3, 4, 5, 6, 7, 8 (light yellow circles) * End Node: "Finish" (light green circle at the bottom) * Edges (arrows indicating flow): Task -> 1, Task -> 2; 1 -> 3, 1 -> 4; 2 -> 5, 2 -> 6; 3 -> 7; 4 -> 7, 4 -> 8; 5 -> 8; 6 -> 8; 7 -> Finish, 8 -> Finish. * **Training Dataset** box (top-right): A rectangular box. * Content: "Training Dataset" * **GRPO Agent Icons** (bottom-right): Two robot icons connected by an arrow. * Left Robot: Frowning face with red eyes. * Right Robot: Smiling face with blue eyes. * Text above arrow: "GRPO" **Section (b): Executing process** (Lower half, predominantly light yellow background) This section is labeled "(b) Executing process" at the bottom-center of its boundary. It describes how the trained system performs a task. * **Query & Candidate Tools Stage** (Leftmost, light yellow background): * **Query Icon & Text** (top-left): A circular icon of a person (green shirt) with a speech bubble next to it. * Label: "Query" (below the person icon) * Speech Bubble Content: "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." * **Candidate Tools Cloud** (bottom-left): A cloud-shaped area containing various tool icons. * Label: "Candidate Tools" (below the cloud) * Icons (from top-left to bottom-right): * Google Maps pin icon (red, yellow, blue, green) * Google 'G' logo (red, yellow, blue, green) * Document icon (blue, white) * Airplane icon (orange) * Airplane icon (green) * Money symbol (Yen/Yuan, blue) * Hospital/hotel building icon with a red heart (blue, white) * Envelope icon (blue, white) * **Planning Stage** (Middle, light yellow background): * Label: "Planning" (centered at the top of this stage) * **Planning DAG** (center): A directed acyclic graph (DAG) representing the specific plan for the query. * Nodes (icons with labels below): * Top: Google Maps pin icon, labeled "find_city" * Left: Green airplane icon, labeled "get_flights" * Right: Yellow hotel/stars icon, labeled "get_hotels" * Bottom: Blue money symbol, labeled "make_report" * Edges (arrows indicating flow): find_city -> get_flights; find_city -> get_hotels; get_flights -> make_report; get_hotels -> make_report. * **Executing Stage** (Rightmost, light yellow background): * Label: "Executing" (centered at the top of this stage) * **Execution Steps** (center-right): A rectangular box listing three numbered steps. * Step 1: "Step 1: Use **find_city** to find a destination for hiking." (Icon: magnifying glass over a map pin) * Step 2: "Step 2: In parallel, use **get_flights** and **get_hotels** to find costs." (Icon: two magnifying glasses over a map pin) * Step 3: "Step 3: Use **make_report** to create a final plan and budget." (Icon: document with numbered lines) * **Final Answer Icon** (bottom-right): An icon depicting a document with a pen. * Label: "Final answer" (below the icon) **Connecting Elements and Icons:** * **Gear/Brain Icon**: Represents a processing or generation step, seen between "Multi Tools" and "Candidate Tools DAG", and between "Complex Query" and "New DAG". * **Robot Icons**: Represent the AI agent. A frowning robot is fine-tuned into a smiling robot during training. A smiling robot processes the query in the execution phase. * **Arrows**: Indicate the direction of flow or data transformation between components. ### Detailed Analysis **Section (a) Training process:** The training process begins with a collection of "Multi Tools," each having a generic "Description1." These tools are fed into a "Workflow Generation" module (represented by the gear/brain icon) to produce a "Candidate Tools DAG." This DAG outlines a potential sequence of tool usage, starting from a "Task" and ending at "Finish," with intermediate nodes numbered 1 through 7. Following this, a "Complex Query" and the "Candidate Tools" are processed through "Query Reverse-Engineering" and "Intent Analysis and Re-planning" (another gear/brain icon). This step generates a "New DAG," which is a refined or adapted workflow. This "New DAG" is more complex, featuring 8 intermediate nodes, suggesting a more detailed or optimized plan. The output of the "New DAG" is used to "Filter Training Dataset" and then for "Fine-tuning" an AI agent. The fine-tuning process, labeled "GRPO," transforms a "frowning" robot (presumably an untrained or poorly performing agent) into a "smiling" robot (a well-trained or high-performing agent). This implies an iterative learning process, possibly using reinforcement learning, where the agent learns to generate and execute effective workflows. **Section (b) Executing process:** The execution process starts with a user providing a natural language "Query," such as "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." The system also has access to a pool of "Candidate Tools," represented by various icons like maps, search, documents, flights, hotels, and financial tools. In the "Planning" stage, the system, likely guided by the trained agent, constructs a specific DAG tailored to the query. This DAG shows a clear dependency structure: 1. `find_city` (using a map tool) is the initial step. 2. Once a city is found, `get_flights` (using a flight tool) and `get_hotels` (using a hotel tool) can proceed in parallel. 3. Finally, `make_report` (using a money/report tool) combines the information from flights and hotels to create a budget. The "Executing" stage then describes the sequential and parallel steps derived from the "Planning" DAG: 1. "Step 1: Use **find_city** to find a destination for hiking." 2. "Step 2: In parallel, use **get_flights** and **get_hotels** to find costs." 3. "Step 3: Use **make_report** to create a final plan and budget." This execution leads to a "Final answer," represented by a document and pen icon. ### Key Observations * **DAG-centric Approach**: Both training and execution heavily rely on Directed Acyclic Graphs (DAGs) to model and manage complex workflows, indicating a structured and dependency-aware approach to task completion. * **Iterative Refinement in Training**: The transition from "Candidate Tools DAG" to "New DAG" suggests a process of refining or optimizing workflows based on complex queries and intent analysis. * **Agent Improvement**: The "GRPO" fine-tuning step, transforming a frowning robot to a smiling one, clearly indicates that the training process aims to improve the agent's capability or performance. * **Tool-Use Specialization**: In the execution phase, generic "Candidate Tools" are mapped to specific, named functions like `find_city`, `get_flights`, `get_hotels`, and `make_report`, demonstrating the system's ability to select and apply relevant tools. * **Parallelism in Execution**: The "Planning" DAG and "Executing" steps explicitly show that `get_flights` and `get_hotels` can run "in parallel," highlighting the system's ability to optimize task execution time. ### Interpretation This diagram illustrates a sophisticated AI system designed to understand complex user queries and execute them by orchestrating a series of specialized tools. The core idea is to enable an AI agent to break down a high-level goal into a structured workflow (a DAG) of tool calls. The **training process** is crucial for teaching the agent how to construct these effective workflows. It starts with a broad set of tools and learns to generate and refine DAGs that represent valid and efficient ways to achieve tasks. The "Query Reverse-Engineering" and "Intent Analysis" steps suggest that the system learns to infer the underlying intent of a complex query and adapt its planning strategy accordingly. The "GRPO" fine-tuning indicates that this learning is likely driven by optimizing some performance metric, possibly through reinforcement learning, where the agent is rewarded for generating successful plans. The **executing process** demonstrates the practical application of this learned capability. Given a user's query, the agent doesn't just execute a single command but intelligently plans a multi-step, potentially parallel, sequence of tool invocations. For the hiking retreat example, the agent understands that finding a city is a prerequisite for finding flights and hotels, and both are needed before a final budget can be compiled. This shows a hierarchical understanding of tasks and their dependencies. In essence, the system acts as an intelligent orchestrator, translating human intent into actionable, tool-based workflows. This approach is highly relevant for developing general-purpose AI agents that can interact with a wide array of digital tools and services to solve real-world problems, moving beyond single-task capabilities to complex, multi-faceted problem-solving. The "Description1" for all tools in the training phase might imply that the system learns to generalize from tool descriptions rather than requiring specific examples for each tool, making it adaptable to new tools.

# Technical Document Extraction: AI Agent Training and Execution Workflow This document provides a comprehensive technical breakdown of the provided image, which illustrates a two-part process for training and executing an AI agent capable of complex task planning and tool usage. --- ## 1. Overview The image is divided into two primary horizontal sections: * **(a) Training process:** A blue-shaded region detailing the data generation and model optimization pipeline. * **(b) Executing process:** A yellow-shaded region illustrating the real-time application of the trained model to a user query. --- ## 2. Section (a): Training Process This section describes the "Workflow Generation," "Query Reverse-Engineering," and "Intent Analysis and Re-planning" phases. ### Component 1: Multi Tools Input A list of available tools is provided as the initial input: * **Tool_1:** Description1 * **Tool_2:** Description1 * **......** * **Tool_n:** Description1 ### Component 2: Workflow Generation An OpenAI/GPT-style logo indicates an LLM processes the tools to create a **Candidate Tools DAG (Directed Acyclic Graph)**: * **Structure:** * Starts at a node labeled **Task**. * Flows into a parallel structure: * Path A: Node 1 $\rightarrow$ Node 3 $\rightarrow$ Node 6. * Path B: Node 1 $\rightarrow$ Node 4 $\rightarrow$ Node 6. * Path C: Node 2 $\rightarrow$ Node 5 $\rightarrow$ Node 7. * All paths converge at a node labeled **Finish**. ### Component 3: Query Reverse-Engineering & Intent Analysis The DAG and tools are passed through another LLM process to generate a **Complex Query**. This is then fed into a third LLM stage for **Intent Analysis and Re-planning**, resulting in a **New DAG**: * **New DAG Structure:** * Starts at **Task**. * Branch 1: Node 1 $\rightarrow$ Node 3 $\rightarrow$ Node 7. * Branch 2: Node 1 $\rightarrow$ Node 4 $\rightarrow$ Node 7. * Branch 3: Node 2 $\rightarrow$ Node 5 $\rightarrow$ Node 8. * Branch 4: Node 2 $\rightarrow$ Node 6 $\rightarrow$ Node 8. * All paths converge at **Finish**. ### Component 4: Model Optimization * **Filter:** The generated data is filtered into a **Training Dataset**. * **Fine-tuning:** The dataset is used to fine-tune a base model (represented by a robot icon). * **GRPO:** A final optimization step labeled "GRPO" (likely Group Relative Policy Optimization) transitions the model to its final state. --- ## 3. Section (b): Executing Process This section demonstrates the inference flow from user query to final answer. ### Component 1: User Query and Candidate Tools * **Query:** "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." * **Candidate Tools:** A cloud containing various icons representing Google, maps, flights, currency/finance, and messaging. ### Component 2: Planning (DAG Generation) The agent generates a specific execution graph: 1. **find_city** (Map icon) 2. **get_flights** (Airplane icon) and **get_hotels** (Building icon) are triggered in parallel after `find_city`. 3. **make_report** (Currency/Yen icon) is the final node receiving input from both flights and hotels. ### Component 3: Executing (Step-by-Step) The plan is translated into sequential/parallel execution steps: * **Step 1:** Use `find_city` to find a destination for hiking. * **Step 2:** In parallel, use `get_flights` and `get_hotels` to find costs. * **Step 3:** Use `make_report` to create a final plan and budget. ### Component 4: Output * **Final answer:** Represented by a map and pencil icon, signifying the completed itinerary and budget report. --- ## 4. Summary of Flow 1. **Training:** Synthetic workflows (DAGs) are generated from tool descriptions, reverse-engineered into queries, and used to fine-tune a model via GRPO. 2. **Execution:** The fine-tuned model receives a natural language query, selects tools, generates a planning DAG, and executes the steps to provide a final answer.

\n ## Diagram: Workflow for Tool-Augmented LLMs ### Overview The image depicts a workflow diagram illustrating the training and execution processes of a tool-augmented Large Language Model (LLM). The diagram is divided into two main sections: (a) Training process and (b) Executing process. It showcases how the LLM learns to utilize various tools to fulfill complex queries. ### Components/Axes The diagram consists of several interconnected components represented by boxes, circles, and arrows. Key components include: * **Multi Tools:** A list of tools with descriptions (Tool\_1: Description1, Tool\_2: Description1, etc.). * **Candidate DAG:** Directed Acyclic Graph representing potential tool execution sequences. * **Complex Query:** The input query to the system. * **New DAG:** Refined Directed Acyclic Graph after intent analysis and re-planning. * **Training Dataset:** Filtered data used for fine-tuning. * **GRPO:** A component involved in the fine-tuning process. * **Planning:** Section showing the planning stage of query execution. * **Executing:** Section showing the execution stage of query execution. * **Final Answer:** The output of the system. * **Tools:** Icons representing individual tools (e.g., map, search, calculator, airplane). ### Detailed Analysis or Content Details **(a) Training Process:** 1. **Multi Tools** (Top-Left): A list of tools is fed into the system. The list is represented as "Tool\_1: Description1", "Tool\_2: Description1", and so on, indicating multiple tools with associated descriptions. 2. **Candidate DAG** (Left-Center): A circular diagram with nodes numbered 1 through 7, representing a potential workflow of tool execution. An arrow points from the "Multi Tools" to this DAG. The label "Task" is present above the DAG. 3. **Complex Query** (Center): A "Complex Query" is input into the system, connecting to the "Candidate DAG" and "Candidate Tools". 4. **Candidate Tools** (Below Complex Query): A box labeled "Candidate Tools" receives input from the "Complex Query". 5. **New DAG** (Right-Center): A similar circular diagram with nodes numbered 1 through 8, representing a refined workflow. The label "Task" is present above the DAG. 6. **Filter Training Dataset** (Top-Right): A box labeled "Filter Training Dataset" receives input from the "New DAG". 7. **Fine-tuning** (Bottom-Right): A process labeled "Fine-tuning" utilizes the filtered dataset and involves a component labeled "GRPO". 8. **GRPO** (Bottom-Center): A component labeled "GRPO" is involved in the fine-tuning process. **(b) Executing Process:** 1. **Query** (Bottom-Left): A query is presented: "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." 2. **Candidate Tools** (Left of Query): Icons representing candidate tools are displayed alongside the query: a map, a "G" (likely Google Search), a calculator, an airplane, and a compass. 3. **Planning** (Left Section): This section shows the planning stage. * **find\_city:** A tool icon representing finding a city. * **get\_flights:** A tool icon representing getting flight information. * **get\_hotels:** A tool icon representing getting hotel information. * **make\_report:** A tool icon representing creating a report. 4. **Executing** (Right Section): This section shows the execution stage. * **Step 1:** "Use find\_city to find a destination for hiking." * **Step 2:** "In parallel, use get\_flights and get\_hotels to find costs." * **Step 3:** "Use make\_report to create a final plan and budget." 5. **Final Answer** (Far-Right): A tent icon represents the final answer. ### Key Observations * The training process focuses on refining the tool execution workflow based on complex queries. * The executing process demonstrates a sequential and parallel execution of tools to fulfill a user query. * The diagram highlights the importance of intent analysis and re-planning in optimizing the tool usage. * The use of DAGs suggests a structured approach to managing tool dependencies and execution order. ### Interpretation The diagram illustrates a sophisticated approach to building tool-augmented LLMs. The training process aims to teach the LLM how to effectively utilize a set of tools to solve complex problems. The use of DAGs allows for representing and optimizing the order of tool execution. The executing process demonstrates how the LLM can break down a complex query into a series of steps, leveraging different tools in parallel to achieve the desired outcome. The diagram suggests a system capable of not only understanding natural language but also reasoning about the best way to utilize external tools to provide comprehensive and accurate answers. The GRPO component in the fine-tuning stage likely represents a reinforcement learning or gradient-based optimization process to improve the LLM's tool selection and execution strategies. The overall workflow emphasizes a data-driven approach to building intelligent agents that can effectively interact with the real world through the use of tools.

## Diagram: AI Agent Training and Execution Workflow ### Overview The image is a two-part technical diagram illustrating a framework for training and deploying an AI agent that uses multiple tools to solve complex queries. The top section (a) depicts the **Training process**, showing how tool descriptions and queries are used to generate training data for fine-tuning an agent. The bottom section (b) illustrates the **Executing process**, demonstrating how the trained agent plans and executes a specific user query by composing tool calls into a Directed Acyclic Graph (DAG). ### Components/Axes The diagram is divided into two main colored regions: 1. **Top Region (Light Blue):** Labeled "(a) Training process". 2. **Bottom Region (Light Yellow):** Labeled "(b) Executing process". **Key Textual Elements and Labels:** * **Training Process (a):** * **Leftmost Box:** "Multi Tools" containing a list: `Tool_1: Description1`, `Tool_2: Description1`, `......`, `Tooln_: Description1`. * **First DAG Box:** "Candidate Tools DAG:" with a graph containing nodes labeled `Task`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, and `Finish`. * **Middle Boxes:** "Complex Query" and "Candidate Tools". * **Second DAG Box:** "New DAG:" with a graph containing nodes labeled `Task`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, and `Finish`. * **Process Flow Labels (below the boxes):** "Workflow Generation", "Query Reverse-Engineering", "Intent Analysis and Re-planning". * **Right Side:** An arrow labeled "Filter" points to a box labeled "Training Dataset". An arrow labeled "Fine-tuning" points from the dataset to a robot icon. The robot is labeled "GRPO". * **Executing Process (b):** * **Left Side - User Query:** A user icon next to a text box containing: "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." This is labeled "Query". * **Left Side - Tools:** A cloud-shaped container labeled "Candidate Tools" filled with various application icons (e.g., Google logo, map pin, airplane, hotel, yen symbol, envelope). * **Center - Planning:** A section titled "Planning" containing a DAG with tool icons and labels: `find_city` (map pin), `get_flights` (airplane), `get_hotels` (hotel), and `make_report` (yen symbol). Arrows show the flow: `find_city` -> `get_flights` & `get_hotels` (in parallel) -> `make_report`. * **Right - Execution Steps:** A section titled "Executing" with three steps: * "Step 1: Use **find_city** to find a destination for hiking." * "Step 2: In parallel, use **get_flights** and **get_hotels** to find costs." * "Step 3: Use **make_report** to create a final plan and budget." * **Final Output:** An arrow points to an icon of a document with a pencil, labeled "Final answer". ### Detailed Analysis **Training Process Flow (a):** 1. **Input:** A set of tool descriptions ("Multi Tools") and a "Complex Query". 2. **Process:** The system performs "Workflow Generation" to create an initial "Candidate Tools DAG". It then engages in "Query Reverse-Engineering" and "Intent Analysis and Re-planning" to produce a "New DAG". 3. **Output Generation:** The new DAG is filtered to create a "Training Dataset". 4. **Model Training:** The dataset is used for "Fine-tuning" to produce a trained agent model, represented by a robot icon labeled "GRPO". **Executing Process Flow (b**** AI,##, AI, для,**, AI, всужизации, AI, для,,, AI я, AI0.,,,**я, я,, tools.об,,00 000 наи,.. и002000**化的ations, **.00я. .00,0.4.0000.,.... autom.0 . **,,,**### ** Key Observations * **DAG-Centric Design:**** Both training and execution rely on representing workflows as Directed Acyclic Graphs (DAGs), where nodes represent tasks or tool calls and edges represent dependencies. * **Two-Stage Process:** The framework clearly separates the offline **training** of the agent (learning to create good DAGs) from the online **execution** (using a trained agent to solve a new query). * **Parallel Execution:** The executing process diagram explicitly highlights the ability to run independent tool calls (`get_flights` and `get_hotels`) in parallel, which is a key efficiency feature. * **GRPO Agent:** The trained agent is referred to as "GRPO," which is likely an acronym for the specific model or algorithm used (e.g., "Graph-based Reasoning and Planning Operator"). ### Interpretation This diagram outlines a sophisticated method for building AI agents that can solve multi-step problems by intelligently composing available tools. The core innovation appears to be using **reverse-engineering and re-planning** during training to generate high-quality training data (DAGs) from complex queries. This teaches the agent not just to use tools, but to structure their use optimally. The executing process demonstrates the practical benefit: a vague, high-level user request ("Plan a hiking retreat") is decomposed into a concrete, executable plan with clear steps and parallelizable sub-tasks. The agent acts as a **reasoning engine**, translating intent into action. The "GRPO" agent is the product of this training, capable of taking a new query and candidate tools, and autonomously generating and following an efficient execution plan to produce a final answer. This approach bridges the gap between large language models' reasoning capabilities and the practical need to interact with external APIs and services.

## Diagram: AI Workflow for Task Execution and Training ### Overview The image depicts a two-phase workflow for an AI system: (a) Training process and (b) Executing process. The training phase involves workflow generation, query reverse-engineering, and intent analysis, while the executing phase focuses on planning and task execution using candidate tools. The system uses a DAG (Directed Acyclic Graph) structure for task decomposition and fine-tuning via GRPO (Group Relative Policy Optimization). --- ### Components/Axes #### Training Process (a) 1. **Multi Tools**: List of tools with descriptions (e.g., `Tool_1: Description1`, `Tool_2: Description1`). 2. **Candidate Tools DAG**: A 7-node DAG with nodes labeled `1` to `7`, connected sequentially with arrows. The final node is labeled "Finish." 3. **Complex Query**: A query input connected to the Candidate Tools DAG. 4. **New DAG**: A 8-node DAG with nodes labeled `1` to `8`, connected sequentially. The final node is labeled "Finish." 5. **Filter**: A component separating the New DAG into a Training Dataset. 6. **Fine-tuning**: A step following the Training Dataset. 7. **GRPO**: A robot icon representing the fine-tuning algorithm. #### Executing Process (b) 1. **Query**: A user request: "Plan a 5-day hiking retreat. Find a city, get flight and hotel costs, and give me a total budget." 2. **Candidate Tools**: Icons representing tools (e.g., Google Maps, flight booking, currency converter, hotel booking). 3. **Planning Diagram**: A 4-node DAG with nodes labeled `find_city`, `get_flights`, `get_hotels`, and `make_report`, connected sequentially. 4. **Executing Steps**: - **Step 1**: Use `find_city` to find a hiking destination. - **Step 2**: Use `get_flights` and `get_hotels` in parallel to find costs. - **Step 3**: Use `make_report` to create a final plan and budget. --- ### Detailed Analysis #### Training Process (a) - **Workflow Generation**: Multi Tools are converted into a Candidate Tools DAG, which defines task dependencies. - **Query Reverse-Engineering**: Complex queries are broken down into candidate tools for processing. - **Intent Analysis and Re-planning**: The New DAG refines task sequences, filtered into a Training Dataset for fine-tuning. - **Fine-tuning**: The GRPO algorithm optimizes the model using the Training Dataset. #### Executing Process (b) - **Planning**: The query is decomposed into a DAG of subtasks (`find_city`, `get_flights`, `get_hotels`, `make_report`). - **Execution**: Subtasks are executed in sequence or parallel, with results aggregated into a final report. --- ### Key Observations 1. **Structured Task Decomposition**: Both phases use DAGs to model task dependencies and workflows. 2. **Tool Integration**: Candidate tools (e.g., flight/hotel APIs) are central to both training and execution. 3. **GRPO Fine-tuning**: Reinforcement learning from human feedback (RLHF) is implied via GRPO, suggesting iterative model improvement. 4. **Parallel Execution**: Step 2 in the executing phase explicitly uses parallel tool calls (`get_flights` and `get_hotels`). --- ### Interpretation The system is designed to handle complex user queries by: 1. **Training**: Building a task decomposition framework (DAGs) and refining it via fine-tuning. 2. **Execution**: Dynamically planning and executing subtasks using integrated tools, with parallel processing for efficiency. The GRPO fine-tuning step indicates a focus on aligning the model with user preferences, likely through iterative feedback. The use of DAGs ensures tasks are executed in a logical, dependency-respecting order, while candidate tools provide real-world data integration (e.g., flight/hotel pricing). The example query demonstrates end-to-end functionality, from planning a retreat to generating a budget report.