Token Lab搜索

JEV · AGENT SYSTEMS

Jev 与 Coding Agent Harness:决策模型、上下文、成本与执行控制

系统讲解类型化决策模型如何接入编码智能体,核查流传的 Jev PDF 与性能宣传,并通过架构、数学算例和本地实现解释可落地的设计。

JevHarnessRLCDContext engineering

来源与版本详情
本文目录

Jev 改变了什么,又把什么留给软件

Coding agent 是一个在模型推理与工具操作之间循环的有状态程序。Harness 是模型周围的运行系统:组织上下文、提供工具、限制预算、记录观察结果,并决定哪些操作可以执行。模型能够提出补丁,但它看到哪个版本的代码、补丁拥有多大权限,由运行系统控制。这两类职责不能混为一谈。

Jev 是 TypeSafe 的决策模型,不是替代代码生成器。它根据输入状态返回有类型的判断 [1]。本文贯穿的场景是:SRE agent 修复 HTTP 客户端重试放大问题。生成模型编写修改,决策服务帮助筛选证据或选择专家;调用者认证、文件读取、权限执行和结果核验仍由软件负责。

读完应能区分判断质量与执行安全、计算路由是否省钱、搭建一个可重放的小型 harness,并设计可信对照。先修不是几个名词:JSON 用于约定数据结构,概率描述结果的不确定性,缓存只有在身份与版本匹配时才可复用。理解 Python 函数和请求超时即可完成本地练习,无需付费模型。

先把传播文案与证据层次分开

流传的 12 页 PDF 自称 2026 年 9 月独立整理材料,未获 TypeSafe 背书;核心是显式状态、按查询组织上下文及受策略控制的路由 [2]。Diogo Almeida 确为 InstructGPT 合著者 [3],但这不能证明 PDF 由他撰写。

TypeSafe 发布报告把 193.6× 速度、444.6× 成本比值归于选定的 System One 工作流,参考答案来自模型概率,而不是人工事实标签 [4]。它不能直接证明 coding agent 的整体提速。用户提供文案中的“两小时配置”也没有配套的可复现实验流程。

一次决策、一个工作流、一次正确的软件修改,是三个不同分母。分类很快,测试套件仍可能很慢;每次尝试便宜,失败重试可能让每次正确修复更贵。本文把传播文案作为待核查线索,并提供原创工程分析与本地模拟,不声称复原未公开的 Jev 内部架构。

从生成句子到有边界的决策

自回归生成器不断在已有前缀条件下预测下一个 token。决策问题则是在预先定义的选项集合上输出判断。TypeSafe 描述了并行决策输出,并将训练方法称为 RLCD [4] [5]。已核查资料没有公开足以复现训练的架构、损失、数据和优化器细节,因此不能自行编造一个 softmax 分类头或强化学习公式冒充 Jev 实现。

对重试事故,“把服务修好”需要调查与综合;“这份证据应交给哪个子系统负责人”则受候选集合约束。后者适合决策接口。真正重要的是给它什么证据:只有报错堆栈、没有重试策略,输出即使结构正确,也可能偏离根因。

约束输出能避免生成集合之外的工具名,却不能避免选错一个合法工具。类似于有类型的函数仍可能返回错误的整数:类型检查保证结构,不保证业务结论。专用决策模型与受 JSON 约束的 LLM 都能返回合法对象;延迟、校准与正确率必须在同一个任务上比较,不能从接口形式推导优劣。

符号中,x 是输入,y₁:T 是生成 token 序列,s 是应用状态,Q 是有类型的问题,A 是允许答案集合。第二个表达式只是接口抽象,不是已公开的 Jev 训练目标。

先设计问题,再选择模型

Choice 在命名选项间选择,Score 表示有序评分档位,Noul 返回一个是非命题成立的概率 [6] [7] [8]。三者的语义不能混用。相关度 0.8 不自动等于补丁正确概率 80%;从三个子系统中选出一个,也不证明根因一定存在于这三个选项里。

本文的证据包包含目标、仓库版本、失败断言、有限文件片段、允许的候选 ID 和缺失证据说明。分别问“证据是否充分”和“哪个候选最相关”。证据不足应触发补充检索,不能悄悄变成“反正选一个最像的”。缺失信息与相互矛盾的信息还应记录为不同原因。

