Article Index

共 141 篇主体文章。本文仅按 canonical module 分组用于检索；不表达默认课程顺序。默认学习路径见 90-days/13-week-map.md。

01. Agent 与 Harness 基础

• Agent、Workflow 与 Harness：控制权、执行权与系统边界 — 01-01, 01-02, 01-03
• 控制平面、执行平面与 Agent 协作模式 — 01-04, 01-05, 01-06
• 长任务 Agent：持续进度、恢复与 Harness 演进 — 01-07, 01-08

02. 模型层与结构化交互

• 一次模型调用受哪些硬边界约束：Token、Context Window、Sampling 与 Latency — 02-01
• 模型输入到底是什么：Message、Item、Event 与 Instruction Hierarchy — 02-02, 02-03
• Structured Output、Schema Validation 与 Tool Calling — 02-04, 02-05, 02-06
• 如何隔离 Provider 差异：Streaming、Adapter 与 Capability — 02-07, 02-08, 02-09
• 模型调用失败后怎么处理：Error Taxonomy、Routing 与 Fallback — 02-10, 02-11
• 怎么在不依赖真实模型的情况下测试 Runtime：Fake Model 与 Deterministic Tests — 02-12
• 一次 Run 如何可复现：Version Snapshot 与 Run Manifest — 02-13, 02-14

03. Python 工程

• Python 项目怎样可复现又可维护：Package、uv 与 Typing — 03-01, 03-02, 03-03
• 核心接口怎么建模：Protocol、ABC、dataclass 与 Pydantic — 03-04, 03-05, 03-06
• 失败和资源生命周期怎么管：Exception、Context Manager 与 Logging — 03-07, 03-08, 03-09
• 如何隔离外部依赖做测试：pytest、Fixtures 与 Test Doubles — 03-10, 03-11, 03-12
• 配置和依赖应该在哪一层注入：Configuration 与 Dependency Boundary — 03-13, 03-14

04. Context Engineering

• 为什么只写 Prompt 不够：从 Prompt Engineering 到 Context Engineering — 04-01, 04-02, 04-03
• Context 如何组装：Assembly Pipeline 与 Token Budget — 04-04, 04-05
• Context 如何选：Selection Signals、Progressive Disclosure 与 JIT — 04-06, 04-07, 04-08, 04-09
• Tool 如何撑爆 Context：Definition Cost 与 Result Management — 04-10, 04-11
• Context 什么时候该压缩、什么不能丢：Compaction、Trigger 与 Fidelity — 04-12, 04-13, 04-14, 04-15
• 长任务如何跨 Context 延续：Structured Artifacts 与 Reset — 04-16, 04-17
• Context 优化是否真的有效：Cache 与 Evaluation — 04-18, 04-19

05. Retrieval 与 RAG

• RAG 从哪里开始：Retrieval 边界、架构模式与 Ingestion — 05-01, 05-02, 05-03
• 文档怎样变成可检索索引：Chunking、Embedding 与 Vector Store — 05-04, 05-05, 05-06
• 一次检索请求怎样被约束：Retriever、Metadata Filter 与 Query Rewrite — 05-07, 05-08, 05-09
• 语义搜还是关键词搜：Semantic、BM25 与 Hybrid Search — 05-10, 05-11, 05-12
• 召回之后如何形成证据：Reranking、Threshold 与 Grounding — 05-13, 05-14, 05-15
• Agent 什么时候该检索：Pre-Retrieval、Retrieval Tool 与 Failure Modes — 05-16, 05-17, 05-18
• 怎么判断检索真的变好了：Retrieval 与 RAG Evaluation — 05-19, 05-20, 05-21

06. Tool 工程

• 什么才是好 Tool：Contract、Granularity 与 Naming — 06-01, 06-02, 06-03
• 让模型稳定调用 Tool：Schema、Examples 与 Registry — 06-04, 06-05, 06-06
• Tool 太多时怎么暴露：Metadata、Dynamic Exposure 与 Discovery — 06-07, 06-08, 06-09
• 从发现 Tool 到可回灌结果：Search、Execution、Normalization 与 Result Budget — 06-10, 06-11, 06-12, 06-18
• 一次 Tool 批次如何安全执行：Parallel Call、Error 与 Timeout — 06-13, 06-14, 06-15
• Tool 失败后能不能重试：Retry Eligibility 与 Idempotency Contract — 06-16, 06-17
• Tool 能力怎么扩展且不失控：Programmatic Calling 与 Evaluation — 06-19, 06-20

07. Planning 与 Orchestration

