知乎回答

问题：如何看待 从零构建高级Agentic Harness：开发者不可不知的五大核心设计模式？

当大模型不再满足于“聊天”，而是开始接管复杂工作流时，我们需要的不仅是更强的模型，而是一个能驾驭它们的“缰绳”。今天，我们拆解一个来自数据科学社区的高阶教程，看看真正的Agentic Harness应该长什么样。

当大模型不再满足于“聊天”，而是开始接管复杂工作流时，我们需要的不仅是更强的模型，而是一个能驾驭它们的“缰绳”。今天，我们拆解一个来自数据科学社区的高阶教程，看看真正的Agentic Harness应该长什么样。

大模型应用正在经历一场从“对话机器人”到“自主智能体”的范式转移。随之而来的，是开发者们集体面临的一个新问题：如何为这些拥有无限可能性的模型，设计一个既灵活又可控的执行框架？ 这正是“Agentic Harness”概念爆发的背景。它并非简单的API调用封装，而是一个包含状态管理、工具调度、安全护栏和自省机制的复杂系统。

本周，数据科学社区data4sci发布了一篇深度技术文章《Building an Advanced Agentic Harness》，直接切入这一痛点。文章没有停留在概念层面，而是提供了一个可运行的、面向生产环境的构建蓝图。我们提炼了其中最核心的五个设计模式，并结合代码示例，带你一窥高级Agent基础设施的真相。

模式一：状态机驱动的任务循环

大多数初级Agent实现是一个while True循环，直到模型认为任务完成。但高级Harness摒弃了这种模糊控制，转而采用显式的有限状态机（FSM）。这不仅仅是工程洁癖，而是为了可观测性和故障恢复。

from enum import Enum
from dataclasses import dataclass, field

class AgentState(Enum):
    IDLE = "idle"
    THINKING = "thinking"
    TOOL_EXECUTION = "tool_execution"
    WAITING_FOR_HUMAN = "waiting_for_human"
    FINISHED = "finished"
    ERROR = "error"

@dataclass
class TaskContext:
    state: AgentState = AgentState.IDLE
    history: list = field(default_factory=list)
    pending_tool_calls: dict = field(default_factory=dict)

    def transition(self, new_state: AgentState):
        # 记录状态变迁日志，用于追踪和回放
        self.history.append((self.state, new_state))
        self.state = new_state

通过状态机，我们可以精确控制Agent何时可以调用工具、何时必须暂停等待人工审批，以及当工具执行超时或返回异常时，如何优雅地回退到“ERROR”状态并触发修复策略。这种结构化设计是生产级系统与玩具Demo的分水岭。

模式二：工具注册表与动态Schema发现

Agent的核心能力在于调用外部工具。高级Harness不会将工具写死在代码里，而是维护一个工具注册表。每个工具不仅包含函数实现，还附带一个动态生成的JSON Schema，用于在运行时向大模型描述函数签名。

import json
from typing import Callable, Any

class ToolRegistry:
    def __init__(self):
        self._tools = {}

    def register(self, name: str, description: str, schema: dict, func: Callable):
        self._tools[name] = {
            "description": description,
            "parameters_schema": schema,
            "function": func
        }

    def get_system_prompt_blocks(self) -> str:
        # 生成供LLM上下文窗口读取的函数定义
        blocks = []
        for name, tool in self._tools.items():
            block = f"Tool: {name}\nDescription: {tool['description']}\nParams: {json.dumps(tool['parameters_schema'])}"
            blocks.append(block)
        return "\n\n".join(blocks)

    def execute(self, name: str, **kwargs) -> Any:
        if name not in self._tools:
            raise ValueError(f"Unknown tool: {name}")
        return self._tools[name]["function"](**kwargs)

# 示例：注册一个天气查询工具
def get_weather(city: str, unit: str = "celsius"):
    # 实际实现会调用外部API
    return f"Weather in {city}: 22° {unit}"

registry = ToolRegistry()
registry.register(
    name="get_weather",
    description="获取指定城市的当前天气",
    schema={
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "城市名称"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
    },
    func=get_weather
)

这一模式的优势在于解耦。新增工具只需注册，无需修改Agent核心逻辑。同时，动态Schema让大模型能更准确地理解参数约束，减少无效调用。

模式三：基于“预算”的执行控制

无约束的Agent循环是成本黑洞。高级Harness引入了预算机制——无论是时间预算、Token预算还是工具调用次数预算。一旦预算耗尽，Agent必须强制进入“WAITING_FOR_HUMAN”状态，请求用户决策。