同一快照上的独立问题可批量询问,例如相关性、归属、证据缺口。若问题 B 依赖 A 的答案,应由代码组织第二阶段,不能把同一请求误当成条件推理链。阈值和问题模板都需版本化,修改评分标准后应产生新版本,避免旧日志的语义被悄然改变。

校准、分布集中度与错误代价

TypeSafe 的 Choice confidence 将最高概率相对均匀分布重新缩放 [9]。三个选项、最高概率 0.8 时,confidence 是 0.7。两者来自同一个输出,同时检查并不构成两份独立证据。Noul 自身就是概率,没有额外 confidence 字段。

校准是一种群体性质:预测在 0.8 附近的事件,应约有 80% 真正发生。校准良好不等于区分能力强;始终输出基础发生率也可能校准,但无法有效排序。高准确率模型也可能在少数高损失事件上严重过度自信。应按仓库、语言、操作类别分层观察,并关注模型或问题模板变化后的分布漂移。

原创决策论算例:假设误操作损失 100 个效用单位,人工复核成本 2,且假定复核完全正确。自动操作的期望损失是 (1−p)×100,只有 p>0.98 才比复核更优。这不是生产推荐阈值:人也会错,各操作损失不同,预测概率需要本地校验。概率估计从不授予权限。

贯穿重试事故的参考架构

控制器先创建任务 ID,验证调用者的仓库访问范围,并固定 commit。读取器只取允许的文件,附带路径、行范围与哈希。敏感信息在任何外部决策请求之前过滤:便宜的路由模型同样是外部数据接收方。状态库保存不可变观察记录,控制器维护当前任务状态;两类模型都不能直接改写权限策略。

上下文构建器固定保留强制指令与失败断言,再按 token 预算加入证据。决策适配器提出模型路由,策略过滤器将建议与允许提供商、剩余预算取交集。生成模型返回补丁提案;执行器核对确切补丁和任务范围后,才在隔离 worktree 中应用。执行结果重新进入状态库,但工具输出只是数据,不是新的权限来源。

每条连接都要定义失败行为。决策服务超时则回到原有保守路由或人工复核;响应畸形不得执行工具;快照过期重新读取。任务取消后不能发起新动作,但已发出的外部请求仍可能计费。特权派发之前必须持久化审计记录;崩溃后先核对未知结果,不能盲目重试写操作。

原创参考架构:决策建议必须经过策略,只有获授权的执行器可以操作。虚线表示观察记录。不是 TypeSafe 内部架构;点击查看原尺寸。
原创参考架构:决策建议必须经过策略,只有获授权的执行器可以操作。虚线表示观察记录。不是 TypeSafe 内部架构;点击查看原尺寸。
组件输入 → 输出不能据此证明什么
决策模型证据与候选 → 概率权限或事实必然正确
上下文构建器允许的片段与预算 → 证据包省略的证据一定不相关
策略引擎身份、动作与范围 → 允许/复核/拒绝获准的补丁一定正确
执行器获授权提案 → 观察结果超时意味着没有副作用
独立验证器补丁与固定检查 → 结果超出覆盖范围的普遍正确性

上下文选择是有预算的证据分配

在重试修复中,“不可删除重试上限”这条约束、当前实现和失败断言,通常比上周讨论的漂亮摘要重要。一个 chunk 因此不能只有文本:还需要 ID、版本、来源、可见等级、token 估计、访问范围以及是否强制保留。摘要应指向原文,不能取代权威源。

下式是教学模型:为每个片段 i 选择一种表示 v,在预算 B 内最大化估计效用。效用不是事实;考虑片段依赖后更复杂,例如函数定义和调用点单独看都不突出,组合起来却不可缺少。先保留关键契约,并给输出预留空间;若预算连必需证据都放不下,应直接拒绝,不能静默删除权限规则。

稳定的策略前缀有利于复用,但每轮重排全部证据可能破坏缓存。应分别版本化稳定区域与任务区域,记录决策依赖的源哈希,并在源变化时失效派生摘要。仓库搜索也可能是瓶颈;FastContext 对此有独立研究 [10],其结果不能改称 Jev 实测。

计算整条路径,不能只看便宜的那次调用

原创合成价格模型分别计算未缓存输入、缓存输入、输出和决策服务费用。假定一次步骤有 10,000 输入 token,按每百万 2 美元计;1,000 输出 token,按每百万 8 美元计,则为 0.028 美元。价格仅用于算术,不是当前厂商报价。便宜路径本身 0.010 美元,但移交和复核增加 0.015、路由增加 0.001,合计 0.026,只省约 7.1%;再增加 0.004 的期望重试费用就更贵。