• 开放任务怎么拆：Task Decomposition、ReAct 与 Plan-and-Execute — 07-01, 07-02, 07-03
• 计划如何被验证并修正：Replanning、Structured Plan、Validation 与 Evaluator — 07-04, 07-05, 07-06, 07-09
• Plan 如何进入 Runtime：Graph Compilation 与 Code / LLM Orchestration — 07-07, 07-08
• 常见编排模式怎么选：Router、Fan-out、Manager 与 Handoff — 07-10, 07-11, 07-12
• Multi-Agent 为什么容易失控：Context Isolation 与 Planning Failure — 07-13, 07-14

08. Async 与 Concurrency

• asyncio 到底在调度什么：Coroutine、Event Loop 与 Awaitable — 08-01, 08-02, 08-03
• Task、TaskGroup 与 Structured Concurrency — 08-04, 08-05, 08-06, 08-16
• 异步任务怎样超时、取消和限流：Cancellation、Timeout 与 Semaphore — 08-07, 08-08, 08-09
• Harness 内部任务如何排队而不失控：asyncio.Queue、Producer / Consumer 与 Race — 08-10, 08-11, 08-12
• Harness 共享状态怎么保护：Lock、Coroutine、Thread 与 Process — 08-13, 08-14
• Harness 工作该放 Event Loop、Thread 还是 Process：I/O 与 CPU 并发选择 — 08-15

09. Execution Runtime

• 一次 Run 如何被推进：Lifecycle、State Machine 与 Node Transition — 09-01, 09-02, 09-03
• Graph 怎样变成可执行依赖：Representation、Validation 与 Cycle Detection — 09-04, 09-05, 09-06
• DAG 怎么调度：Ready Queue、Parallel Execution 与 Scheduler — 09-07, 09-08, 09-09
• 运行中的并发怎么收住：Concurrency Limit、Cancellation 与 Deadline — 09-10, 09-11, 09-12
• 局部失败如何传播：Partial Failure 与 Runtime Invariants — 09-13, 09-14, 09-15
• Run 怎样安全暂停再继续：Pause、Checkpoint 与 Pending Writes — 09-16, 09-17, 09-18
• 历史执行怎样重放和分叉：Replay、Determinism、Fork 与 Time Travel — 09-19, 09-20
• 长 Run 什么时候必须停：Long-running Execution 与 Termination — 09-21, 09-22
• 多个 Worker 抢同一个 Run 怎么办：Claim、Lease、Heartbeat 与 Fencing — 09-23
• Run 等几个小时还能继续吗：Durable Wait、Timer 与 External Event — 09-24

10. State、Session 与 Memory

• Run、Session 和 Durable State 到底各保存什么 — 10-01, 10-02, 10-03
• 运行中的信息放哪里：Conversation、Checkpoint 与 Short-Term Memory — 10-04, 10-05, 10-06
• 什么值得长期记住：Long-Term Memory 的写入与检索 — 10-07, 10-08, 10-09
• 一条 Memory 还能不能信：Provenance、Freshness、Conflict 与 Isolation — 10-10, 10-11, 10-12
• 哪些信息能用于恢复：Memory、RAG、Event Log 与 Crash Recovery — 10-13, 10-14, 10-15
• 昨天保存的 Run，今天的新代码还能恢复吗：State Schema Versioning 与 Migration — 10-16

11. Reliability 与 Human Control

• 一次 Run 的时间预算怎么传下去：Timeout、Deadline 与 Retry 分类 — 11-01, 11-02, 11-03
• 重试怎样避免放大故障：Backoff、Retry Budget 与 Idempotency — 11-04, 11-05, 11-06
• 如何限制重复和过载：Dedup、Rate Limit 与 Concurrency Limit — 11-07, 11-08, 11-09
• 下游故障后怎么继续服务：Circuit Breaker 与 Graceful Degradation — 11-10, 11-11
• Human Control 如何跨进程工作：HITL、Interrupt、Approval 与 Resume — 11-12, 11-13, 11-14, 11-15, 11-16
• Guardrails 能管什么、不能管什么：Input、Output 与 Tool Checks — 11-17, 11-18

12. HTTP 与 Streaming

• 一次 HTTP 调用经历什么：Lifecycle、Connection Pool 与 Timeout Layers — 12-01, 12-02, 12-03, 12-04
• 长任务 API 用普通 REST 还是 Streaming HTTP — 12-05, 12-06
• Agent 事件怎么推给前端：SSE、WebSocket 与 Event Stream — 12-07, 12-08, 12-09, 12-14
• 客户端断开后上游该不该停：Disconnect 与 Cancellation Propagation — 12-10, 12-11
• 流式响应为什么会堵住：Backpressure 与 Gateway Timeout — 12-12, 12-13

