一个 Python 智能体和一个 Go 智能体如何利用 Agent2Agent 协议在合同合规性上进行协作

你的合同合规流水线存在一个问题。数据科学团队用 Python 编写了一个出色的提取智能体。它使用 Gemini 来解析法律合同并提取出每一个关键条款。安全工程团队则用 Go 构建了一个极速的合规性验证器，全部采用确定性逻辑，没有使用大语言模型。两者在独立运行时都表现完美。但现在你需要它们协同工作，作为一个统一的协调流水线，而两个团队都不愿意用另一种语言重写他们的服务。

这就是生产级 AI 系统的现实：不同的团队、不同的语言、不同的部署目标。问题不在于你是否会面临这种情况，而在于你将如何解决它。

在这篇文章中，我们将构建一个合同合规多智能体流水线，其中 Python 智能体使用 Gemini 提取合同条款，Go 智能体则根据公司政策对其进行验证。这两个服务通过 Agent2Agent（A2A）协议连接，并由 Google 的 Agent 开发工具包（ADK）进行编排。

在此过程中，你将学到三种架构模式，这些模式将生产级多智能体系统与单语言演示区分开来：

• 使用 A2A 协议进行跨语言智能体协作，这样团队就能以最适合该工作的语言构建智能体，而无需重写代码。
• ADK 的 RemoteA2aAgent 抽象，它只需几行代码就能将任何符合 A2A 规范的远程服务转变为一个本地子智能体。
• 多智能体流水线编排，其中职责范围狭窄的专业化智能体取代了试图包揽一切的巨型提示词。

完整源代码可在 GitHub 上获取。

当一个智能体不够用时

大多数 AI 项目都以相同的方式开始：一个庞大的智能体，一个庞大的提示词，所有工具都塞进一个上下文窗口中。这在演示时行得通。但在生产环境中，它会因三个关键原因而崩溃：

• 上下文退化：当工具数量超过 10-15 个后，模型会开始遗漏指令、调用错误的工具或产生参数幻觉。每增加一个工具，都会在更广的范围内稀释模型的注意力。一个同时处理翻译、摘要和邮件起草的合同提取智能体，最终会在该调用哪个工具时陷入混乱。
• 影响半径：某个次要功能中一个未处理的异常就会导致整个智能体交互回合崩溃。翻译 API 的速率限制不应该拖垮你的整个工作流。但在单体智能体中，每一次失败都是彻底的失败。
• 不可测试：你无法对一个拥有 50 个纠缠不清职责的系统进行干净的单元测试。当每次提示词变更都可能影响所有下游行为时，评估回归问题就变成了猜测。

解决方案与十年前改变后端工程的模式相同：将单体分解为专门的微服务。每个智能体承担一项任务，拥有一个聚焦的提示词和一套最小化的工具集。

A2A 协议：智能体如何发现彼此并进行通信

智能体间（A2A）协议是一项开放标准，使得用任何语言或框架构建的智能体都能互操作。可以把它想象成智能体世界的 HTTP：一份共享契约，让任意两个智能体无论内部如何构建都能进行通信。

A2A 解决了三个根本性问题：

• 发现：智能体通过智能体卡片（Agent Cards）来宣传自身能力，这些卡片是位于 `/.well-known/agent.json` 的 JSON 元数据。类似于 REST API 的 OpenAPI 规范，该卡片声明了智能体的名称、URL、版本、技能以及支持的输入/输出格式。调用方智能体会先获取该卡片，以了解远程智能体能够做什么。
• 通信：所有数据交换都通过 JSON-RPC 2.0 进行，并路由至单个端点。智能体通信的核心方法是 `message/send`（我们的实现用它来提交合同数据并同步接收结果），以及其他协议方法如 `tasks/send` 和 `tasks/get` 用于任务的提交和检索。数据在类型化的消息部件（Message Parts）中传输：TextParts 用于自然语言，DataParts 用于结构化 JSON。
• 任务生命周期：每一次交互都封装在一个任务（Task）中，该任务会经历定义明确的状态转换：已提交、处理中、已完成或失败。这种状态机机制使得智能体能够用同一套协议处理同步工作流（立即审核此合同）和异步工作流（在48小时内验证此文档）。