Amdahl 定律给出另一个边界。假设决策调用占总耗时 20%,且这部分快 200 倍,其余不变,则任务整体仅快 1/(0.8+0.2/200),约 1.248 倍。如果生成代码、CI 和审批占主导,这才是应该使用的直觉。并行流程要看关键路径,不能把重叠 span 的时间直接相加。

应比较每次验收合格修复的成本:失败、审核、检索和基础设施的总成本,除以同一正确性标准下的合格修复数。固定仓库快照、难度和缓存条件。提示缓存与 GPU KV 驻留有关联,但不是同一个计费合同,不能假设不同模型间自动复用。

其中 nᵤ、n꜀、nₒ 分别是未缓存输入、缓存输入和输出 token 数,pᵤ、p꜀、pₒ 是对应每百万 token 的美元价格,C_d 为决策费用。S 中 f 是原耗时占比,s 是该部分加速倍数;公式假设串行分解且其他工作不变。

原创 Amdahl 算例:决策调用快 200 倍。横轴为原决策时间占比,纵轴为整个任务的加速比。属于合成上界,不是 Jev 性能实测。
原创 Amdahl 算例:决策调用快 200 倍。横轴为原决策时间占比,纵轴为整个任务的加速比。属于合成上界,不是 Jev 性能实测。

建议不是执行凭证

重试案例的授权是准备补丁,不是部署。即使模型极有把握地建议重启生产,也仍然越权。模型路由前检查允许动作与目标,真正派发前再次核验,避免旧审批被拿来执行新补丁。审批应绑定任务 ID、动作摘要、目标、有效期与仓库版本。

不能靠查几个危险字符串保护 shell:引号、子进程、模块导入和符号链接都会绕开粗糙规则。优先使用窄范围类型化操作、规范路径、无生产凭证沙箱、受控网络出口和资源限额。叫作“test”的命令也会执行仓库代码。分类器可以标记可疑意图,却不能证明任意脚本安全。

提示注入可能来自代码注释、日志和检索结果。应标记来源,把检索文本与控制指令分离。即使“忽略策略”的判断概率是 1.0,也没有授权。写请求超时不表示未执行;需用操作 ID 查询状态、协调结果。本地 SQLite 事务无法让外部 API 与审计库组成一个原子事务。

先接入一个决策点,再考虑重建 Agent

接入深度分三层:skill 提供实现指导;可调用工具把决策服务暴露给现有 agent;原生 harness 才掌控每轮上下文、状态转换和权限边界。安装一个 skill 并不获得第三层能力。必须核实实际 agent 版本支持哪些扩展,不能承诺它能自动拦截所有轮次。

从只读证据排序开始:同时保存旧排序与候选排序,暂不改变执行。审阅分歧后,再对少量任务启用,并保留立即回退开关。之后只有当证据包能独立传递、返回结果紧凑且可追溯时,才引入模型路由。

生产适配器需要验证响应结构、记录解析后的模型版本、设截止时间、限制并发并计算失败尝试费用。限流不能无限重试。缓存键应包含模型、问题、策略版本和状态哈希,不能跨租户复用。文末链接官方 API 与 skill [11] [12]。本站不发起付费请求;练习使用明确的固定响应,API 示例仅展示请求契约,未声称实际调用成功。

何时值得使用,以及哪些问题仍未解决

确定性事实优先普通代码:允许名单和精确结构检查无需模型。广义语义排序可以先考虑 embedding 或 reranker。带丰富上下文的有界判断适合尝试专用决策模型;创造新算法或编写补丁仍需要生成模型。几类组件可以协作,不必把每个分支都改成 AI 请求。

购买方往往是开发平台或 agent 基础设施团队,关心的是在质量、隐私约束下每单位成本能完成多少正确任务。专用厂商竞争延迟、校准与集成质量;通用模型厂商可捆绑路由并利用缓存局部性;harness 厂商掌握工作流和审计;自托管分类器改善数据控制,却带来训练与运维负担。这是控制点分析,不是市场份额排名,也不暗示未经核实的融资或收购。

未解决的问题包括罕见事件校准、发现候选集合遗漏、上下文裁剪后的依赖完整性、多个判断器的相关错误,以及人工审核之后的真实节省。闭源内部也限制独立归因。更快的判断可能诱发过度并行与更高账单。有界路由是有价值的工程改进,却不构成 agent 递归提高自身智能的证据。