13. Database 与 Durable Storage

• Runtime 数据库怎样设计 Key 和 Index：Schema、Key 与 Index — 13-01, 13-02, 13-03
• 数据库并发边界：Transaction、Isolation、Optimistic Concurrency 与 Pool — 13-04, 13-05, 13-06, 13-07
• Runtime 事实怎么落表：Run、Node Execution 与 Attempt Identity — 13-08, 13-09
• 哪些 Runtime 事实必须持久化：Tool、Checkpoint 与 Approval — 13-10, 13-11, 13-12
• 数据库提交和外部副作用如何衔接：Event Log、Outbox 与 Side-effect Consistency — 13-13, 13-14, 13-15
• 外部 Tool 不能回滚怎么办：Transactional Boundary 与 Compensation — 13-16, 13-17

14. Cache、Redis 与 Queue

• Harness 哪些数据值得缓存：Cache Aside、TTL、Invalidation 与 Stampede — 14-01, 14-02, 14-03
• Harness 多实例怎样共享短期协调状态：Redis、Atomic Operations 与 Distributed Rate Limit — 14-04, 14-05, 14-06, 14-07
• Run/Node 发给 Worker 后会发生什么：Queue、Ack、Redelivery 与 At-least-once — 14-08, 14-09
• Worker 失败后怎样重投而不重复副作用：Idempotent Worker、Retry Queue 与 DLQ — 14-10, 14-11, 14-12
• Harness Worker 怎么扩容而不压垮 Provider/DB：Concurrency、Prefetch 与 Backpressure — 14-13, 14-14

15. MCP

• MCP 的执行边界：Host、Client、Server 与 Stateless Core — 15-01, 15-02, 15-03
• MCP 如何发现能力：Self-describing Request、Discovery 与 Tools — 15-04, 15-05, 15-06
• MCP 如何表达内容与模板：Resources 与 Prompts — 15-07, 15-08
• MCP 无状态请求如何路由和缓存：Header Routing 与 Cacheable Lists — 15-09, 15-10
• MCP 谁可以调用什么：Authorization、OAuth 与 Enterprise Managed Auth — 15-11, 15-12, 15-18
• 一次 MCP 交互为什么可能多轮：MRTR、Elicitation 与 Extensions — 15-13, 15-14, 15-15
• MCP Core 之外怎样扩展长任务和 UI：Tasks Extension 与 Apps — 15-16, 15-17
• MCP 进入生产环境后的边界：Tracing、Migration 与 Security — 15-19, 15-20, 15-21
• MCP 如何接入现有 Harness：Gateway、Conformance 与 Adapter — 15-22, 15-23, 15-24

16. Workspace 与 Coding Agent

• Coding Agent 的工作环境是什么：Workspace 与 Filesystem State — 16-01, 16-02, 16-03
• 代码修改如何成为可验证动作：Shell、Patch 与 Command Lifecycle — 16-04, 16-05, 16-06
• 长命令和代码变更怎么管：PTY、Git 与 Verification — 16-07, 16-08, 16-09
• 如何证明 Coding Agent 真做完了：Tests、Artifacts 与 Manifest — 16-10, 16-11, 16-12
• 跨进程继续代码任务：Sandbox Session、Snapshot 与 Resume — 16-13, 16-14, 16-15
• Coding Agent 如何跨 Context 持续推进：Skills、Incremental Progress 与 Handoff — 16-16, 16-17, 16-18
• Coding Agent 如何形成闭环：Planner / Generator / Evaluator、Recovery 与 Artifact Contract — 16-19, 16-20, 16-21
• Browser / Computer Use 如何进入 Coding Agent Workspace — 16-22
• Workspace 为什么不能自动信任 Tool / Skill：Supply-chain Trust Boundary — 16-23

17. Security 与 Sandbox

• Agent 会被什么攻击：Threat Model 与 Prompt Injection — 17-01, 17-02, 17-03
• 不可信输入怎样限制权限：Tool Result、Permission 与 Capability Security — 17-04, 17-05, 17-06
• 高风险 Tool 怎样只拿最小权限：Risk、Least Privilege 与 Approval — 17-07, 17-08, 17-09
• Sandbox 该隔离什么：Process、Filesystem 与 Network — 17-10, 17-11, 17-12
• Container 为什么不是完整 Sandbox：Resource、Credential 与 Security Boundary — 17-13, 17-14, 17-15
• 模型能想和能做为什么要分开：Brain / Hands 与 Delegated Authorization — 17-16, 17-17, 17-18
• 多租户环境怎样保护 Secret 和 Workspace Trust — 17-19, 17-20, 17-21
• 观测数据该留什么、删什么：Retention、Redaction 与 Audit — 17-22, 17-23

