Qodo揭示模型丢弃中间上下文 借80/20架构终结智能体推理空转

Why More Context Makes Your Agent Dumber and What to Do About It — Nupur Sharma, Qodo — AI Engineer

AI Engineer

盲目扩大上下文窗口不仅无法增强智能体,反而因U型遗忘曲线丢弃核心数据并引发规划死循环,系统构建必须依赖切分上下文的多专家架构与限制推理时长的确定性硬门禁。

AI-assisted summary of Why More Context Makes Your Agent Dumber and What to Do About It — Nupur Sharma, Qodo — original source. Check the original for full context.

Source published:

Key ideas

  • 大语言模型在超大上下文窗口中表现出明显的“U 型曲线”现象,倾向于牢记开头的指令与结尾的追加输入,却会默默丢弃中间的海量代码与工单上下文。 (2:34)
  • 面对高推理模型在方法论选择上反复横跳、空耗 Token 的“编排悖论”,Qodo 提出 80/20 架构:前置 80% 阶段由高推理模型发散并辅以超时/计数熔断,后置 20% 阶段采用轻量模型执行确定性硬门禁校验。 (8:31)
  • 大包大揽的单 Agent 往往中途丢弃子任务,Qodo 采用 MoA 专家分发机制,由 Context Collector 拆解分发上下文,并由 Judge Agent 结合历史 PR 记录仲裁并剔除无效噪音。 (13:14)
  • 为避免系统把历史坏习惯(如硬编码 API 密钥)当成规范,系统区分强制拦截的硬性规则(Rules)与自适应建议(Recommendations),后者在被连续忽略 10 次后会自动降权。 (24:54)

Detailed notes

## Background 该内容由 YouTube 频道 AI Engineer 于 2026 年 6 月 8 日发布。视频为 Qodo 的 Nupur Sharma 所作的技术演讲,页面简介指出,演讲聚焦于将整个代码库塞给 Agent 时中间上下文被遗忘的“U 型曲线”现象,深入探讨扩大上下文窗口为何无法解决该问题,并分享了迭代检索、分层摘要、80/20 混合架构及 Qodo 实际运行的代码审查生产级架构方案。

## TL;DR Nupur Sharma 从自身 DevSecOps 转向 AI Agent 的工程实践切入,揭示了大语言模型在长上下文下只关注开头和结尾、忽略中间信息的“U 型曲线”遗忘规律,并对比了上下文引擎、知识图谱与迭代检索等优化方案的得失。针对高推理模型过度消耗 Token 思考方法而非执行的“编排悖论”,她提出了以 80% 开放调研配合熔断、20% 轻量确定性校验的 80/20 混合架构。随后,她以 Qodo 的代码审查生产级架构为例,展示了 Context Collector 如何向多专职 Agent 路由上下文、由 Judge Agent 仲裁并结合历史 PR 与合规规则动态调整反馈权重的完整工程落地路径。

## Atmosphere & style 整场演讲充满务实且一针见血的一线工程气息,Nupur 的表达自信直率、节奏明快,毫不避讳在生产实践中踩过的“坑”与模型的缺陷。现场氛围十分活跃,互动频繁,听众多次切中痛点连环追问底层实现、通信机制与幸存者偏差,主讲人则以幽默生动的生活化比喻(如保镖、图书馆借阅卡、多 Agent 规划度假)和坚定的架构原则从容拆解。观看体验犹如置身一场高质量的系统设计复盘会,既有犀利的技术反思,又充满了直面复杂现实的工程清醒。

## Bulletin - [02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 大语言模型在超大上下文窗口中表现出明显的“U 型曲线”现象,倾向于牢记开头的指令与结尾的追加输入,却会默默丢弃中间的海量代码与工单上下文。 - [08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 面对高推理模型在方法论选择上反复横跳、空耗 Token 的“编排悖论”,Qodo 提出 80/20 架构:前置 80% 阶段由高推理模型发散并辅以超时/计数熔断,后置 20% 阶段采用轻量模型执行确定性硬门禁校验。 - [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 大包大揽的单 Agent 往往中途丢弃子任务,Qodo 采用 MoA 专家分发机制,由 Context Collector 拆解分发上下文,并由 Judge Agent 结合历史 PR 记录仲裁并剔除无效噪音。 - [24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 为避免系统把历史坏习惯(如硬编码 API 密钥)当成规范,系统区分强制拦截的硬性规则(Rules)与自适应建议(Recommendations),后者在被连续忽略 10 次后会自动降权。

## Key takeaways - [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 从确定性 DevSecOps 转向不确定性 AI Agent,架构演进经历了从 4K 静态 Prompt 到带工具单 Agent、再到多 Agent 系统的跨越,但协同冲突和无法收敛成为新瓶颈。 - [02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 上下文窗口扩大并未根治信息丢失问题,基准测试表明大模型存在显著的 U 型曲线效应,夹在首尾中间的大量代码与 MCP 上下文极易被遗忘丢弃。 - [04:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=271s) 优化上下文需要做工程取舍:上下文引擎扩展到数百仓库时索引极慢,分层摘要前置消耗大,知识图谱维护门槛极高,而迭代检索加自我修正则是性价比较高的工程解法。 - [08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 编排悖论指出顶尖模型往往过度消耗算力决定“如何做”而非“实际去做”,必须引入 4-5 次交互计数或 5 分钟超时机制强制冻结决策并收敛流转。 - [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 在 80/20 混合架构中,高推理模型负责前期开放式探索与最终仲裁,轻量级模型则严格执行硬门禁与确定性比对,从而兼顾灵活性与推理成本。 - [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 试图用单一 Agent 处理全部任务是典型反模式,模型容易被淹没并丢失部分任务,解耦为专注特定领域的专家 Agent 蜂群是更稳健的选择。 - [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 多专家 Agent 各自输出局部最优结果时容易产生冲突,必须引入全局 Judge Agent 对零散结果进行统筹融合与合理性裁决。 - [14:41](https://www.youtube.com/watch?v=EcqMYoIV57A&t=881s) Qodo 的代码审查工作流由 Context Collector 先行切分数据并分发给安全、Diff 和 Jira 等专家 Agent,最后由 Judge Agent 剔除不相关建议。 - [16:08](https://www.youtube.com/watch?v=EcqMYoIV57A&t=968s) 模型本身缺乏组织特有的工程习惯,系统通过建立 PR 历史索引并进行两阶段注入,校准专家 Agent 输入与 Judge Agent 的仲裁权重。 - [19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 组织可在门户中配置全局架构与安全规范以补充 Agent 的局部视角;在缺乏文档的开箱即用场景下,系统则依靠 PR 历史沉淀逐步学习隐性规则。 - [23:22](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1402s) 评审节点引入采纳反馈闭环,开发者对某类建议的采纳或否决动作会实时反哺索引,动态调整该模式在未来评审中的置信权重。 - [24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 历史代码存在幸存者偏差,架构设计必须将不可违背的硬性规则与通用缺陷建议严格剥离,防止模型将遗留陋习作为正向经验自适应学习。

## Detailed walkthrough ### [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 从确定性 DevSecOps 到不确定性的 Agent 世界与架构演进

Nupur 介绍了自己的工作背景:她就职于 Qodo(原 Codium),专注于代码审查 Agent(agentic reviews)的研发。在此之前,她的背景是 DevSecOps。这是一个界限极为分明的领域:“流水线要么运行,要么崩溃。如果崩了,我们就去修好它。”在这个曾经一切皆可预测的世界里,逻辑是完全确定性的(deterministic)。然而,转向 AI Agent 研发后,面对的却是一个完全不确定、充满不可预测性的环境。过去几年中,她深入探索了 Agent 到底在哪些环节会失败、为何会失败,并希望将这些一线教训分享出来。

回顾 Agent 架构的演化过程,最初是从只有 4K 上下文窗口的静态 Prompt(static prompts)起步的。当时开发者必须费尽心机挑选所谓“最关键”的信息塞给模型让其处理。这种做法意味着人类背负着沉重的筛选负担:“这意味着责任落在我们身上,由我们去告诉 LLM 应该关注什么;如果我们提供了错误的输入,就可能得不到正确的结果。”

随后,业内寄希望于上下文窗口的扩大,认为输入变大就能解决问题,并逐渐走向了 Agent 工作流:给模型配备搜索工具,让它自主查询文档并执行命令。然而,这立刻带来了新的死循环(loop)——工具根本不知道何时该停下,总觉得自己缺少信息,于是不停地回头继续检索。为了进一步提升能力,如今多 Agent 架构(multi-agent systems)大行其道,团队会部署安全审查 Agent、代码 Review Agent、修代码的 Coding Agent 等等。但工具与角色越多,引发的混乱也越多:各个 Agent 之间的理解往往存在分歧与冲突(clash in their understandings),最终导致任务根本无法收敛得出结果。

```mermaid flowchart TD accTitle: Agent 架构演进阶段 accDescr: 展示从早期静态单 Prompt 到当前多 Agent 架构的发展演变及各自面临的问题。

subgraph Phase1["第一阶段:静态 Prompt"] A["4K 极小上下文"] -->|"强依赖人工筛选"| B["输入偏差导致结果错误"] end

subgraph Phase2["第二阶段:单 Agent + 工具调用"] C["扩展上下文 + 搜索工具"] -->|"缺乏终止条件"| D["无限检索死循环"] end

subgraph Phase3["第三阶段:多 Agent 协同"] E["专职 Agent 团队<br/>(安全/审查/编码)"] -->|"语义与目标冲突"| F["逻辑打架,无法达成共识"] end

Phase1 --> Phase2 Phase2 --> Phase3 ```

