企业 AI Agent 落地：从试点到受治理生产

package main

import (
	"errors"
	"fmt"
)

type Action struct {
	Name                string
	Mode                string
	IdempotencyRequired bool
	CompensatingAction  string
}

type Release struct {
	AgentID            string
	Revision           string
	Owner              string
	Approver           string
	RollbackRevision   string
	PolicyRevision     string
	EvaluationRevision string
	CostCurrency       string
	MaxSteps           int
	MaxCost            float64
	TerminalStates     []string
	Actions            []Action
}

func makeSet(values []string) (map[string]struct{}, error) {
	result := make(map[string]struct{}, len(values))
	for _, value := range values {
		if value == "" {
			return nil, errors.New("empty value")
		}
		if _, exists := result[value]; exists {
			return nil, fmt.Errorf("duplicate value %q", value)
		}
		result[value] = struct{}{}
	}
	return result, nil
}

func validateRelease(release Release) error {
	if release.AgentID == "" || release.Revision == "" || release.Owner == "" ||
		release.PolicyRevision == "" || release.EvaluationRevision == "" ||
		release.CostCurrency == "" {
		return errors.New("release, policy, evaluation, cost, and owner identity are required")
	}
	if release.Approver == "" || release.Approver == release.Owner {
		return errors.New("approver must be independent from owner")
	}
	if release.RollbackRevision == "" ||
		release.RollbackRevision == release.Revision {
		return errors.New("independent rollback revision is required")
	}
	if release.MaxSteps <= 0 || release.MaxCost <= 0 {
		return errors.New("positive step and cost limits are required")
	}
	if len(release.Actions) == 0 {
		return errors.New("at least one bounded action is required")
	}

	states, err := makeSet(release.TerminalStates)
	if err != nil {
		return fmt.Errorf("terminal states: %w", err)
	}
	for _, required := range []string{"accepted", "escalated", "blocked", "budget_exhausted"} {
		if _, exists := states[required]; !exists {
			return fmt.Errorf("missing terminal state %q", required)
		}
	}

	names := map[string]struct{}{}
	for _, action := range release.Actions {
		if action.Name == "" {
			return errors.New("action name is required")
		}
		if _, exists := names[action.Name]; exists {
			return fmt.Errorf("duplicate action %q", action.Name)
		}
		names[action.Name] = struct{}{}

		switch action.Mode {
		case "read":
		case "auto", "approval":
			if !action.IdempotencyRequired {
				return fmt.Errorf("%s must require an idempotency key", action.Name)
			}
			if action.CompensatingAction == "" {
				return fmt.Errorf("%s must define compensation", action.Name)
			}
		default:
			return fmt.Errorf("%s has unknown mode %q", action.Name, action.Mode)
		}
	}
	return nil
}

func main() {
	release := Release{
		AgentID:            "refund-triage",
		Revision:           "2026-08-09.1",
		Owner:              "customer-operations",
		Approver:           "finance-control",
		RollbackRevision:   "2026-08-01.3",
		PolicyRevision:     "refund-policy/42",
		EvaluationRevision: "refund-eval/17",
		CostCurrency:       "USD",
		MaxSteps:           12,
		MaxCost:            1.50,
		TerminalStates: []string{
			"accepted", "rejected", "escalated", "blocked", "budget_exhausted",
		},
		Actions: []Action{
			{Name: "customer_profile:read", Mode: "read"},
			{Name: "order:read", Mode: "read"},
			{
				Name:                "refund_draft:create",
				Mode:                "auto",
				IdempotencyRequired: true,
				CompensatingAction:  "refund_draft:delete",
			},
			{
				Name:                "refund:execute",
				Mode:                "approval",
				IdempotencyRequired: true,
				CompensatingAction:  "refund:reverse",
			},
		},
	}

	valid := validateRelease(release) == nil
	invalid := release
	invalid.Approver = invalid.Owner
	selfApprovalRejected := validateRelease(invalid) != nil
	fmt.Printf(
		"release=%s/%s valid=%t self_approval_rejected=%t\n",
		release.AgentID,
		release.Revision,
		valid,
		selfApprovalRejected,
	)
}

release=refund-triage/2026-08-09.1 valid=true self_approval_rejected=true

规划 -> 授权 -> 准备 -> 必要时审批
     -> 携带幂等键执行 -> 回读业务事实系统
     -> 提交终态或补偿 -> 写入证据

已验收 Goodput
  = 受限运营周期内的已验收业务结果数

每个已验收结果成本
  = (模型 + 基础设施 + 集成摊销
     + 操作 + 审批 + 返工 + 事故 + 撤销成本)
    / 已验收业务结果数