这种方法的美妙之处在于，两个智能体都无需了解对方的实现细节。Python 智能体不导入 Go 包，Go 智能体也不运行 Python 代码。它们只需通过 HTTP 协议使用共享协议进行通信。

智能体卡片（Agent Card）的实际样貌

以下是 Go 合规服务在 `/.well-known/agent.json` 路径下暴露的智能体卡片：

// go-compliance-agent/internal/agentcard/card.go
func GetCard() AgentCard {
	agentURL := os.Getenv("AGENT_URL")
	if agentURL == "" {
		agentURL = "http://localhost:8888"
	}

	return AgentCard{
		Name:        "Security Compliance Validator",
		Description: "Go-based validation engine that checks vendor contracts against corporate compliance policy rules.",
		Version:     "1.0.0",
		SupportedInterfaces: []AgentInterface{
			{
				URL:             agentURL,
				ProtocolBinding: "JSONRPC",
				ProtocolVersion: "1.0",
			},
		},
		Capabilities: Capabilities{
			ExtendedAgentCard: false,
		},
		DefaultInputModes:  []string{"application/json"},
		DefaultOutputModes: []string{"application/json"},
		Skills: []Skill{
			{
				ID:          "contract_compliance_check",
				Name:        "Contract Compliance Check",
				Description: "Validates extracted contract fields against corporate policy rules.",
				Tags:        []string{"compliance", "contract", "validation"},
				Examples: []string{
					"Check this contract for compliance violations",
					"Validate vendor agreement terms against policy",
				},
			},
		},
	}
}

Go

URL 从环境变量中读取，因此同一份代码既可在本地（`localhost:8888`）运行，也可在容器（`go-compliance-agent:8888`）中运行。Skills 数组意味着单个智能体可以公布多种能力。

代码实现详解

以下展示了如何使用 Python 的 ADK 和 Go 的标准 HTTP 服务器，轻松组建这个跨语言团队。

共享状态：智能体之间的数据总线

在深入探讨单个智能体之前，理解它们如何通信至关重要。ADK 的 ToolContext.state 提供了一个共享字典，管道中的所有子智能体都可以对其进行读写。智能体之间并非通过函数参数或返回值传递数据，而是通过共享的会话状态进行通信。

我们合规管道的每一步都对应一个特定的检查点：

class ComplianceStep(str, Enum):
    INGESTED = "INGESTED"                     # Contract uploaded, awaiting extraction
    EXTRACTED = "EXTRACTED"                    # Fields parsed by Gemini
    COMPLIANCE_PENDING = "COMPLIANCE_PENDING"  # Sent to Go agent, awaiting result
    COMPLIANCE_COMPLETE = "COMPLIANCE_COMPLETE"# Go agent returned verdict
    MANUAL_REVIEW = "MANUAL_REVIEW"           # Timeout or error, routed to human
    REVIEW_READY = "REVIEW_READY"             # Report generated, violations found
    APPROVED = "APPROVED"                      # All checks passed

Python

MANUAL_REVIEW 状态值得特别说明。如果 Go 合规智能体因服务器崩溃、网络超时、容器未启动等原因无法访问，管道不会直接失败。它会转换到 MANUAL_REVIEW 状态，将该案例转交给人工法律审核员。这种故障安全模式对于下游服务可能间歇性不可用的生产系统至关重要。

1. 完整的多智能体管道：在 Python 中封装 Go 智能体

使用 ADK，你可以通过 `RemoteA2aAgent` 在本地定义一个远程的、符合 A2A 协议的智能体。SDK 会在后台自动处理智能体卡片握手、参数序列化以及 JSON-RPC 网络请求。

# python-extraction-agent/app/agent.py
from google.adk.agents import Agent, SequentialAgent
from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
from google.adk.models import Gemini


# Sub-Agent 1: Ingests & extracts details using LLM reasoning
extractor_agent = Agent(
   name="extractor_agent",
   model=Gemini(model="gemini-3.5-flash"),
   instruction="You are a Legal Data Extraction Agent. Extract contract fields: value, contractor, dates, insurance...",
   tools=[read_contract_text, save_extracted_fields, classify_risk_level]
)