- **静态 Prompt 时代**:受限于 4K 上下文窗口,人类负责硬编码上下文,对输入质量极度敏感。 - **工具调用循环**:引入 Agent 自动化工具后,模型在缺少退出策略时极易陷入反复搜索补充输入的死循环。 - **多 Agent 协同困境**:不同专职 Agent 间缺少对齐机制,互相碰撞导致任务难以收敛。

---

[02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 上下文 U 型曲线(U-Curve)与信息遗忘现象

随着大模型能力提升,上下文容量看似不再是瓶颈,业界可以一股脑将海量数据扔给模型。然而,Nupur 提出质疑:模型真的变聪明到能替你分辨什么是重要的了吗?现实情况恰恰相反:当前的大语言模型表现出极其明显的“U 型曲线”(U-curve)模式——它们能关注到最开始给出的目标指令,也能关注到最后追加的输入,但直接忽视并抛弃了夹在中间的大量上下文。

现场有听众立刻追问:“你们是怎么知道这一点的?”Nupur 回应称,这来自于 Qodo 内部持续进行的基准测试(benchmarking)。在多 Agent 架构中执行代码审查任务时,团队尝试将整个代码库作为背景全面喂给模型,观察其是否真正消化了所有上下文。测试结果非常一致:模型牢牢记住了开头的初始目标,也能留意到最后输入的提示,但夹在中间的大规模上下文——比如关联的 Jira 工单信息或 Model Context Protocol(MCP)等服务拉取的数据——统统被 LLM 默默丢弃(purge),模型依然只靠头尾碎片自行拼凑结论。

“这就像一条 U 型曲线,开头的某些部分和结尾的某些部分起到了作用,但你无论在中间塞进什么,都不会被真正采纳吸收。” Nupur 直言。

---

[04:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=271s) 上下文优化的四大战略路径与权衡

为了解决中间信息丢失的问题,不能再无脑向模型倾倒数据,而必须引入战略性的上下文优化方案(strategic solutions for context optimization)。Nupur 详细拆解了业界主流的几条实现路径及其工程取舍:

1. **上下文引擎(Context Engine)**:当下极为火爆的概念,其定位就像是一个拦截在代码访问链路上的“保镖”(bouncer)。面对庞大而混乱的代码库,它能建立搜索模式与排序逻辑,筛选出最相关的部分交付给 Agent。但是,它的痛点在于索引与横向扩展极度困难:当代码仓库规模扩大到六七百个代码库(600–700 repositories)时,映射和索引构建会严重变慢,维护成本对于非专门做上下文引擎的公司来说难以承受。 2. **分层摘要(Hierarchical Summarization)**:不让 Agent 翻阅所有完整文件,而是为每个文件和文件夹提前生成摘要。Agent 检索时先读取摘要再判断是否值得深入。这种方式效果显著,但严重依赖前置的 LLM 处理:任何文件的创建或修改都需要触发 Agent 重新生成映射,产生极高的前期 LLM 算力消耗(high upfront LLM processing)。 3. **知识图谱(Knowledge Graph)**:结构极其复杂,但在梳理强逻辑依赖关系(如跨文件连锁修改、多代码库依赖)时表现绝佳。通常需要搭建图数据库(Graph DB)支持,开发者前期的搭设与维护成本极高,但对于大型复杂逻辑网络收益明显。 4. **迭代检索(Iterative Retrieval)与自我修正(Self-Correction)**:对于并非专门做工具软件、只是为内部业务构建 Agent 的团队而言,迭代检索是最具性价比的方案。它就像给 Agent 一张“图书检索卡”(library card),只展示主题,由 Agent 按需深入。其开发门槛低,效果好,仅会产生少量的额外调用成本。另一种配套方案是引入“评估批判节点”(critic node)进行自我修正,一旦发现偏离最初目标就让 Agent 重新尝试,虽引入了额外的运行延迟,但对开发者的前期投入要求极低。

| 上下文策略 | 核心机制 | 前期开发投入 | 算力/延迟代价 | 最佳适用场景 | |:--- |:--- |:--- |:--- |:--- | | **上下文引擎** | 专用检索与重排算法 | 中等(索引搭建) | 面对 600+ 仓库时扩展与速度急剧下降 | 超大型单体/混乱代码库 | | **分层摘要** | 为各级文件目录生成摘要 | 极高(每次文件变更需重新处理) | 高前置 LLM 处理成本 | 目录结构清晰、需快速宏观判断的项目 | | **知识图谱** | 借助图数据库映射逻辑依赖链 | 极高(需人工梳理复杂逻辑) | 存储与维护成本高 | 跨代码库强逻辑依赖、复杂级联变更场景 | | **迭代检索** | 类似图书借阅卡的索引按需下钻 | 低 | 轻微成本增加 | 内部业务 Agent、快速落地自建流程 | | **自我修正** | 独立 Critic 节点校验输出并重试 | 极低 | 增加单次执行的端到端延迟 | 容错率低、对精准度要求高的任务流 |

---

[08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 编排悖论与 80/20 混合架构(The 80/20 Approach)

另一个困扰 Agent 开发的顽疾是“编排悖论”(orchestration paradox)。随着模型推理能力越来越强(例如使用最新的 Claude Opus 等高推理模型),模型往往会“聪明反被聪明误”。接收到任务后,它不仅不去动手解决问题,反而沉迷于方法论的选择:“我应该用这个工具吗?还是先去调研一下有没有更好的途径?”模型在一个又一个方法论之间反复横跳自我怀疑,耗费了海量 API Token 却全花在了寻找解法而不是执行解法上。

“它们在不同方法之间反复横跳,大部分 API Token 都浪费在寻找实现途径上,而不是真正去执行它。” Nupur 指出,这直接让 Agent 彻底陷入了纯粹的调研死循环。

针对这一困境,Qodo 团队提出了 **80/20 混合策略(80/20 hybrid approach)**: - **80% 开放式调研阶段**:给予高推理模型充分的自由度去进行前期探索、规划和寻找工具。为了防止这一阶段无限漫延,系统会加设确定性的熔断机制(counter mechanism),例如限制最多执行 4 到 5 次交互计数,或设置 5 分钟超时计时器(timeout counters),超时后强制提取当前最终决策向下流转。 - **20% 确定性校验阶段**:进入最后的结果提炼、摘要与验证环节时,坚决剥夺模型的自主发散权,改为高度受控的硬门禁(hard gates)。该阶段遵循严格的确定性逻辑(如“得到 X 结果就必须输出 Y”),且无需使用昂贵的高推理模型,轻量级确定性模型足以胜任。比如上文提到的 Critic 审查节点,根本不需要思考调研,只需严格比对最终输出是否契合最初设定的目标。

```mermaid flowchart TD accTitle: 80/20 混合编排架构 accDescr: 前端 80% 采用高推理模型进行开放式探索并辅以计数/超时熔断,后端 20% 采用轻量模型执行确定性校验与收敛。

subgraph OpenDiscovery["80% 开放式发现与规划阶段 (高推理模型)"] Task["输入目标任务"] --> Reasoning["自主规划 / 工具探索"] Reasoning --> LoopCheck{"达到 4-5 次计数<br/>或 5 分钟超时?"} LoopCheck -- 否 --> Reasoning LoopCheck -- 是 --> Freeze["强制收敛并冻结当前决策"] end

subgraph HardGates["20% 确定性收尾阶段 (轻量级模型)"] Freeze --> Critic["Critic 审查节点"] Critic --> Verify{"是否符合初始目标?<br/>(严格硬门禁: X -> Y)"} Verify -- 合格 --> Output["输出最终确定性结果"] Verify -- 不合格 --> Retry["回滚重试 / 降级策略"] end ```

- **编排悖论的本质**:高推理模型算力被过度消耗在“选择如何做”而非“实际去做”的元推理循环中。 - **80% 调研控制**:通过 4~5 次计数上限或 5 分钟超时机制对顶尖模型的发散推理进行硬性约束。 - **20% 确定性硬门禁**:采用轻量模型替代高智商模型执行收束、比对与总结,大幅砍掉冗余成本并提升系统可靠度。

[11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 80/20 模型分工与“单 Agent 承载一切”的失效陷阱

在构建复杂工作流时,80% 的动态模型(轻量级/确定性模型)非常适合处理具体执行层面的事务,例如总结内容、根据当前提取的结果判断下一步该查找什么操作;而具备高推理能力的 20% 模型,则专门负责更高维度的仲裁与决策——在拿到下层返回的所有零散结果后,裁定哪一种方式或哪一项输出才是用户真正需要的目标。

Nupur Sharma 指出,随着上下文窗口不断扩大,许多工程团队掉进了一个经典的认知陷阱:“因为上下文窗口足够大,我们就用一个 Agent 搞定所有事情。”团队把测试、代码审查、逻辑核对等所有任务一股脑塞给同一个 Agent,寄希望于它能在庞大的上下文里输出全部答案。然而,这种做法会导致 Agent 在前行过程中彻底被输入信息淹没,进而偏离并遗忘原本的核心任务。“所以你可能给 Agent 分派了四个任务,但在执行过程中它只聚焦在其中两个任务上。对于这两个任务你确实得到了不错的结果,但另外两个任务在半途就直接丢失了。”

```mermaid flowchart TD accTitle: Single Agent Bottleneck vs Mixture of Agents accDescr: Comparison of a bloated single agent failing across tasks versus specialized agents arbitrated by a judge.

subgraph AntiPattern["单 Agent 瓶颈(容易丢失任务)"] A["单一大上下文 Prompt<br/>(测试 + 审查 + Jira + 安全)"] --> B["超载的单 Agent"] B --> C["聚焦任务 1 & 2 (丢失任务 3 & 4)"] end

subgraph MOA["多智能体协作架构 (Mixture of Agents)"] D["上下文与任务分配"] --> E["安全专家 Agent"] D --> F["代码审查 Agent"] D --> G["Jira 关联 Agent"] E --> H["仲裁 Agent (Judge Agent)"] F --> H G --> H H --> I["全局一致的高质量输出"] end ```

---

[13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 智能体混合(Mixture of Agents)与仲裁者(Judge Agent)机制

为了解决单一 Agent 认知超载与中间信息丢失的问题,当前行业兴起了“多智能体架构”(Multi-Agent Architecture)或“智能体混合”(Mixture of Agents)。这种架构的核心在于解耦:不再强求一个大包大揽的通用 Agent,而是针对特定任务构建专注精通的小型“领域专家 Agent”(Issue Expert Agents)。

然而,拆分成多个专家 Agent 后会带来全新的集成挑战:各个 Agent 单独拿出的结果可能都很优秀,但彼此之间却毫无关联甚至相互冲突。Nupur 用搜索度假行程举例:“比如我想规划一次度假,让一个 Agent 去找最佳酒店,另一个 Agent 去找最佳目的地,第三个 Agent 去找最优航班。结果三者各自为政:酒店在希腊,航班是从阿姆斯特丹飞往葡萄牙,所有信息拼凑在一起完全对不上。”为化解这一矛盾,系统中必须引入“仲裁智能体”(Judge Agent):“它的职责是收集所有子 Agent 的结果,评估它们组合在一起是否合理。借助 Judge Agent,既能保留各专家 Agent 最顶尖的局部成果,又能将它们统筹融合成一份逻辑自洽的最终结论。”

- **单一 Agent 缺陷**:上下文过载引发注意力漂移,往往只能完成部分子任务,其余任务被“吞噬”。 - **专家 Agent 特性**:各司其职,专门攻克特定边界内的问题(如漏洞挖掘、规范比对)。 - **Judge Agent 作用**:充当总览全局的评估者与协调者,消解子 Agent 间的冲突输出。

---

[14:41](https://www.youtube.com/watch?v=EcqMYoIV57A&t=881s) Qodo 代码审查架构:从 Context Collector 到 Judge Agent

Nupur 随后详细展示了 Qodo 在生产环境中运行的代码审查架构。在审查拉取请求(Pull Request, PR)时,系统第一步并非直接唤起模型出具审查报告,而是由 Context Collector(上下文收集器)先行动作。它负责从 PR 本身、上下文引擎以及关联的各项外部工具中抓取背景数据。

Context Collector 汇集到信息后,绝不会粗暴地把全量数据一次性丢给某一个模型,而是精准切分(bifurcates),将最对口的上下文分发给专门的子 Agent: - **安全 Agent**:专门筛查潜在的安全缺陷与漏洞。 - **Diff 分析 Agent**:专注于代码层面的改动逻辑。 - **任务追踪 Agent**:核对关联的 Jira 工单信息。

当各专家 Agent 输出分析结论后,后置的 Judge Agent 启动。它不仅会校验这些结论是否足够深入,还会再次调阅上下文引擎与过往 PR 记录,评估“给出的 10 项建议中,到底有几项与当下的代码和团队习惯真正相关”,借此剔除无关噪声,只把真正有价值的审查反馈交付给开发者。

---

[16:08](https://www.youtube.com/watch?v=EcqMYoIV57A&t=968s) 现场问答:Agent 间通信、Prompt 链转接与“校准”机制

在问答环节,有现场观众询问多 Agent 蜂群(Swarm)在底层是如何具体实现彼此通信的,是依靠文件系统还是专有工具。Nupur 澄清,Qodo 在底层利用了 LangChain 来构建跨 Agent 通信的基础设施。观众追问具体的传递流程是否就是收集上一节点的响应并硬塞进下一个节点的 Prompt 中,Nupur 回应:“是的,完全正确。我们的做法就是提取前序阶段的输出结果,为下一个 Agent 构建 Prompt;如果涉及多个来源的复杂数据,还会有专门的收集 Agent 负责清洗汇总,提炼出针对下一阶段更加精准的上下文 Prompt。”

```mermaid flowchart LR accTitle: Qodo Multi-Agent PR Review Workflow accDescr: Sequence of context collection, agent routing, and calibration via historical PR data.

PR["PR 提交与环境变更"] --> CC["Context Collector"] CC -->|"切分上下文"| Sec["安全审查 Agent"] CC -->|"切分上下文"| Diff["代码 Diff Agent"] CC -->|"切分上下文"| Jira["Jira 状态 Agent"]

Sec --> Judge["Judge Agent<br/>(结合历史 PR 判定)"] Diff --> Judge Jira --> Judge

History[("PR 历史索引库<br/>团队偏好/过往反馈")] -.->|"一校:前置输入"| CC History -.->|"二校:仲裁权重"| Judge Judge --> Out["最终精简 Review 建议"] ```

接着,观众抛出关于“校准”(Calibration)的疑问——团队如何向 Agent 明确什么代码实践是“好的”、什么判定是“坏的”。Nupur 解释,LLM 本身对具体团队的偏好与行业惯例一无所知;无论是医疗、零售还是金融行业,即便使用同一套 Java 框架,关注的架构优先级也截然不同。Qodo 采用两项核心机制对 Agent 进行行为校准: 1. **建立 PR 历史索引**:系统为代码库的所有历史 PR 建立索引,查找过往类似场景的修改记录。 2. **两阶段上下文注入**:历史数据会被注入两次——“第一次是在为各子 Agent 分配上下文时;第二次则是注入给 Judge Agent。这样当针对一次代码审查产生 15 条不同的改进建议时,Judge Agent 能够参阅过往资深审查员和开发者的互动评论,据此决断这 15 条建议中哪些真正值得推送给当前的开发者。”

---

[19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 局部视角与全局架构的张力:人类经验与组织规则配置

随后,现场观众就架构评估提出了更深层的质疑:如果每个 Agent 仅拿到被剥离后的局部上下文,在彼此割裂、不掌握全局架构图景的前提下独立运行,该如何做出需要权衡妥协的全局判断?“在人类做代码审查时,拥有全局视角至关重要。仅给局部信息可能应付得了 Linting 或者测试覆盖率这种基础工作,但一旦涉及兼顾安全与系统平衡的架构设计决策,缺乏全局视野的 Agent 该如何应对?”

Nupur 结合传统研发团队的角色分工进行回应。在过去,代码审查本就是多角色协作的产物:资深工程师把控框架规范与整体习惯,安全专家紧盯 API 硬编码与 SQL 注入,合规审计员检查审计日志;每个人本身就带着不同侧重的专业视角。如今在 Agent 架构中,系统通过门户配置来补足架构维度的全局规范:架构师可以在后台设定架构指南,合规人员上传安全准则,Context Collector 在理解这套完整规则的前提下,再将匹配的上下文下发给相应 Agent 执行校验。

针对观众关于“是否必须强制客户上传这类架构文档,否则系统输出质量将截然不同”的追问,Nupur 说明道:“这完全取决于不同组织的成熟度。有些团队崇尚完全不设限的自由开发,要求系统开箱即用;但这也意味着,在系统积累起足够的 PR 历史数据之前,不要指望 Agent 能够捕捉到团队特有的隐性规范。”PR 历史在此充当了兜底校准网:即使团队未主动维护成文的架构规范,系统也能逐步通过过往的代码沉淀与审查互动,学习并反哺出符合该组织习惯的代码审查边界。

- **组织规则配置**:架构师与安全合规团队可在 Web 门户预设硬性准则,由 Context Collector 下发校验。 - **开箱即用与冷启动权衡**:不提供外部规则文档时,系统极度依赖历史 PR 索引的沉淀与迭代反馈。

[23:22](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1402s) 评审节点中的权重平衡与动态反馈机制

在问答环节中,观众针对代码评审系统中的仲裁节点(Judge Node / Jury)提出了一个棘手的现实问题:当系统引入多源信息时,应该如何权衡各个上下文来源的权重?提问者举例指出,团队新出台的工程原则、架构规范文档与历史遗留的合并记录(PR history)之间,可能会存在严重的冲突或失衡,如果只参考历史合并代码,很可能会把过去的坏习惯当成正确规范。Nupur Sharma 对此幽默地插话回应道:“有人正在我家做饭呢,但这确实可以作为上下文来源之一,这就是为什么需要有多种多样的信息源。”

```mermaid flowchart TD accTitle: 评审系统动态权重反馈机制 accDescr: 展示合规规则与PR历史如何通过开发者采纳行为动态调整建议权重

subgraph Sources["上下文输入源"] A["合规与架构规范文档<br/>(强制规则/错误)"] B["PR 历史与遗留代码<br/>(通用建议/模式)"] end

subgraph JudgeNode["评审仲裁节点 (Judge / Jury)"] C["信息聚合与初始权重赋值"] D["开发者采纳行为追踪<br/>(Accept / Reject)"] end

subgraph WeightAdjust["动态权重更新"] E["采纳建议 -> 提升该模式权重"] F["驳回/忽略 -> 降低该建议权重"] end

A --> C B --> C C --> D D -->|采纳| E D -->|拒绝/未实现| F E -.->|"迭代下一次评审"| C F -.->|"迭代下一次评审"| C ```

Nupur 详细剖析了系统在平衡这些冲突上下文时的多维度设计。单从单一视角来看确实难以抉择,但 Qodo 的做法是从多角度构建上下文网络。系统会在合规门户中对不同反馈进行分级:某些属于严重错误(Error),某些则属于普通优化建议(Recommendation)。每一次反馈都会根据其类别打上基准权重。更关键的是引入了持续的动态反馈循环:每当开发者采纳了一条 Agent 提出的建议,这种模式在下一次评审中的权重就会得到提升;如果开发者反复拒绝或忽略某条建议,它的权重便会被削弱。Nupur 总结道:“And every time your developer expect accepts a suggestion, it gets more weighted for the next one.” 系统的核心就在于建立索引并持续管理和更新这些动态权重。

- 系统获取上下文的来源绝非单一依赖历史代码,而是结合了 PR 历史记录、架构合规规范及工程原则文档。 - 仲裁机制对建议进行了分层管理,明确划分为阻断性的错误(Errors)与参考性的推荐(Recommendations)。 - 系统通过双向追踪闭环:实时记录当前 PR 中开发者对建议的采纳情况,并在后台索引中动态调整对应规则的置信权重。

---

[24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 强制规则与惯性陋习的博弈及结语

对于权重具体的追踪和计算方式,Nupur 解释了团队落地的两种主要途径。第一种是在当前工作流中进行即时捕获,直接索引开发者面对推荐时的采纳(Accept)与否决(Reject)动作;第二种则是深度回溯过去的 PR 历史,分析历史上检测出的同类问题以及开发者是否真正落实了修复。提问者随即指出,历史代码往往存在“幸存者偏差”,过去发生过的事并不代表它是对的。Nupur 对此深表赞同,并分享了自己在实际工作中遇到的真实拉扯:有些工程师习惯了直接在代码中硬编码 API 密钥(hard-coding API keys),甚至会理直气壮地争辩“我们平时一直就是这么干的”。Nupur 当时态度非常坚决地回绝:“No this is should this should not be the way.”

为了彻底解决这种“历史遗留陋习与最佳实践”的冲突,Nupur 阐明了系统内部“硬性规则(Rules)”与“通用缺陷分析(Bug Fixes)”的本质区别。当安全团队或架构师将某项标准定义为显式规则(例如严禁硬编码密钥)时,无论团队以前的代码风格如何、开发者主观上是否想要看到,系统都会将其强制高亮并拦截。而对于常规的潜在 Bug 或优化建议,Agent 会给出警告;如果人类评审者和开发者连续十次都选择忽略该建议且不予实现,系统就会自动降低此类提示的权重,避免产生烦人的告警疲劳。Nupur 明确界定了规则与自适应学习的边界:“So if you provide them as a rule it will get highlighted doesn't matter if you want it or not.” 提问者对此方案表示十分认可并致谢,整场演讲在掌声中正式落下帷幕。

- 跟踪采纳度的两大路径:实时监测当前 PR 建议的采纳动作,以及交叉比对历史 PR 中同类问题的真实修复执行率。 - 区分不可逾越的规则(Rules)与可自适应调节的缺陷建议(Bugs),防止模型把过去的坏实践(如硬编码 API 密钥)当成正向经验学习。 - 动态降权过滤告警噪音:若某项推荐型提示被工程师连续 10 次忽略且未采纳,系统将判定其不符合团队当前场景并自动下调其展示权重。

## Notable quotes > [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 借助 Judge Agent,既能保留各专家 Agent 最顶尖的局部成果,又能将它们统筹融合成一份逻辑自洽的最终结论。 — Nupur Sharma

> [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 你可能给 Agent 分派了四个任务,但在执行过程中它只聚焦在其中两个任务上。对于这两个任务你确实得到了不错的结果,但另外两个任务在半途就直接丢失了。 — Nupur Sharma

> [19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 在系统积累起足够的 PR 历史数据之前,不要指望 Agent 能够捕捉到团队特有的隐性规范。 — Nupur Sharma

> [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 责任落在我们身上,由我们去告诉 LLM 应该关注什么;如果我们提供了错误的输入,就可能得不到正确的结果。 — Nupur Sharma

## Mentioned Nupur Sharma, Qodo, Codium, Claude Opus, Model Context Protocol, Jira, LangChain, Java

## Video description Give an agent your full codebase and it will attend to the start and the end, then quietly drop the middle. Nupur from Qodo calls this the U curve and builds the whole talk around it: why growing the context window did not fix the problem, and what actually does. She runs through iterative retrieval, hierarchical summarization, and self correction with honest cost tradeoffs for each.

The second half covers the orchestration paradox: capable models burn most of their tokens deciding how to solve a problem rather than solving it. Her team's fix is an 80/20 split, using high reasoning models for open ended discovery and lighter deterministic models for validation. Qodo's code review architecture runs this live: a context collector feeds specialized agents, a judge node recombines the results and weighs them against PR history, and every accepted or rejected suggestion shifts the weights for the next run.

Speaker info: - https://www.linkedin.com/in/nupursh/

---

Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/EcqMYoIV57A-why-more-context-makes-your-agent-dumber-and-what-to-do-about-it

Join our upcoming AI Engineer conferences (see https://ai.engineer landing page):

- AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney

---

[Source](https://www.youtube.com/watch?v=EcqMYoIV57A)

中文简报

长上下文削弱代码审查效果,Qodo拆分智能体架构 将完整代码库直接塞入模型上下文窗口会导致提示词中间部分出现严重的注意力流失,工程团队需用专业子智能体及确定性裁决节点过滤替代单一整体智能体。 Nupur Sharma指出,将完整代码库直接塞入日益扩大的LLM上下文窗口中会引发“U型曲线”注意力失效,即模型只关注提示词的开头和结尾而忽略中间部分。为解决这一问题,工程团队应放弃单一提示词,转而采用迭代检索和分层总结等针对性上下文策略。她提出了一种80/20混合编排模型,以防止推理智能体在无限规划循环中空耗Token,将前沿模型保留用于开放式探索,并使用轻量级确定性逻辑进行验证。最后,她详细拆解了Qodo的实时拉取请求(PR)审查架构,其中专业子智能体负责评估限定范围的代码切片,并提供给中央裁决节点,该节点会根据历史合并数据和不可妥协的合规规则动态校准反馈。 扩大上下文窗口并不会让智能体更聪明;模型在长提示词中间部分始终存在注意力衰减问题,呈现出U型留存曲线,会悄然忽略辅助数据。 (2:34) 能力强大的基础模型常常陷入编排悖论,将Token预算耗费在元规划和工具选择上,而不是执行解决方案。 (8:31) Qodo通过80/20混合拆分解决了编排瘫痪问题,在严格的迭代上限下将高推理模型用于开放式探索,同时将验证和总结路由至轻量级确定性模型。 (8:31) 承担多重职责的单一智能体在执行过程中往往会中途放弃次要任务,因此需要采用下游裁决节点串联的混合智能体设计。 (11:49) Qodo的PR审查架构根据开发者的采纳情况动态重新校准启发式建议权重,同时无论历史代码习惯如何,均严格执行组织的安全与合规规则。 (24:54)

精炼阅读摘要

Qodo 工程师 Nupur Sharma 指出,单纯扩大上下文窗口并直接灌入海量信息反而会导致大语言模型退化,系统设计必须采用上下文切片与多智能体分层架构来保证审查质量。 上下文 U 型陷阱与多任务退化 (2:34) Nupur Sharma 指出,尽管现代模型的上下文窗口大幅扩展,但直接填入完整代码库、Jira 需求单与 MCP 外部工具输出并不能提升智能决策水平。Qodo 的内部基准测试显示,大语言模型对长提示词的处理存在明显的“U 型曲线”衰退:模型能够牢固关注开头的初始指令与末尾的输入内容,但在提示词中间的信息会被系统性忽略或丢失。若将辅助资源堆积在提示词中间,模型往往会完全忽略这些信息,导致上下文无法生效。 扩展上下文窗口还促使许多团队陷入构建单一全能智能体的反模式。开发者常试图把单元测试生成、代码审查以及架构规范检查合并至同一个智能体中,误以为共享全局上下文能得出连贯结论。然而,面对密集的多任务指令,单一智能体极易被指令规模压垮,并在处理中期发生上下文丢失。实际场景中,模型往往只会执行最初或最后指派的两项任务,而中途悄悄遗漏或放弃其余目标。 上下文检索策略与编排悖论治理 (4:31) 为了避免用冗余数据塞满上下文,开发团队常采用四类检索路由方案。独立上下文引擎能精准筛选与排序混乱代码,但当规模扩展至六七百个代码仓库时,索引性能会急剧恶化;分层摘要为文件和目录生成多级概括,但每次代码变动都会引发昂贵的后台大模型重算;图数据库知识图谱擅长追踪跨文件与跨仓库的逻辑依赖,却需要极为繁重的初期人工工程建设。针对内部工作流场景,Sharma 推荐使用轻量级迭代检索,以类似图书馆借书卡的形式让智能体按需调取源码,既压低了维护成本又保留了较高精度。 在规划高阶任务时,Claude Opus 等顶尖推理模型常常陷入“编排悖论”,将大部分 API 消耗在反复权衡工具与自省策略上,反而迟迟不执行实质操作。为此,Qodo 提出了 80/20 混合架构:将 80% 的动态探索、工具调用及常规摘要交由轻量级模型或设置严格护栏的高推理模型处理,且探索阶段设置最多 4 至 5 次循环或 5 分钟超时截断;剩余 20% 的最终验证与仲裁环节剥离发散性自主权,依靠低成本模型配合严格验证门禁来输出最终成果,从而大幅削减推理开销。 混合智能体分工与裁判节点仲裁 (13:14) 为规避单一智能体的任务丢失问题,Qodo 在代码审查流水线中采用混合智能体(MoA)架构。该流程首先由中心化的上下文收集器统一接入拉取请求(PR)数据、开发者工具以及底层上下文引擎的历史记录;随后,收集器将数据切片并精准分发给专精子智能体。例如,安全智能体只审查漏洞与密钥泄露,差异智能体比对代码改动,需求智能体则负责将改动关联至 Jira 单据,防止不同领域的检查互相干扰。 高度特化的子智能体能确保各个任务独立完成,但容易产生全局不一致的推荐。如同度假规划中各智能体分别订了希腊酒店与葡萄牙机票一样,单个方案成立但整体方案冲突。为此,架构下游引入了专属“裁判智能体”(Judge Agent)。裁判节点汇总各子节点的原始报告,结合上下文引擎和历史审查记录进行降噪与去重,在十数条分散的潜在问题中筛选出真正对开发者有价值的改动建议,最后整合成统一的审查意见反馈给用户。 PR 历史校准与双轨动态权重机制 (16:01) 基础大语言模型缺乏针对特定行业或企业的工程规范认知,同样的代码框架在金融、医疗与零售领域有着截然不同的使用标准。Qodo 通过索引代码库的历史 PR 和人工评审历史来解决规范校准问题。这套历史数据不仅在初期辅助子智能体定位团队关心的代码模式,也会输入给裁判节点,用于剔除那些人类审查者习惯性忽略或驳回的繁琐建议,从而在源头上避开把全局源码全量灌入模型所引发的 U 型衰退。 针对历史代码中可能潜藏坏习惯并被智能体学习强化的风险,系统建立了双轨评估机制。对于软性建议与潜在 Bug,系统采用动态权重索引:开发者在日常审查中每接受一条建议,该特征权重便会上升;若反复驳回某类提议,其优先级会被自动调低以减少无用噪音。但对于硬性合规要求、致命错误与核心安全策略(如禁止硬编码 API 密钥),系统采取确定性规则强制执行,完全绕开历史合并习惯和开发者的主观偏好,确保技术债务与遗留坏习惯不会冲刷工程底线。 构建可靠的智能体代码审查系统不能押注于扩大的上下文窗口,而必须依靠上下文切片、子智能体解耦与裁判仲裁;但在实践中,如何在依赖历史数据校准团队偏好的同时,彻底阻断历史坏习惯的自动固化,仍取决于确定性合规门禁与启发式建议之间的权衡设计。

Detailed notes — zh

## Background 该内容由 YouTube 频道 AI Engineer 于 2026 年 6 月 8 日发布。视频为 Qodo 的 Nupur Sharma 所作的技术演讲,页面简介指出,演讲聚焦于将整个代码库塞给 Agent 时中间上下文被遗忘的“U 型曲线”现象,深入探讨扩大上下文窗口为何无法解决该问题,并分享了迭代检索、分层摘要、80/20 混合架构及 Qodo 实际运行的代码审查生产级架构方案。 ## TL;DR Nupur Sharma 从自身 DevSecOps 转向 AI Agent 的工程实践切入,揭示了大语言模型在长上下文下只关注开头和结尾、忽略中间信息的“U 型曲线”遗忘规律,并对比了上下文引擎、知识图谱与迭代检索等优化方案的得失。针对高推理模型过度消耗 Token 思考方法而非执行的“编排悖论”,她提出了以 80% 开放调研配合熔断、20% 轻量确定性校验的 80/20 混合架构。随后,她以 Qodo 的代码审查生产级架构为例,展示了 Context Collector 如何向多专职 Agent 路由上下文、由 Judge Agent 仲裁并结合历史 PR 与合规规则动态调整反馈权重的完整工程落地路径。 ## Atmosphere & style 整场演讲充满务实且一针见血的一线工程气息,Nupur 的表达自信直率、节奏明快,毫不避讳在生产实践中踩过的“坑”与模型的缺陷。现场氛围十分活跃,互动频繁,听众多次切中痛点连环追问底层实现、通信机制与幸存者偏差,主讲人则以幽默生动的生活化比喻(如保镖、图书馆借阅卡、多 Agent 规划度假)和坚定的架构原则从容拆解。观看体验犹如置身一场高质量的系统设计复盘会,既有犀利的技术反思,又充满了直面复杂现实的工程清醒。 ## Bulletin - [02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 大语言模型在超大上下文窗口中表现出明显的“U 型曲线”现象,倾向于牢记开头的指令与结尾的追加输入,却会默默丢弃中间的海量代码与工单上下文。 - [08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 面对高推理模型在方法论选择上反复横跳、空耗 Token 的“编排悖论”,Qodo 提出 80/20 架构:前置 80% 阶段由高推理模型发散并辅以超时/计数熔断,后置 20% 阶段采用轻量模型执行确定性硬门禁校验。 - [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 大包大揽的单 Agent 往往中途丢弃子任务,Qodo 采用 MoA 专家分发机制,由 Context Collector 拆解分发上下文,并由 Judge Agent 结合历史 PR 记录仲裁并剔除无效噪音。 - [24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 为避免系统把历史坏习惯(如硬编码 API 密钥)当成规范,系统区分强制拦截的硬性规则(Rules)与自适应建议(Recommendations),后者在被连续忽略 10 次后会自动降权。 ## Key takeaways - [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 从确定性 DevSecOps 转向不确定性 AI Agent,架构演进经历了从 4K 静态 Prompt 到带工具单 Agent、再到多 Agent 系统的跨越,但协同冲突和无法收敛成为新瓶颈。 - [02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 上下文窗口扩大并未根治信息丢失问题,基准测试表明大模型存在显著的 U 型曲线效应,夹在首尾中间的大量代码与 MCP 上下文极易被遗忘丢弃。 - [04:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=271s) 优化上下文需要做工程取舍:上下文引擎扩展到数百仓库时索引极慢,分层摘要前置消耗大,知识图谱维护门槛极高,而迭代检索加自我修正则是性价比较高的工程解法。 - [08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 编排悖论指出顶尖模型往往过度消耗算力决定“如何做”而非“实际去做”,必须引入 4-5 次交互计数或 5 分钟超时机制强制冻结决策并收敛流转。 - [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 在 80/20 混合架构中,高推理模型负责前期开放式探索与最终仲裁,轻量级模型则严格执行硬门禁与确定性比对,从而兼顾灵活性与推理成本。 - [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 试图用单一 Agent 处理全部任务是典型反模式,模型容易被淹没并丢失部分任务,解耦为专注特定领域的专家 Agent 蜂群是更稳健的选择。 - [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 多专家 Agent 各自输出局部最优结果时容易产生冲突,必须引入全局 Judge Agent 对零散结果进行统筹融合与合理性裁决。 - [14:41](https://www.youtube.com/watch?v=EcqMYoIV57A&t=881s) Qodo 的代码审查工作流由 Context Collector 先行切分数据并分发给安全、Diff 和 Jira 等专家 Agent,最后由 Judge Agent 剔除不相关建议。 - [16:08](https://www.youtube.com/watch?v=EcqMYoIV57A&t=968s) 模型本身缺乏组织特有的工程习惯,系统通过建立 PR 历史索引并进行两阶段注入,校准专家 Agent 输入与 Judge Agent 的仲裁权重。 - [19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 组织可在门户中配置全局架构与安全规范以补充 Agent 的局部视角;在缺乏文档的开箱即用场景下,系统则依靠 PR 历史沉淀逐步学习隐性规则。 - [23:22](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1402s) 评审节点引入采纳反馈闭环,开发者对某类建议的采纳或否决动作会实时反哺索引,动态调整该模式在未来评审中的置信权重。 - [24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 历史代码存在幸存者偏差,架构设计必须将不可违背的硬性规则与通用缺陷建议严格剥离,防止模型将遗留陋习作为正向经验自适应学习。 ## Detailed walkthrough ### [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 从确定性 DevSecOps 到不确定性的 Agent 世界与架构演进 Nupur 介绍了自己的工作背景:她就职于 Qodo(原 Codium),专注于代码审查 Agent(agentic reviews)的研发。在此之前,她的背景是 DevSecOps。这是一个界限极为分明的领域:“流水线要么运行,要么崩溃。如果崩了,我们就去修好它。”在这个曾经一切皆可预测的世界里,逻辑是完全确定性的(deterministic)。然而,转向 AI Agent 研发后,面对的却是一个完全不确定、充满不可预测性的环境。过去几年中,她深入探索了 Agent 到底在哪些环节会失败、为何会失败,并希望将这些一线教训分享出来。 回顾 Agent 架构的演化过程,最初是从只有 4K 上下文窗口的静态 Prompt(static prompts)起步的。当时开发者必须费尽心机挑选所谓“最关键”的信息塞给模型让其处理。这种做法意味着人类背负着沉重的筛选负担:“这意味着责任落在我们身上,由我们去告诉 LLM 应该关注什么;如果我们提供了错误的输入,就可能得不到正确的结果。” 随后,业内寄希望于上下文窗口的扩大,认为输入变大就能解决问题,并逐渐走向了 Agent 工作流:给模型配备搜索工具,让它自主查询文档并执行命令。然而,这立刻带来了新的死循环(loop)——工具根本不知道何时该停下,总觉得自己缺少信息,于是不停地回头继续检索。为了进一步提升能力,如今多 Agent 架构(multi-agent systems)大行其道,团队会部署安全审查 Agent、代码 Review Agent、修代码的 Coding Agent 等等。但工具与角色越多,引发的混乱也越多:各个 Agent 之间的理解往往存在分歧与冲突(clash in their understandings),最终导致任务根本无法收敛得出结果。 ```mermaid flowchart TD accTitle: Agent 架构演进阶段 accDescr: 展示从早期静态单 Prompt 到当前多 Agent 架构的发展演变及各自面临的问题。 subgraph Phase1["第一阶段:静态 Prompt"] A["4K 极小上下文"] -->|"强依赖人工筛选"| B["输入偏差导致结果错误"] end subgraph Phase2["第二阶段:单 Agent + 工具调用"] C["扩展上下文 + 搜索工具"] -->|"缺乏终止条件"| D["无限检索死循环"] end subgraph Phase3["第三阶段:多 Agent 协同"] E["专职 Agent 团队<br/>(安全/审查/编码)"] -->|"语义与目标冲突"| F["逻辑打架,无法达成共识"] end Phase1 --> Phase2 Phase2 --> Phase3 ``` - **静态 Prompt 时代**:受限于 4K 上下文窗口,人类负责硬编码上下文,对输入质量极度敏感。 - **工具调用循环**:引入 Agent 自动化工具后,模型在缺少退出策略时极易陷入反复搜索补充输入的死循环。 - **多 Agent 协同困境**:不同专职 Agent 间缺少对齐机制,互相碰撞导致任务难以收敛。 --- ### [02:34](https://www.youtube.com/watch?v=EcqMYoIV57A&t=154s) 上下文 U 型曲线(U-Curve)与信息遗忘现象 随着大模型能力提升,上下文容量看似不再是瓶颈,业界可以一股脑将海量数据扔给模型。然而,Nupur 提出质疑:模型真的变聪明到能替你分辨什么是重要的了吗?现实情况恰恰相反:当前的大语言模型表现出极其明显的“U 型曲线”(U-curve)模式——它们能关注到最开始给出的目标指令,也能关注到最后追加的输入,但直接忽视并抛弃了夹在中间的大量上下文。 现场有听众立刻追问:“你们是怎么知道这一点的?”Nupur 回应称,这来自于 Qodo 内部持续进行的基准测试(benchmarking)。在多 Agent 架构中执行代码审查任务时,团队尝试将整个代码库作为背景全面喂给模型,观察其是否真正消化了所有上下文。测试结果非常一致:模型牢牢记住了开头的初始目标,也能留意到最后输入的提示,但夹在中间的大规模上下文——比如关联的 Jira 工单信息或 Model Context Protocol(MCP)等服务拉取的数据——统统被 LLM 默默丢弃(purge),模型依然只靠头尾碎片自行拼凑结论。 “这就像一条 U 型曲线,开头的某些部分和结尾的某些部分起到了作用,但你无论在中间塞进什么,都不会被真正采纳吸收。” Nupur 直言。 --- ### [04:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=271s) 上下文优化的四大战略路径与权衡 为了解决中间信息丢失的问题,不能再无脑向模型倾倒数据,而必须引入战略性的上下文优化方案(strategic solutions for context optimization)。Nupur 详细拆解了业界主流的几条实现路径及其工程取舍: 1. **上下文引擎(Context Engine)**:当下极为火爆的概念,其定位就像是一个拦截在代码访问链路上的“保镖”(bouncer)。面对庞大而混乱的代码库,它能建立搜索模式与排序逻辑,筛选出最相关的部分交付给 Agent。但是,它的痛点在于索引与横向扩展极度困难:当代码仓库规模扩大到六七百个代码库(600–700 repositories)时,映射和索引构建会严重变慢,维护成本对于非专门做上下文引擎的公司来说难以承受。 2. **分层摘要(Hierarchical Summarization)**:不让 Agent 翻阅所有完整文件,而是为每个文件和文件夹提前生成摘要。Agent 检索时先读取摘要再判断是否值得深入。这种方式效果显著,但严重依赖前置的 LLM 处理:任何文件的创建或修改都需要触发 Agent 重新生成映射,产生极高的前期 LLM 算力消耗(high upfront LLM processing)。 3. **知识图谱(Knowledge Graph)**:结构极其复杂,但在梳理强逻辑依赖关系(如跨文件连锁修改、多代码库依赖)时表现绝佳。通常需要搭建图数据库(Graph DB)支持,开发者前期的搭设与维护成本极高,但对于大型复杂逻辑网络收益明显。 4. **迭代检索(Iterative Retrieval)与自我修正(Self-Correction)**:对于并非专门做工具软件、只是为内部业务构建 Agent 的团队而言,迭代检索是最具性价比的方案。它就像给 Agent 一张“图书检索卡”(library card),只展示主题,由 Agent 按需深入。其开发门槛低,效果好,仅会产生少量的额外调用成本。另一种配套方案是引入“评估批判节点”(critic node)进行自我修正,一旦发现偏离最初目标就让 Agent 重新尝试,虽引入了额外的运行延迟,但对开发者的前期投入要求极低。 | 上下文策略 | 核心机制 | 前期开发投入 | 算力/延迟代价 | 最佳适用场景 | |:--- |:--- |:--- |:--- |:--- | | **上下文引擎** | 专用检索与重排算法 | 中等(索引搭建) | 面对 600+ 仓库时扩展与速度急剧下降 | 超大型单体/混乱代码库 | | **分层摘要** | 为各级文件目录生成摘要 | 极高(每次文件变更需重新处理) | 高前置 LLM 处理成本 | 目录结构清晰、需快速宏观判断的项目 | | **知识图谱** | 借助图数据库映射逻辑依赖链 | 极高(需人工梳理复杂逻辑) | 存储与维护成本高 | 跨代码库强逻辑依赖、复杂级联变更场景 | | **迭代检索** | 类似图书借阅卡的索引按需下钻 | 低 | 轻微成本增加 | 内部业务 Agent、快速落地自建流程 | | **自我修正** | 独立 Critic 节点校验输出并重试 | 极低 | 增加单次执行的端到端延迟 | 容错率低、对精准度要求高的任务流 | --- ### [08:31](https://www.youtube.com/watch?v=EcqMYoIV57A&t=511s) 编排悖论与 80/20 混合架构(The 80/20 Approach) 另一个困扰 Agent 开发的顽疾是“编排悖论”(orchestration paradox)。随着模型推理能力越来越强(例如使用最新的 Claude Opus 等高推理模型),模型往往会“聪明反被聪明误”。接收到任务后,它不仅不去动手解决问题,反而沉迷于方法论的选择:“我应该用这个工具吗?还是先去调研一下有没有更好的途径?”模型在一个又一个方法论之间反复横跳自我怀疑,耗费了海量 API Token 却全花在了寻找解法而不是执行解法上。 “它们在不同方法之间反复横跳,大部分 API Token 都浪费在寻找实现途径上,而不是真正去执行它。” Nupur 指出,这直接让 Agent 彻底陷入了纯粹的调研死循环。 针对这一困境,Qodo 团队提出了 **80/20 混合策略(80/20 hybrid approach)**: - **80% 开放式调研阶段**:给予高推理模型充分的自由度去进行前期探索、规划和寻找工具。为了防止这一阶段无限漫延,系统会加设确定性的熔断机制(counter mechanism),例如限制最多执行 4 到 5 次交互计数,或设置 5 分钟超时计时器(timeout counters),超时后强制提取当前最终决策向下流转。 - **20% 确定性校验阶段**:进入最后的结果提炼、摘要与验证环节时,坚决剥夺模型的自主发散权,改为高度受控的硬门禁(hard gates)。该阶段遵循严格的确定性逻辑(如“得到 X 结果就必须输出 Y”),且无需使用昂贵的高推理模型,轻量级确定性模型足以胜任。比如上文提到的 Critic 审查节点,根本不需要思考调研,只需严格比对最终输出是否契合最初设定的目标。 ```mermaid flowchart TD accTitle: 80/20 混合编排架构 accDescr: 前端 80% 采用高推理模型进行开放式探索并辅以计数/超时熔断,后端 20% 采用轻量模型执行确定性校验与收敛。 subgraph OpenDiscovery["80% 开放式发现与规划阶段 (高推理模型)"] Task["输入目标任务"] --> Reasoning["自主规划 / 工具探索"] Reasoning --> LoopCheck{"达到 4-5 次计数<br/>或 5 分钟超时?"} LoopCheck -- 否 --> Reasoning LoopCheck -- 是 --> Freeze["强制收敛并冻结当前决策"] end subgraph HardGates["20% 确定性收尾阶段 (轻量级模型)"] Freeze --> Critic["Critic 审查节点"] Critic --> Verify{"是否符合初始目标?<br/>(严格硬门禁: X -> Y)"} Verify -- 合格 --> Output["输出最终确定性结果"] Verify -- 不合格 --> Retry["回滚重试 / 降级策略"] end ``` - **编排悖论的本质**:高推理模型算力被过度消耗在“选择如何做”而非“实际去做”的元推理循环中。 - **80% 调研控制**:通过 4~5 次计数上限或 5 分钟超时机制对顶尖模型的发散推理进行硬性约束。 - **20% 确定性硬门禁**:采用轻量模型替代高智商模型执行收束、比对与总结,大幅砍掉冗余成本并提升系统可靠度。 ### [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 80/20 模型分工与“单 Agent 承载一切”的失效陷阱 在构建复杂工作流时,80% 的动态模型(轻量级/确定性模型)非常适合处理具体执行层面的事务,例如总结内容、根据当前提取的结果判断下一步该查找什么操作;而具备高推理能力的 20% 模型,则专门负责更高维度的仲裁与决策——在拿到下层返回的所有零散结果后,裁定哪一种方式或哪一项输出才是用户真正需要的目标。 Nupur Sharma 指出,随着上下文窗口不断扩大,许多工程团队掉进了一个经典的认知陷阱:“因为上下文窗口足够大,我们就用一个 Agent 搞定所有事情。”团队把测试、代码审查、逻辑核对等所有任务一股脑塞给同一个 Agent,寄希望于它能在庞大的上下文里输出全部答案。然而,这种做法会导致 Agent 在前行过程中彻底被输入信息淹没,进而偏离并遗忘原本的核心任务。“所以你可能给 Agent 分派了四个任务,但在执行过程中它只聚焦在其中两个任务上。对于这两个任务你确实得到了不错的结果,但另外两个任务在半途就直接丢失了。” ```mermaid flowchart TD accTitle: Single Agent Bottleneck vs Mixture of Agents accDescr: Comparison of a bloated single agent failing across tasks versus specialized agents arbitrated by a judge. subgraph AntiPattern["单 Agent 瓶颈(容易丢失任务)"] A["单一大上下文 Prompt<br/>(测试 + 审查 + Jira + 安全)"] --> B["超载的单 Agent"] B --> C["聚焦任务 1 & 2 (丢失任务 3 & 4)"] end subgraph MOA["多智能体协作架构 (Mixture of Agents)"] D["上下文与任务分配"] --> E["安全专家 Agent"] D --> F["代码审查 Agent"] D --> G["Jira 关联 Agent"] E --> H["仲裁 Agent (Judge Agent)"] F --> H G --> H H --> I["全局一致的高质量输出"] end ``` --- ### [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 智能体混合(Mixture of Agents)与仲裁者(Judge Agent)机制 为了解决单一 Agent 认知超载与中间信息丢失的问题,当前行业兴起了“多智能体架构”(Multi-Agent Architecture)或“智能体混合”(Mixture of Agents)。这种架构的核心在于解耦:不再强求一个大包大揽的通用 Agent,而是针对特定任务构建专注精通的小型“领域专家 Agent”(Issue Expert Agents)。 然而,拆分成多个专家 Agent 后会带来全新的集成挑战:各个 Agent 单独拿出的结果可能都很优秀,但彼此之间却毫无关联甚至相互冲突。Nupur 用搜索度假行程举例:“比如我想规划一次度假,让一个 Agent 去找最佳酒店,另一个 Agent 去找最佳目的地,第三个 Agent 去找最优航班。结果三者各自为政:酒店在希腊,航班是从阿姆斯特丹飞往葡萄牙,所有信息拼凑在一起完全对不上。”为化解这一矛盾,系统中必须引入“仲裁智能体”(Judge Agent):“它的职责是收集所有子 Agent 的结果,评估它们组合在一起是否合理。借助 Judge Agent,既能保留各专家 Agent 最顶尖的局部成果,又能将它们统筹融合成一份逻辑自洽的最终结论。” - **单一 Agent 缺陷**:上下文过载引发注意力漂移,往往只能完成部分子任务,其余任务被“吞噬”。 - **专家 Agent 特性**:各司其职,专门攻克特定边界内的问题(如漏洞挖掘、规范比对)。 - **Judge Agent 作用**:充当总览全局的评估者与协调者,消解子 Agent 间的冲突输出。 --- ### [14:41](https://www.youtube.com/watch?v=EcqMYoIV57A&t=881s) Qodo 代码审查架构:从 Context Collector 到 Judge Agent Nupur 随后详细展示了 Qodo 在生产环境中运行的代码审查架构。在审查拉取请求(Pull Request, PR)时,系统第一步并非直接唤起模型出具审查报告,而是由 Context Collector(上下文收集器)先行动作。它负责从 PR 本身、上下文引擎以及关联的各项外部工具中抓取背景数据。 Context Collector 汇集到信息后,绝不会粗暴地把全量数据一次性丢给某一个模型,而是精准切分(bifurcates),将最对口的上下文分发给专门的子 Agent: - **安全 Agent**:专门筛查潜在的安全缺陷与漏洞。 - **Diff 分析 Agent**:专注于代码层面的改动逻辑。 - **任务追踪 Agent**:核对关联的 Jira 工单信息。 当各专家 Agent 输出分析结论后,后置的 Judge Agent 启动。它不仅会校验这些结论是否足够深入,还会再次调阅上下文引擎与过往 PR 记录,评估“给出的 10 项建议中,到底有几项与当下的代码和团队习惯真正相关”,借此剔除无关噪声,只把真正有价值的审查反馈交付给开发者。 --- ### [16:08](https://www.youtube.com/watch?v=EcqMYoIV57A&t=968s) 现场问答:Agent 间通信、Prompt 链转接与“校准”机制 在问答环节,有现场观众询问多 Agent 蜂群(Swarm)在底层是如何具体实现彼此通信的,是依靠文件系统还是专有工具。Nupur 澄清,Qodo 在底层利用了 LangChain 来构建跨 Agent 通信的基础设施。观众追问具体的传递流程是否就是收集上一节点的响应并硬塞进下一个节点的 Prompt 中,Nupur 回应:“是的,完全正确。我们的做法就是提取前序阶段的输出结果,为下一个 Agent 构建 Prompt;如果涉及多个来源的复杂数据,还会有专门的收集 Agent 负责清洗汇总,提炼出针对下一阶段更加精准的上下文 Prompt。” ```mermaid flowchart LR accTitle: Qodo Multi-Agent PR Review Workflow accDescr: Sequence of context collection, agent routing, and calibration via historical PR data. PR["PR 提交与环境变更"] --> CC["Context Collector"] CC -->|"切分上下文"| Sec["安全审查 Agent"] CC -->|"切分上下文"| Diff["代码 Diff Agent"] CC -->|"切分上下文"| Jira["Jira 状态 Agent"] Sec --> Judge["Judge Agent<br/>(结合历史 PR 判定)"] Diff --> Judge Jira --> Judge History[("PR 历史索引库<br/>团队偏好/过往反馈")] -.->|"一校:前置输入"| CC History -.->|"二校:仲裁权重"| Judge Judge --> Out["最终精简 Review 建议"] ``` 接着,观众抛出关于“校准”(Calibration)的疑问——团队如何向 Agent 明确什么代码实践是“好的”、什么判定是“坏的”。Nupur 解释,LLM 本身对具体团队的偏好与行业惯例一无所知;无论是医疗、零售还是金融行业,即便使用同一套 Java 框架,关注的架构优先级也截然不同。Qodo 采用两项核心机制对 Agent 进行行为校准: 1. **建立 PR 历史索引**:系统为代码库的所有历史 PR 建立索引,查找过往类似场景的修改记录。 2. **两阶段上下文注入**:历史数据会被注入两次——“第一次是在为各子 Agent 分配上下文时;第二次则是注入给 Judge Agent。这样当针对一次代码审查产生 15 条不同的改进建议时,Judge Agent 能够参阅过往资深审查员和开发者的互动评论,据此决断这 15 条建议中哪些真正值得推送给当前的开发者。” --- ### [19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 局部视角与全局架构的张力:人类经验与组织规则配置 随后,现场观众就架构评估提出了更深层的质疑:如果每个 Agent 仅拿到被剥离后的局部上下文,在彼此割裂、不掌握全局架构图景的前提下独立运行,该如何做出需要权衡妥协的全局判断?“在人类做代码审查时,拥有全局视角至关重要。仅给局部信息可能应付得了 Linting 或者测试覆盖率这种基础工作,但一旦涉及兼顾安全与系统平衡的架构设计决策,缺乏全局视野的 Agent 该如何应对?” Nupur 结合传统研发团队的角色分工进行回应。在过去,代码审查本就是多角色协作的产物:资深工程师把控框架规范与整体习惯,安全专家紧盯 API 硬编码与 SQL 注入,合规审计员检查审计日志;每个人本身就带着不同侧重的专业视角。如今在 Agent 架构中,系统通过门户配置来补足架构维度的全局规范:架构师可以在后台设定架构指南,合规人员上传安全准则,Context Collector 在理解这套完整规则的前提下,再将匹配的上下文下发给相应 Agent 执行校验。 针对观众关于“是否必须强制客户上传这类架构文档,否则系统输出质量将截然不同”的追问,Nupur 说明道:“这完全取决于不同组织的成熟度。有些团队崇尚完全不设限的自由开发,要求系统开箱即用;但这也意味着,在系统积累起足够的 PR 历史数据之前,不要指望 Agent 能够捕捉到团队特有的隐性规范。”PR 历史在此充当了兜底校准网:即使团队未主动维护成文的架构规范,系统也能逐步通过过往的代码沉淀与审查互动,学习并反哺出符合该组织习惯的代码审查边界。 - **组织规则配置**:架构师与安全合规团队可在 Web 门户预设硬性准则,由 Context Collector 下发校验。 - **开箱即用与冷启动权衡**:不提供外部规则文档时,系统极度依赖历史 PR 索引的沉淀与迭代反馈。 ### [23:22](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1402s) 评审节点中的权重平衡与动态反馈机制 在问答环节中,观众针对代码评审系统中的仲裁节点(Judge Node / Jury)提出了一个棘手的现实问题:当系统引入多源信息时,应该如何权衡各个上下文来源的权重?提问者举例指出,团队新出台的工程原则、架构规范文档与历史遗留的合并记录(PR history)之间,可能会存在严重的冲突或失衡,如果只参考历史合并代码,很可能会把过去的坏习惯当成正确规范。Nupur Sharma 对此幽默地插话回应道:“有人正在我家做饭呢,但这确实可以作为上下文来源之一,这就是为什么需要有多种多样的信息源。” ```mermaid flowchart TD accTitle: 评审系统动态权重反馈机制 accDescr: 展示合规规则与PR历史如何通过开发者采纳行为动态调整建议权重 subgraph Sources["上下文输入源"] A["合规与架构规范文档<br/>(强制规则/错误)"] B["PR 历史与遗留代码<br/>(通用建议/模式)"] end subgraph JudgeNode["评审仲裁节点 (Judge / Jury)"] C["信息聚合与初始权重赋值"] D["开发者采纳行为追踪<br/>(Accept / Reject)"] end subgraph WeightAdjust["动态权重更新"] E["采纳建议 -> 提升该模式权重"] F["驳回/忽略 -> 降低该建议权重"] end A --> C B --> C C --> D D -->|采纳| E D -->|拒绝/未实现| F E -.->|"迭代下一次评审"| C F -.->|"迭代下一次评审"| C ``` Nupur 详细剖析了系统在平衡这些冲突上下文时的多维度设计。单从单一视角来看确实难以抉择,但 Qodo 的做法是从多角度构建上下文网络。系统会在合规门户中对不同反馈进行分级:某些属于严重错误(Error),某些则属于普通优化建议(Recommendation)。每一次反馈都会根据其类别打上基准权重。更关键的是引入了持续的动态反馈循环:每当开发者采纳了一条 Agent 提出的建议,这种模式在下一次评审中的权重就会得到提升;如果开发者反复拒绝或忽略某条建议,它的权重便会被削弱。Nupur 总结道:“And every time your developer expect accepts a suggestion, it gets more weighted for the next one.” 系统的核心就在于建立索引并持续管理和更新这些动态权重。 - 系统获取上下文的来源绝非单一依赖历史代码,而是结合了 PR 历史记录、架构合规规范及工程原则文档。 - 仲裁机制对建议进行了分层管理,明确划分为阻断性的错误(Errors)与参考性的推荐(Recommendations)。 - 系统通过双向追踪闭环:实时记录当前 PR 中开发者对建议的采纳情况,并在后台索引中动态调整对应规则的置信权重。 --- ### [24:54](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1494s) 强制规则与惯性陋习的博弈及结语 对于权重具体的追踪和计算方式,Nupur 解释了团队落地的两种主要途径。第一种是在当前工作流中进行即时捕获,直接索引开发者面对推荐时的采纳(Accept)与否决(Reject)动作;第二种则是深度回溯过去的 PR 历史,分析历史上检测出的同类问题以及开发者是否真正落实了修复。提问者随即指出,历史代码往往存在“幸存者偏差”,过去发生过的事并不代表它是对的。Nupur 对此深表赞同,并分享了自己在实际工作中遇到的真实拉扯:有些工程师习惯了直接在代码中硬编码 API 密钥(hard-coding API keys),甚至会理直气壮地争辩“我们平时一直就是这么干的”。Nupur 当时态度非常坚决地回绝:“No this is should this should not be the way.” 为了彻底解决这种“历史遗留陋习与最佳实践”的冲突,Nupur 阐明了系统内部“硬性规则(Rules)”与“通用缺陷分析(Bug Fixes)”的本质区别。当安全团队或架构师将某项标准定义为显式规则(例如严禁硬编码密钥)时,无论团队以前的代码风格如何、开发者主观上是否想要看到,系统都会将其强制高亮并拦截。而对于常规的潜在 Bug 或优化建议,Agent 会给出警告;如果人类评审者和开发者连续十次都选择忽略该建议且不予实现,系统就会自动降低此类提示的权重,避免产生烦人的告警疲劳。Nupur 明确界定了规则与自适应学习的边界:“So if you provide them as a rule it will get highlighted doesn't matter if you want it or not.” 提问者对此方案表示十分认可并致谢,整场演讲在掌声中正式落下帷幕。 - 跟踪采纳度的两大路径:实时监测当前 PR 建议的采纳动作,以及交叉比对历史 PR 中同类问题的真实修复执行率。 - 区分不可逾越的规则(Rules)与可自适应调节的缺陷建议(Bugs),防止模型把过去的坏实践(如硬编码 API 密钥)当成正向经验学习。 - 动态降权过滤告警噪音:若某项推荐型提示被工程师连续 10 次忽略且未采纳,系统将判定其不符合团队当前场景并自动下调其展示权重。 ## Notable quotes > [13:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=794s) 借助 Judge Agent,既能保留各专家 Agent 最顶尖的局部成果,又能将它们统筹融合成一份逻辑自洽的最终结论。 — Nupur Sharma > [11:49](https://www.youtube.com/watch?v=EcqMYoIV57A&t=709s) 你可能给 Agent 分派了四个任务,但在执行过程中它只聚焦在其中两个任务上。对于这两个任务你确实得到了不错的结果,但另外两个任务在半途就直接丢失了。 — Nupur Sharma > [19:43](https://www.youtube.com/watch?v=EcqMYoIV57A&t=1183s) 在系统积累起足够的 PR 历史数据之前,不要指望 Agent 能够捕捉到团队特有的隐性规范。 — Nupur Sharma > [00:14](https://www.youtube.com/watch?v=EcqMYoIV57A&t=14s) 责任落在我们身上,由我们去告诉 LLM 应该关注什么;如果我们提供了错误的输入,就可能得不到正确的结果。 — Nupur Sharma ## Mentioned Nupur Sharma, Qodo, Codium, Claude Opus, Model Context Protocol, Jira, LangChain, Java ## Video description Give an agent your full codebase and it will attend to the start and the end, then quietly drop the middle. Nupur from Qodo calls this the U curve and builds the whole talk around it: why growing the context window did not fix the problem, and what actually does. She runs through iterative retrieval, hierarchical summarization, and self correction with honest cost tradeoffs for each. The second half covers the orchestration paradox: capable models burn most of their tokens deciding how to solve a problem rather than solving it. Her team's fix is an 80/20 split, using high reasoning models for open ended discovery and lighter deterministic models for validation. Qodo's code review architecture runs this live: a context collector feeds specialized agents, a judge node recombines the results and weighs them against PR history, and every accepted or rejected suggestion shifts the weights for the next run. Speaker info: - https://www.linkedin.com/in/nupursh/ --- Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/EcqMYoIV57A-why-more-context-makes-your-agent-dumber-and-what-to-do-about-it Join our upcoming AI Engineer conferences (see https://ai.engineer landing page): - AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney --- [Source](https://www.youtube.com/watch?v=EcqMYoIV57A)

Source quotes

[13:14] Nupur Sharma: 借助 Judge Agent,既能保留各专家 Agent 最顶尖的局部成果,又能将它们统筹融合成一份逻辑自洽的最终结论。 [11:49] Nupur Sharma: 你可能给 Agent 分派了四个任务,但在执行过程中它只聚焦在其中两个任务上。对于这两个任务你确实得到了不错的结果,但另外两个任务在半途就直接丢失了。 [19:43] Nupur Sharma: 在系统积累起足够的 PR 历史数据之前,不要指望 Agent 能够捕捉到团队特有的隐性规范。 [0:14] Nupur Sharma: 责任落在我们身上,由我们去告诉 LLM 应该关注什么;如果我们提供了错误的输入,就可能得不到正确的结果。