18. Observability、Testing 与 Evaluation

• 如何看见 Agent 在做什么：Logs、Metrics 与 Trace — 18-01, 18-02, 18-03
• 如何把一次 Run 串成完整链路：Correlation、Distributed Trace 与 Redaction — 18-04, 18-05, 18-06
• 如何量化运行质量：Cost、Latency、Task Success 与 Component Metrics — 18-07, 18-08, 18-09
• Agent Trace 如何标准化导出：OpenTelemetry 与 Export Pipeline — 18-21, 18-22
• Runtime 怎么做确定性验证：Unit、Contract、Fault Injection 与 Invariant Tests — 18-23, 18-24, 18-25, 18-26
• 恢复逻辑如何防回归：Replay / Resume Tests 与 Golden Trace — 18-27, 18-28
• 怎样建立可重复的 E2E Eval：Dataset 与 Deterministic Grader — 18-10, 18-11, 18-12
• 如何评估模型决策轨迹：Model-as-Judge、Trajectory 与 Tool Selection — 18-13, 18-14, 18-15
• 如何定位质量退化：Planner、Context 与 Regression Evaluation — 18-16, 18-17, 18-18
• 如何证明优化真的有效：Ablation 与 Repeated Trials — 18-19, 18-20

19. Performance、Cost 与 Capacity

• 延迟到底花在哪里：Latency Decomposition 与 TTFT — 19-01, 19-02, 19-03
• 钱怎么花、模型怎么选：Token、Budget、Routing 与 Cost / Quality — 19-04, 19-05, 19-06, 19-15
• 如何降低模型与 Context 成本：Model Delegation 与 Cache — 19-07, 19-08, 19-09
• 怎样减少并限制下游压力：Tool Cache、Parallelism 与 Pool Capacity — 19-10, 19-11, 19-12
• 过载时如何控队列：Backpressure、Throughput 与 Latency — 19-13, 19-14
• 系统能扛多少：Run Budget、Capacity Planning 与 Benchmark — 19-16, 19-17, 19-18, 19-19

20. Docker、Linux 与 Deployment

• 进程怎样启动、退出并留下可观测输出：Linux Process、Signal 与 stdout/stderr — 20-01, 20-02, 20-03
• Harness API、Worker 与 Sandbox 应暴露什么：Linux Permission、Network 与 Port — 20-04, 20-05
• Harness 怎么打包而不把状态塞进容器：Image、Dockerfile、Layer 与 Volume — 20-06, 20-07, 20-08, 20-09
• Harness 实例什么时候能接流量：Network、Secret、Liveness 与 Readiness — 20-10, 20-11, 20-12
• 容器如何安全退出并可复现部署：Graceful Shutdown、Resource Limit 与 Deployment — 20-13, 20-14, 20-15, 20-16

21. Shadow Harness 架构

• Shadow Harness 从哪些边界开始：Architecture、Domain Model 与 Model Adapter — 21-01, 21-02, 21-03
• Context、Retrieval 和 Tool Catalog 怎样接起来 — 21-04, 21-05, 21-06
• 模型计划如何变成真实执行：ToolExecutor、Planner 与 GraphCompiler — 21-07, 21-08, 21-09
• Graph 怎样被调度并持久化：Scheduler、State Machine 与 StateStore — 21-10, 21-11, 21-12
• 恢复、重试和人工审批怎样共享同一执行事实 — 21-13, 21-14, 21-15
• Trace、Eval 和 OpenTelemetry 怎样共用同一条 Run Identity — 21-16, 21-17, 21-22
• 外部能力适配：MCP 与 Workspace / Sandbox — 21-18, 21-19
• 运行入口与调试面：API、RunManifest 与 Developer Console — 21-20, 21-21, 21-23
• Run 真正怎样从 API 跑到 Worker：Dispatch、Lease 与 Lifecycle Hooks — 21-24, 21-25

22. Java 开发者的 Python 快速迁移

• Java 开发者的 Python 快速迁移指南 — 按 15 个章节建立 Java → Python → Agent / Harness 的迁移路径

源码导航

• Grok Bot Code Atlas