实践、验证与面试训练

使用 Python 3.11 或更高版本运行:python3 lab.py。不需要依赖包、凭证或网络。固定响应完全确定,因此无需随机种子。SQLite 使用内存数据库;相同请求重放后,最终留下五条不同决策。这验证请求身份去重,不代表实现了跨进程的持久恢复。

按控制流读代码:先保留必需证据,再验证概率分布并提出路由;策略可无视高概率而拒绝动作;输入哈希用于识别重放。贪心选择器是教学简化,不保证全局最优。token 数是固定样例估计,不是真实 tokenizer 测量。示例不执行 shell、不生成或应用代码补丁。

输出应选择 policy/assertion/implementation;过小预算被拒绝;低把握与畸形回答进入 review;部署被 deny;仓库版本变化产生新记录。继续注入未经批准的提供商、NaN 概率、缺失候选和策略新版本:预期分别为复核、结构拒绝、结构拒绝、新身份。在替换为持久数据库前,还应增加并发写入与崩溃恢复用例。

真实对照先固定仓库与留出任务,再调阈值。比较原 agent、确定性启发式、结构化输出 LLM 和 Jev,保持工具权限相同。分别增加上下文选择和路由,避免混杂。记录任务成功率、每次合格修复成本、p50/p95 延迟、缓存命中、人工审核时间及越权事件。按难度分层、重复运行、报告不确定性,不能删除失败运行。校准集用于选择阈值,最终测试集必须独立。

概率评估可计算二元 Brier score,即 (p−y)² 的平均值;示例结果为 0.255。四个样例不能证明校准。还要画阈值变化时的自动处理覆盖率与错误率:全部交给人也可能显得很准确,但没有自动化价值。故障场景应覆盖证据缺失、注入指令、服务中断、过期哈希和写操作结果未知。

下载完整本地 Python 实验
"""Python 3.11+, standard library only. Offline harness simulation, NOT Jev.
No network, shell execution, real code edits, GPU or model benchmark.
Run: python3 lab.py
"""
from dataclasses import dataclass
from hashlib import sha256
import json
import math
import sqlite3

@dataclass(frozen=True)
class Chunk:
    id: str
    revision: str
    text: str
    tokens: int  # Synthetic fixture sizes, not a tokenizer measurement.
    utility: float
    mandatory: bool = False


def select(chunks, budget):
    if budget < 0 or len({c.id for c in chunks}) != len(chunks):
        raise ValueError("invalid budget or duplicate chunk")
    if any(c.tokens <= 0 or not math.isfinite(c.utility) for c in chunks):
        raise ValueError("invalid chunk")
    pinned = [c for c in chunks if c.mandatory]
    left = budget - sum(c.tokens for c in pinned)
    if left < 0:
        raise ValueError("mandatory evidence exceeds budget")
    result = pinned[:]
    # A transparent greedy heuristic; not an optimal dependency-aware solver.
    for c in sorted((c for c in chunks if not c.mandatory),
                    key=lambda c: (-c.utility / c.tokens, c.id)):
        if c.tokens <= left:
            result.append(c)
            left -= c.tokens
    return result


def validate_answer(answer):
    if not isinstance(answer, dict) or set(answer) != {"choice", "probabilities"}:
        raise ValueError("invalid answer schema")
    p = answer["probabilities"]
    if not isinstance(p, dict) or set(p) != {"local", "frontier", "review"}:
        raise ValueError("unknown candidates")
    if any(type(x) not in (int, float) or not math.isfinite(x) or not 0 <= x <= 1
           for x in p.values()) or not math.isclose(sum(p.values()), 1.0, abs_tol=1e-8):
        raise ValueError("invalid probabilities")
    if answer["choice"] not in p or p[answer["choice"]] != max(p.values()):
        raise ValueError("choice does not match maximum")
    return p


def choose_route(answer, action, policy):
    # These are typed fixture actions. No shell-string safety claims.
    if action not in policy["allowed_actions"]:
        return "deny"
    try:
        p = validate_answer(answer)
    except ValueError:
        return "review"
    target = answer["choice"]
    if target not in policy["eligible_routes"] or p[target] < policy["threshold"]:
        return "review"
    return target