class ExecutionBudget:
    def __init__(self, max_tool_calls: int = 10, max_tokens: int = 8000, timeout_seconds: int = 120):
        self.max_tool_calls = max_tool_calls
        self.max_tokens = max_tokens
        self.timeout_seconds = timeout_seconds
        self.used_tool_calls = 0
        self.used_tokens = 0

    def can_proceed(self) -> bool:
        return (self.used_tool_calls < self.max_tool_calls and
                self.used_tokens < self.max_tokens)

    def record_usage(self, tool_calls: int = 0, tokens: int = 0):
        self.used_tool_calls += tool_calls
        self.used_tokens += tokens

这不仅仅是一个计数器，而是一种产品策略。它迫使开发者思考：Agent在什么情况下应该“认输”并寻求人类帮助？这种设计能让系统在面对不可预见的复杂任务时，保持可控性和成本效率。

模式四：自省与轨迹日志

调试Agent就像在迷宫中追踪一只老鼠。高级Harness内置了完整的轨迹日志（Trajectory Logging）系统，记录每一步的思考过程、工具输入输出、状态变迁。这不仅用于调试，更是构建“自省”能力的基础。

class TrajectoryLogger:
    def __init__(self):
        self.events = []

    def log_event(self, event_type: str, data: dict):
        entry = {
            "timestamp": time.time(),
            "type": event_type,
            "data": data
        }
        self.events.append(entry)
        # 也可以输出到外部可观测性系统，如OpenTelemetry

    def get_trace_for_llm(self) -> str:
        # 将轨迹压缩为文本，供LLM在后续决策时参考
        return "\n".join([f"[{e['type']}] {json.dumps(e['data'])}" for e in self.events[-20:]])

模式五：安全护栏（Guardrails）

当Agent拥有执行真实世界操作（如发送邮件、修改代码）的能力时，安全是头等大事。高级Harness在工具执行层之前，插入了一个护栏层，通过策略规则进行预检和后检。

class GuardrailPolicy:
    def __init__(self):
        self.blocked_actions = ["delete_database", "send_email_to_all"]
        self.require_approval = ["execute_code", "modify_production_config"]

    def pre_check(self, tool_name: str, params: dict) -> str:
        # 返回 "allow", "deny", "require_approval"
        if tool_name in self.blocked_actions:
            return "deny"
        if tool_name in self.require_approval:
            return "require_approval"
        return "allow"

这个设计将安全策略与业务逻辑分离。开发者可以灵活调整规则，而不需要改动Agent的推理循环。例如，对于execute_code工具，我们可以设置为默认“require_approval”，只有人工确认后才真正执行。

不只是“框架”，更是“思维方式”

这篇教程最值得称道之处，在于它没有提供一份“开箱即用”的代码库，而是展示了构建过程中的关键决策点。它提醒我们：Agentic Harness的核心价值，不在于让模型更“聪明”，而在于让系统更可靠、可控、可观测。

对于正在开发复杂Agent应用的团队而言，这五个模式提供了一个很好的检视清单：你的状态管理是否清晰？你的工具调用是否灵活？你的成本控制是否有效？你的安全策略是否完备？

正如文章作者所言：“一个高级Harness的目标，不是成为模型的限制，而是成为模型能力得以安全释放的舞台。” 在这个大模型应用快速演进的年代，这样的工程化思考，恐怕比追逐最新模型更有长期价值。

这个事件/技术的核心价值在于它推动了一个重要方向的发展。作为从业者/关注者，我们既要看到短期的影响，也要理解其长期意义。

data4sci.com/blog/building-an-advanced-agentic-harness

抖音口播脚本

时长：60秒以内

【开场 Hook（0-5秒）】

当大模型不再满足于“聊天”，而是开始接管复杂工作流时，我们需要的不仅是更强的模型，而是一个能驾驭它们的“缰绳”。今天，我们拆解一个来自数据科学社区的高阶教程，看看真正的Agentic Harness应该长什么样。

【核心内容（5-45秒）】

从零构建高级Agentic Harness：开发者不可不知的五大核心设计模式

【结尾引导（45-60秒）】

如果你觉得有用，点赞收藏，评论区告诉我你的看法！

• 竖屏 9:16
• 表情自然，语速适中
• 关键信息配文字弹幕
• 背景音乐：科技感电子乐

小红书笔记

从零构建高级Agentic Harness：开发者不可不知的五大核心设计模式 🔥

当大模型不再满足于“聊天”，而是开始接管复杂工作流时，我们需要的不仅是更强的模型，而是一个能驾驭它们的“缰绳”。今天，我们拆解一个来自数据科学社区的高阶教程，看看真正的Agentic Harness应该长什么样。

💡 关键信息：

• 来源：Hacker News
• 更多详情见完整文章

##Agent ##大模型工程 ##开发框架

#科技资讯 #前沿技术