## 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.