# Sub-Agent 2: Go A2A Compliance Service wrapped as a local agent
compliance_agent = RemoteA2aAgent(
   name="compliance_agent",
   agent_card=GO_AGENT_CARD_URL,
   description="Validates extracted contract fields against corporate policies."
)

# Sub-Agent 3: Generates the final audit summary report
report_agent = Agent(
   name="report_agent",
   model=Gemini(model="gemini-3.5-flash"),
   instruction="Generate the final compliance report and Markdown summary.",
   tools=[generate_summary_report]
)

# Coordinator: Chains them together sequentially
root_agent = SequentialAgent(
   name="contract_compliance_coordinator",
    description="Orchestrates contract parsing, A2A compliance validation, and final reporting in sequence.",
   sub_agents=[extractor_agent, compliance_agent, report_agent],
)

Python

2. Go 合规端点

在 Go 语言一侧，合规智能体是一个实现了 A2A 协议的标准 HTTP 服务器。它对外暴露一个用于服务发现的 Agent Card，以及一个单一的 JSON-RPC 端点，该端点接收 message/send 请求，针对提取出的合约字段运行确定性策略检查，并返回通过/未通过的判定结果。无需任何 AI 框架或 SDK——仅需 Go 标准库即可。

以下是简化后的流程（完整实现在代码仓库中）：

// Simplified pseudo-code — see GitHub repository for full implementation


func HandleJSONRPC(w http.ResponseWriter, r *http.Request) {
    var req JSONRPCRequest
    json.NewDecoder(r.Body).Decode(&req)

    // Extract contract details from the A2A message
    var details compliance.ContractDetails
    extractContractFromMessage(req.Params, &details)

    // Run deterministic policy checks
    result := compliance.CheckCompliance(details, policy)

    // Return verdict as a JSON-RPC response
    writeJSONRPCResult(w, req.ID, result)
}

Go

开源应用：合约合规引擎

整个流水线以开源应用的形式发布，你可以直接部署并进行扩展。该代码仓库包含一个功能完备的操作控制台，由 FastAPI 服务提供支持。

• 三面板操作控制台：左侧面板允许操作员选择或上传合约。中间面板显示实时结果：合规合约显示合规证书，违规合约显示违规报告。右侧面板是一个开发者控制台，包含策略控制、网络模拟以及两个智能体之间数据流动的实时视图。
• 网络故障模拟：一个切换开关可让你将 Go 智能体在正常、延迟和崩溃三种状态间切换。将其设置为崩溃状态可展示故障安全机制的实际效果：Python 智能体检测到故障，暂停流水线，并将合约转交人工审核，而非静默失败。
• 实时智能体交接检查器：右侧面板显示从 Python 发送到 Go 的确切请求以及返回的响应，让你能够实时看到结构化的合约数据跨越语言边界进行传输。

ADK 与 A2A 方法的优势

1. 技术自由：你的数据科学团队可以用 Python 编写复杂的认知型智能体，而你的系统团队可以用 Go、Rust 或 C++ 编写高性能、安全的合规验证器。
2. 简化集成：Python 编排器与 Go 智能体通信时，就像与本地类交互一样。你无需编写自定义 HTTP 客户端，也无需手动处理 JSON-RPC 载荷的封装。
3. 弹性：由于智能体之间是解耦的，你可以配置精细的超时和重试逻辑。如果 Go 验证器宕机，Python 智能体会保存当前状态检查点，并等待人工审批。
4. 隔离审计：Go 合规性验证器是完全确定性的。出于审计目的，您可以传入相同的输入，并验证它们是否产生相同的策略判定结果，从而绕过大语言模型的非确定性。

结论

多智能体编排不仅仅是串联提示词，更是构建健壮的、跨语言的分布式系统。

通过使用 Google ADK 和开放的 A2A 协议，将 Python 的 AI 生态系统与 Go 的运行时可靠性连接起来，您可以获得两全其美的效果：在存在歧义时进行认知推理，在涉及策略时进行确定性执行。

准备好自己运行了吗？

• 克隆 contract-compliance-engine 并在本地运行实时演示
• 探索 ADK 文档，了解会话管理、多智能体模式和评估框架
• 探索 Agent2Agent 协议文档以获取更多详细信息。