def record(db, state, action, policy, answer):
    # Identity includes all decision inputs, not just an action name.
    payload = json.dumps([state, action, policy, answer], sort_keys=True,
                         separators=(",", ":"), allow_nan=False)
    key = sha256(payload.encode()).hexdigest()
    existing = db.execute("SELECT result FROM events WHERE id=?", (key,)).fetchone()
    if existing:
        return existing[0], True
    result = choose_route(answer, action, policy)
    with db:
        db.execute("INSERT INTO events VALUES (?, ?, ?)", (key, payload, result))
    return result, False


def run():
    policy = {"version": "policy-1", "allowed_actions": ["inspect", "propose_patch"],
              "eligible_routes": ["local", "frontier", "review"], "threshold": 0.9}
    chunks = [Chunk("policy", "r1", "Keep retry cap; do not deploy.", 40, 1, True),
              Chunk("assertion", "r1", "Expected at most three attempts.", 60, 1, True),
              Chunk("implementation", "r1", "Current retry loop.", 120, 0.96),
              Chunk("old_chat", "r0", "Superseded discussion.", 400, 0.1)]
    chosen = select(chunks, 240)
    assert [x.id for x in chosen] == ["policy", "assertion", "implementation"]
    try:
        select(chunks, 99)
    except ValueError:
        pass
    else:
        raise AssertionError("must reject missing mandatory evidence")
    state = {"task": "retry-incident", "revision": "r1", "question_version": "q1",
             "chunks": [c.__dict__ for c in chosen]}
    good = {"choice": "local", "probabilities": {"local": 0.94, "frontier": 0.04, "review": 0.02}}
    low = {"choice": "local", "probabilities": {"local": 0.55, "frontier": 0.4, "review": 0.05}}
    malformed = {"choice": "delete_production", "probabilities": {"other": 1.0}}
    # In-memory SQLite tests replay logic without leaving personal data behind.
    with sqlite3.connect(":memory:") as db:
        db.execute("CREATE TABLE events (id TEXT PRIMARY KEY, payload TEXT, result TEXT)")
        assert record(db, state, "inspect", policy, good) == ("local", False)
        assert record(db, state, "inspect", policy, good) == ("local", True)
        assert record(db, state, "inspect", policy, low)[0] == "review"
        assert record(db, state, "inspect", policy, malformed)[0] == "review"
        assert record(db, state, "deploy", policy, good)[0] == "deny"
        changed = dict(state, revision="r2")
        assert record(db, changed, "inspect", policy, good) == ("local", False)
        count = db.execute("SELECT COUNT(*) FROM events").fetchone()[0]
        assert count == 5
    n, p = 3, 0.8
    confidence = (p - 1/n) / (1 - 1/n)
    speedup = 1 / (0.8 + 0.2/200)
    assert math.isclose(confidence, 0.7)
    # Synthetic binary forecasts; Brier is not measured on Jev.
    forecasts, outcomes = [0.9, 0.8, 0.4, 0.1], [1, 0, 1, 0]
    brier = sum((p-y)**2 for p, y in zip(forecasts, outcomes)) / len(outcomes)
    print(json.dumps({"mode": "offline_fixture_not_jev", "network_calls": 0,
                      "selected_chunks": [x.id for x in chosen], "audit_rows": count,
                      "choice_confidence": round(confidence, 6),
                      "synthetic_task_speedup": round(speedup, 6),
                      "synthetic_brier": round(brier, 6),
                      "replay_schema_policy_revision_checks": "passed"}, indent=2))

if __name__ == "__main__":
    run()

预期输出

{
  "mode": "offline_fixture_not_jev",
  "network_calls": 0,
  "selected_chunks": [
    "policy",
    "assertion",
    "implementation"
  ],
  "audit_rows": 5,
  "choice_confidence": 0.7,
  "synthetic_task_speedup": 1.248439,
  "synthetic_brier": 0.255,
  "replay_schema_policy_revision_checks": "passed"
}

可选接入契约:未实际调用

下方 JSON 是按核对当日官方 POST https://api.typesafe.ai/v1/systemone 契约写的请求体示例,本页不会发送。认证按官方文档配置,凭证保存在私有服务端,不能放进静态站点。记录 jev-latest 实际解析到的模型版本;使用 SDK 时保存依赖锁文件,并验证响应结构。本文没有声称完成真实 API 调用验证。

