Parallel Tool Call Learning

Agent常常会按顺序执行工具调用，即便这些调用本可以并行运行：

• 不必要的延迟：当工具执行时间远长于推理时间时，顺序调用的耗时会累积
• 低效探索：Agent需等待上一个调用的结果才能决定下一步动作
• 工具利用率低：多个独立的信息需求被逐一处理
• 次优的习得行为：基础模型若无训练信号，通常不会自然地进行并行操作

示例瓶颈：

顺序执行（缓慢）：
1. 搜索（“英特尔财务数据”）→ 2秒
2. 读取文件（“2023_report.pdf”）→ 1.5秒
3. 搜索（“回报指标”）→ 2秒
4. 读取文件（“returns_table.csv”）→ 1.5秒

总耗时：7秒

Cognition团队在Devon中观察到了这一现象：基准模型在文件规划阶段会发起8-10次顺序工具调用，即便其中许多调用本可并行执行，仍会耗费大量时间。

借助Agent RFT训练模型实现独立工具调用的并行化，当工具执行速度快于推理时，可大幅降低延迟。

模型如何学习并行化：

在强化学习（RL）探索阶段，Agent会发现：

1. 可同时发起多个工具调用
2. 当工具结果同步返回时，下一步推理将拥有更丰富的上下文
3. 并行模式能在更短时间内获得相近的奖励（即隐含的效率奖励）
4. 模型会自然向并行执行模式收敛

基于强化学习的并行化自然涌现：

与显式编程不同，并行化源自以下核心机制：

• 探索：Agent尝试不同的工具调用模式
• 奖励塑造：完成速度更快的任务可获得少量额外奖励（可选配置）
• 效率约束：对token使用施加轻微惩罚，以此激励效率提升
• 模式强化：成功的并行模式会得到持续强化

典型的学习后执行模式：

并行（快速）：
批次1（并行）：
  
- search("英特尔财务数据")
  - read_file("2023_report.pdf")
  - search("回报指标")
  - list("/financial_reports")
→ 全部完成耗时约2秒（由最慢的调用决定总时长）

批次2（并行，基于批次1结果）：
  
- read_file("returns_table.csv")
  - read_file("competitor_data.csv")
→ 完成耗时约1.5秒

总耗时：约3.5秒（提速50%）

前提条件：

你的基础设施必须支持并行工具执行：

# 工具服务器必须能够处理并发请求
@app.cls(
    image=base_image,
    concurrency_limit=10,  # 允许每个部署实例同时运行10个工具
    allow_concurrent_inputs=True
)
class ParallelToolExecutor:
    @method()
    async def execute_tool(self, rollout_id: str, tool: str, params: dict):
        # 针对IO密集型操作使用异步实现
        result = await self._async_execute(tool, params)
        return result

训练设置：

无需特殊配置，并行化会自然形成：

# 标准Agent RFT训练设置
job = client.fine_tuning.jobs.create(
    training_file="file-abc123",
    model="gpt-4o",
    method="rft",
    rft={
        "tools": tools,
        "grader": grader,
        "hyperparameters": {
            "n_epochs": 3,
            "batch_size": 16,
            "compute_multiplier": 1
        }
    }
)

# 无需设置特殊的"并行化"标志！
# 模型会在探索过程中自主发现该模式

可选：显式延迟奖励

你可以通过奖励塑形来鼓励模型采用并行化策略：

class LatencyAwareGrader:
    def grade(self, question, answer, tool_trace, ground_truth):
        # 标准正确性评分
        correctness = self.check_correctness(answer, ground_truth)

        # 效率奖励
        num_sequential_rounds = self.count_sequential_rounds(tool_trace)

        if num_sequential_rounds <= 3:
            efficiency_bonus = 0.1
        elif num_sequential_rounds <= 5:
            efficiency_bonus = 0.05
        else:
            efficiency_bonus = 0.0

        return {
            "score": correctness + efficiency_bonus,
            "subscores": {
                "correctness": correctness,
                "efficiency": efficiency_bonus
            }
        }

    def count_sequential_rounds(self, tool_trace):
        """
        统计与工具交互的顺序轮次
        同一轮中的并行调用计为1轮
        """
        rounds = 0
        current_round_calls = set()

        for call in tool_trace:
            if call['type'] == 'tool_call':
                current_round_calls.add(call['id'])
            elif call['type'] == 'tool_response':
                if call['call_id'] in current_round_calls:
                    current_round_calls.remove(call['call_id'])
                    if not current_round_calls:
                        rounds += 1

        return rounds

并行化监控：

在训练过程中跟踪模型是否习得并行模式：

def analyze_parallelization(tool_trace):
    """
    分析Agent发起的并行调用数量
    """
    parallel_batches = []
    current_batch = []

    for event in tool_trace:
        if event['type'] == 'tool_call':
            current_batch.append(event)
        elif event['type'] == 'assistant_message':
            # 推理阶段结束，开启新的工具调用批次
            if current_batch:
                parallel_batches.append(len(current_batch))
                current_batch = []

    return {
        'num_batches': len(parallel_batches),
        'calls_per_batch': parallel_batches,
        'max_parallelism': max(parallel_batches) if parallel_batches else 0,
        'total_calls': sum(parallel_batches)
    }

# 示例输出展示已习得的并行化能力：
# 基线模型：{'num_batches': 8, 'calls_per_batch': [1,1,1,1,1,1,1,1], 'max_parallelism': 1}
# 微调后模型：{'num_batches': 2, 'calls_per_batch': [4,2], 'max_parallelism': 4}

优点：

• 显著降低延迟：适用场景下通常可减少40%-50%的延迟
• 无需手动编码：并行化源于模型训练，而非人工编程
• 自适应能力：模型会针对你的特定工具与任务学习最优并行化策略
• 自然可扩展：适配不同工具数量与任务复杂度的场景
• 更优用户体验（UX）：更快的Agent响应能提升用户体验

缺点：

• 基础设施要求较高：工具服务器需具备处理并发请求的能力
• 资源消耗增加：同时发起的工具调用越多，峰值资源使用率越高
• 并行化效果未必自然生成：需要训练数据具备足够的多样性
• 可能需要奖励塑造（reward shaping）：若并行化未自然生成，添加明确的延迟优化奖励项可起到辅助作用
• 调试复杂度提升：并行执行会使追踪执行链路的难度加大