{
  "model": "jev-latest",
  "state": {
    "goal": "Identify evidence for a retry amplification incident",
    "revision": "example-r1",
    "evidence": "Fixture: retry loop restarts its attempt counter after a timeout; required cap is three attempts."
  },
  "questions": {
    "subsystem": {
      "type": "choice",
      "instructions": "Which subsystem is directly implicated by the supplied evidence?",
      "criteria": {
        "retry_control": "Attempt counting, stopping and retry budget",
        "rendering": "Displaying a user interface",
        "unknown": "The supplied evidence does not identify a subsystem"
      }
    }
  }
}

原创模拟面试题,非公司真实题目

1. 为何单次决策快 200 倍不等于任务快 200 倍?

提示:找不变的关键路径。答案: 时仅约 1.248 倍;还要算路由开销、CI 与重试。

2. confidence 0.99 能授权部署吗?

提示:区分判断与权力。答案:不能。即使理解概率语义,仍需范围、目标、审批和当前动作摘要的授权核验。

3. 便宜模型路由什么时候反而更贵?

提示:计算两次移交。答案:上下文重载、审核、缓存损失和失败费用可能超过生成节省;按同一任务的合格修复单价比较。

4. 怎样区分有效校准与把任务全推给人工?

提示:风险与覆盖率一起看。答案:同时报告自动处理错误率、自动化覆盖率、审核成本;用留出结果并覆盖罕见高损失类别。

评分:1 分—复述术语;2 分—区分模型与 harness;3 分—运行示例并解释成本和置信度;4 分—处理版本、失败与授权;5 分—设计公平的任务级对照,并说明结论边界。

继续学习

把基础真正讲清楚

回顾本方法依赖的共同基础,再通过算例与检查定位理解上的缺口。

Agent 是有状态的控制循环:观察、提出动作、检查权限、执行,再检查结果。工具参数结构只说明输入是否合法,不能证明调用者有权限,更不能证明副作用已经发生。模型生成的文字只是提议,不是可信执行证据。应区分尝试调用、收到成功响应和验证任务真正完成。

先独立推理,再看答案

支付工具收到请求后超时,没有返回成功。Agent 是否应该立即重试?

逐步解析

不应该。超时意味着结果未知:支付可能已经成功,只是响应丢失。需要幂等键和状态查询,或暂停等待核对。盲目重试可能重复执行不可逆操作。限制步数只能限制尝试次数,不能修复这个正确性问题。

为什么在应用中重要

因此工具助手需要由应用维护状态、授权和停止条件。状态应记录哪些事实已知、哪些结果不确定、哪些动作仍需确认。只有能验证完成状态并控制动作范围,增加自主性才有意义。

怎样证明自己理解了

用同一流程追踪成功、拒绝、超时和格式错误响应。断言拒绝的动作绝不执行,重试保持幂等;分别限制步数、时间和费用。先用本地模拟工具验证,再考虑真实副作用。

运行完整 Python 算例

Python 3.10+ · 仅标准库 · 确定性计算,无需随机种子 · 不联网。保存文件后执行下方命令。这些是教学检查,不是模型基准。

下载 Python · agent.py
python3 agent.py
# Python 3.10+; standard library; deterministic; no network.
# In-memory mock only: no real payment or network call.
ledger = {}
def pay(key, amount):
    if key in ledger:
        if ledger[key] != amount:
            raise ValueError("same key with different request")
        return "already applied"
    ledger[key] = amount
    return "applied"

assert pay("order-1", 10) == "applied"
# Pretend the reply was lost. Reconcile and retry with the same key.
assert ledger.get("order-1") == 10
assert pay("order-1", 10) == "already applied"
assert len(ledger) == 1
try:
    pay("order-1", 20)
    raise AssertionError("conflicting retry accepted")
except ValueError:
    pass
print("one effect; duplicate retry suppressed")

预期输出

one effect; duplicate retry suppressed

补齐先修知识 →

基础讲解更新:

参考资料与延伸教程

  1. TypeSafe — Introductionhttps://docs.typesafe.ai/introduction
  2. Jev Engineering for Coding Agents — PDF · 2026-09https://jevforagents.com/media/Jev-Engineering-for-Coding-Agents.pdf
  3. InstructGPT — arXiv:2203.02155v1 · 2022-03-04https://arxiv.org/abs/2203.02155v1
  4. TypeSafe — Introducing System One Models & Jev · 2026-09-15https://typesafe.ai/blog/introducing-system-one-models-and-jev
  5. TypeSafe — AI primer / RLCDhttps://docs.typesafe.ai/introduction/machine-learning-primer
  6. TypeSafe — Choicehttps://docs.typesafe.ai/primitives/choice
  7. TypeSafe — Scorehttps://docs.typesafe.ai/primitives/score
  8. TypeSafe — Noulhttps://docs.typesafe.ai/primitives/noul
  9. TypeSafe — Confidencehttps://docs.typesafe.ai/confidence
  10. FastContext — arXiv HTML v1https://arxiv.org/html/2606.14066v1
  11. TypeSafe — API / Quick starthttps://docs.typesafe.ai/introduction/quickstart
  12. TypeSafe — Agent skillshttps://github.com/typesafe-ai/skills
  13. TypeSafe — Workflow evaluationshttps://evals.typesafe.ai/
  14. InstructGPT — PDF v1https://arxiv.org/pdf/2203.02155v1
  15. FastContext — abstract / version historyhttps://arxiv.org/abs/2606.14066v1
  16. FastContext — PDF v1https://arxiv.org/pdf/2606.14066v1
来源与版本详情

带着问题看视频

观看 → 解释 → 实现 → 测试

以下为外部英文视频,字幕与可用性由 YouTube 提供。点击播放后才连接 YouTube,不发送实验输入。

把一个案例讲完整

预订 Agent 必须完成且仅完成一个授权任务

这是合成教学场景与手算数据,不是生产基准。同主题课程共用这个案例,便于从不同角度追踪同一个系统。

案例更新:

员工要求 Agent 预订预算内的可退款酒店。搜索可以撤回,预订会花钱。Agent 可以提出行程,但身份、额度和精确审批必须由可信服务强制执行。衡量成功的依据是真实确认的预订,而不是流畅的结束语。

100+ 10= 110100
合成重试账本:100个任务加10次重试仍有110次请求;去重可让已提交效果保持100次。

1. 把请求变成有边界的状态机

任务依次经过搜索、提议、审批、提交、验证。明确日期、币种、退款条款和最高金额;日期缺失就澄清。网页中的“忽略预算”是不可信内容,不是新的用户指令。每次状态转移都应检查前置状态并记录原因。

2. 审批精确动作

将审批绑定酒店、日期、价格和条款。提交前重新检查库存与价格,价格变化使旧审批失效。执行服务使用窄权限凭据。模型不能自行提供花钱权限,也不能把笼统的“不错”解释成对实质不同购买的授权。

3. 恢复结果不确定的操作

提交后超时不代表失败。重试前用稳定操作键查询供应商。教学数据中100项任务有10项成功后超时,盲重试产生110次业务效果;幂等重试维持100次。业务上恰好一次需要供应商支持或对账,不是加个重试计数器。

4. 验证并改进,不扩张权限

返回供应商确认、已审批条款和未解决异常。追踪工具调用并记录恢复原因,限制步数和时长,避免不可能完成的任务无限循环。可改进搜索和规划,但必须保留独立权限检查;规划更聪明不等于执行更安全。

证据与取舍

指标/条件基线对照解释
业务效果次数100 + 10 = 110100仅在所述幂等假设成立时避免重复购买。
每个原任务的重复率10/100 = 10%0/100 = 0%这是教学构造,不是服务实测保证。
含重试的提交请求100 + 10 = 110100 + 10 = 110幂等控制效果,不减少请求次数。

验收与失败测试

注入成功提交后的超时、重复操作键、修改审批价格、撤销凭据并耗尽步数。断言仅一份确认预订,拒绝变更购买;无法验证时进入有边界的待解决状态。

Python 3.10+ · topic-cases.py ↓

python3 topic-cases.py

这个例子的适用边界

示例省略并发工作进程、供应商故障和外部状态不一致。生产需要原子去重、对账及补偿策略;取消可能收费,不能视为通用回滚。

下一步学什么

测试错误参数、过期权限与重复重试,检查最终状态。

实现与验收 → · 继续学习路线 →
学习指南与本课目录学习目标与验收

理解 → 实现 → 研究

用同一流程追踪成功、拒绝、超时和格式错误响应。断言拒绝的动作绝不执行,重试保持幂等;分别限制步数、时间和费用。先用本地模拟工具验证,再考虑真实副作用。

预测、检验与证据记录

展开答案前先预测一个结果;练习后记录差异和迁移测试。记录仅存本地,在不同语言版本间共用。

打开记录/导出/清除 →

数学复核范围逐篇记录,不代表完成论文实证复现;可在笔记中记录疑似错误。 复核范围