Agent 架构设计 · 题目列表
共 935 题
- 什么是 LLM Agent?与传统 LLM 应用有何区别?
- 解释 Agent 的核心组件:感知、推理、行动、记忆
- Agent 架构模式详解:ReAct、Plan-and-Execute、LATS、Proactive
- 如何设计一个分层 Agent 架构(Orchestrator / Worker 模式)?
- Agent Loop 设计:循环控制、终止条件与错误恢复
- Workflow vs Agent:什么时候用确定性工作流,什么时候用自主 Agent?
- 如何实现 Agent 的自我反思(Self-Reflection)和自我纠正?
- 生产级 Agent 系统设计(含智能客服实战案例)
- 面试追问链:从「什么是 Agent」到系统设计的 10 层递进追问
- 什么是 Agent Harness?与 Framework / Runtime 三层抽象有何区别?
- 什么是 Computer Use / Browser Use Agent?它与 API Agent 有何区别?
- 什么是 Deep Research / Agentic Search Agent?它和 Agentic RAG 有何区别?
- 什么是 Function Calling?它是如何工作的?
- 如何为 LLM 定义和描述工具(Tool Schema)?
- Tool Use 的常见模式:API 调用、数据库查询、代码执行
- 如何设计 Tool Gateway 和工具权限管理?
- 工具选择策略:LLM 如何决定使用哪个工具?
- 如何处理工具调用失败和超时?
- MCP(Model Context Protocol)是什么?它如何标准化工具集成?
- 并行工具调用 vs 顺序工具调用的设计考量
- 如何实现动态工具发现和注册?
- 工具使用的安全性:防止注入攻击和越权操作
- 什么是多 Agent 系统?与单 Agent 相比有何优势?
- 多 Agent 通信模式:消息传递、共享状态、黑板模式
- Agent 编排模式:Hub-Spoke、Pipeline、Hierarchical
- 如何设计 Agent 间的任务分配与协调?
- 多 Agent 系统中的冲突解决机制
- 比较主流多 Agent 框架:CrewAI、AutoGen、LangGraph
- 如何实现 Agent 间的 Handoff(任务交接)?
- 多 Agent 系统中的涌现行为与可控性
- 如何调试和监控多 Agent 系统?
- A2A(Agent-to-Agent)协议是什么?它与 MCP 有何区别?
- 推理策略详解:Chain-of-Thought 与 Tree-of-Thought
- 任务分解(Task Decomposition)的基本方法
- Plan-and-Solve 与动态重规划
- LLM 作为规划器的局限性与缓解方案
- 2026 推理 / Agent 模型版图:Claude / GPT / Gemini 三家旗舰对比与选型
- Monte Carlo Tree Search 在 Agent 规划中的应用
- 如何评估 Agent 的推理质量?
- 因果推理在 Agent 决策中的作用
- Agentic-RL 是什么?如何用 GRPO 训练 Agent 的决策能力?
- System Prompt 设计的核心原则
- Few-Shot vs Zero-Shot Prompting:如何选择?
- 结构化输出(Structured Output):如何让 LLM 返回 JSON/XML?
- Agentic Prompting:如何编写让 LLM 自主执行任务的 Prompt?
- Prompt Chaining:多步骤 Prompt 的设计与编排
- 如何防止 Prompt Injection 攻击?
- 自动化 Prompt 优化:DSPy / APE / OPRO / PromptBreeder 全景
- Prompt 版本管理与 A/B 测试
- 跨模型 Prompt 迁移:如何编写模型无关的 Prompt?
- 什么是 Context Engineering?它与 Prompt Engineering 有何本质区别?
- ReAct vs Plan-and-Execute 怎么选?
- Agent 长短期记忆如何分层?
- 多轮对话上下文状态管理机制
- Agent模块协作机制与失败场景
- 多 Agent 协同如何分工?
- Agent 系统实现流程与核心组件
- ReAct 架构原理与失败场景
- Agent工具定义、注册与安全控制有哪些?
- 用户要先核库存再下单,客服侧却只跑了一轮 LLM 补全、随口造出订单号。缺掉的是哪一层能力?
- 眼下只有人抛出「下午有空吗」时这名日程助手才会去翻日历,产品却希望它一旦发现冲突就自行改期。从被动应答迈向主动改期之前,为何必须先落地授权范围、动作通知和一键撤销,而不是先换更强的模型?
- 调研这条线已经连搜 12 趟,模型每次收工都甩「再看一篇就齐了」。模型自称做完能不能当唯一停机开关,编排层是否必须另用刚性指标收口?
- 让模型先写指摘再重跑,步数变成两倍而成功比例毫无变化。自评该在何时中止,改去挂上外置检查器?
- 一连发出五个工具调用却忽略 Observation;另一条轨迹三轮都停在 Thought,始终没有发出 Action。ReAct 规定的交替节拍坏在哪一拍?
- 资金划转实际发生在哪一侧?补全只是提出 refund 并带上 order_id。如果执行器没做校验就把款退了,还能说系统会用工具吗?
- 怎样写「改配送地址」的参数、失败码和副作用注释,才不会把「查地址」那一轮做成写入?要细到什么程度才够?
- 订票助理挂载的工具由 12 种膨胀到 80 种,查机票的 search_flights 与查酒店的 search_hotels 从此常被它弄反。每轮全量下发完整定义,为何反倒拖累选择?按需暴露应当依据什么来分组?
- 表结构在第 3 步已经被改过——规划器给出的改库计划有八步。该把计划整份推翻重做,还是仅仅修补尚未执行的步骤?
- 会话前端有四套、对内 API 有十二套,新助手上线总在重写同一套适配。MCP 把 N×M 胶水里哪一层收成只需落地一次?
- 知识库昨天把退款时效改成 14 天,权重里仍是 7 天。用户问「退款要几天」时,怎样写系统提示、并把 tool_choice 钉死,才能禁止凭记忆作答?
- 发票 PDF 抽成字段写入内部表,为什么一次性的 schema 就够用?拿这些字段去发起退款,为什么必须有执行结果回写给模型的环?
- 执行器只开放了查询订单 get_order、创建工单 create_ticket。模型却要去调 cancel_order,还带上 order_id,并把 refund 设成 true。说明书加长为什么拦不住这种幻觉?未知函数名和未声明字段为何必须在执行层被拒绝?
- 填槽与选工具该在哪一层拆开?get_refund 这个名字选对了,金额槽却写成 1200、日期槽写成当天。用户说的是上周二、金额 1,200 的退款。schema 已把类型标成 number 与 date,为何仍不够?
- CSV 共一千行,清洗后要落库。风险该怎么衡量:让它生成 Python 脚本,还是把现成变换工具串起来?
- 写死的函数 schema 共 8 份、每次请求都带上。再包 MCP server 为什么仍然有独立价值?
- 即便 MCP 的 initialize 已经走完,为何仍不可默认对端具备全部可选能力?
- MCP 接口若标有 idempotentHint 或 readOnlyHint,调用方是否即可省略防护?
- 写操作执行后,承载 MCP 的 Streamable HTTP 连接断开了。把 tools/call 原样再发一遍为何是错误的恢复方式?断流就意味着请求没跑吗,重发之前先得确认什么?
- 客户端递来的访问令牌,MCP 代理为什么禁止把它原样转给下游 API?
- 远程 MCP 走 Streamable HTTP:浏览器里一张恶意页把域名解析到内网地址后,仍能打到 MCP 端口。服务端必须校验哪一个请求头才能挡住 DNS 重绑定,MCP-Session-Id 为什么当不了登录凭证,未授权请求该回哪一种挑战?
- 约半年的编程助手记忆开始召回过期仓库布局,以及用户早已推翻的缩进习惯。写入如何去重并挂 supersede 链接、读取如何按新近与置信度打分、定期如何合并,以及离线用冻结探针来看记忆是否仍可靠?
- 进程在第 40 步被杀掉,重启后只靠对话记录接着干,结果订单下了两次。权威状态该落在何处,为何聊天文本当不了工作流状态?
- 本单查过的工单号、用户退款偏好、教训「上次套用了过期费率」——客服刚收工时这三样都在。各应写入哪类记忆,过期如何规定?
- 甲能改仓库、乙只会空转聊天,两款编程助手却接到同一权重。优先要翻开的是 harness 哪几层?
- 迭代预算怎样从累计成功对轮次的曲线读出来?何时该把本轮快照滚回去并重置窗口?自主改仓库的外层循环要写成带契约的尝试:一轮要冻结什么输入、必须交出什么工件、验证门怎么排?
- 在 LangChain 中,聊天模型前面接提示模板、后面接一个负责解析输出的组件,三者合成一条 Runnable。末端一旦报出格式错,为何比自己手写循环更难定位数据是在哪一步走样的?链真正统一的是什么,又有哪些控制流应当移出链外?
- 这季度口袋只够做一项:上更大的模型,或把文件 I/O 和测试回环推倒重来。对照实验该怎么做,才能把钱的去向拍板?
- 季度报告该按什么章节排、哪些口径不能写,为何做成需要时才加载的说明包,而不是再注册一个工具函数?技能描述过宽或过窄时,会分别怎样选错?
- 合法顺序事先已知:先拉政策、再写回信、过合规、等人批、最后发出。为何先画状态图并配上条件边,而不是让模型在自由循环里自己排步骤?
- 某个工单流程分四步:检索、起草、等人审批、发送,而审批可能拖到两小时后。为什么要建成带状态、有条件边的图,而非在链尾再续一环?审批人离开期间,检查点到底把什么写进了存储?
- 抽条款、标风险、写对外回复都压在同一份合同上。拆成三个角色,还是做一个配了三套工具的 Agent?凭什么取舍?
- 把一次出行排出来,需要订票、签证、预算三路配合。口语对聊、协调者派结构化任务单、一块共享黑板,这三种接法该看哪类故障来定组网?
- 几万文件里要揪出竞态。主窗口该不该自己逛目录、通读全文,还是把范围收窄后交给子执行体?
- CI 已经变绿、功能却回退,评审与执行两个 Agent 还在互相覆盖对方的补丁。凭哪些信号该把它们折回成一个 Agent?
- LLM 当调度器,下面挂三个专家。必须画成确定性图的是哪些边,何种下一跳可以让模型挑?
- orders 列名可见,压测行仍被算进 GMV。为何不用系统提示,而用 OKF 那种靠链接串起来的说明文件记口径?文件如何互指才能走通?
- 生成权重为何不能充当安全边界?给办公室里的 agent 列威胁:提示注入、失控循环、数据外带、工具越权、误操作。哪些必须在执行器强制,哪些可以先写成策略提示?
- 合法 schema 里填出带破坏性副作用的参数,尽管模型刚答应只读。护栏放在提示词、工具面还是执行器?
- 生产上通过 run_sql 发出 DROP TABLE,尽管 Agent 号称只读。禁删写在提示里、执行前再弹确认,为何仍不够?工具面与库角色该如何拆权?
- 假定注入已经成功、模型愿意发信。邮件正文要求忽略既有规则并把收件箱密钥寄到指定地址。如何保证这封信仍然发不出去?
- 数学、写作、编码三类题各配了专家模型。硬路由按题型分发、现场组队由编排器现组,各自会在什么题目上更吃亏?
- 周级调研每步回灌完整轨迹,token 费用一天翻一倍。先换成更便宜的模型为什么不是正确的第一步,砍上下文该按什么顺序?
- 工单助手挂了一个不可信的远程 MCP server。该 server 在工具跑到一半时,向 host 发 `sampling/createMessage`,要把大约 80 张工单摘要成一封给经理的邮件,并点名要用用户这边最强的模型和 8000 的 `max_tokens`。host 在把对话转给模型之前必须挡住什么,为什么不能把当前会话原文原样交给这个 server?
- 端到端耗时约 90 秒,活只碰三份文件,轨迹却是 11 次挨个做 read 再 grep。哪些调用往返能并行打出,哪些有先后依赖?想提速时哪条安全底线不能松?
- 沙箱里跑出的代码对外打到了 link-local 元数据地址。隔离该落在虚拟机、容器还是仅仅进程?云凭证绝对不该进哪一层?
- 队列已经堵死:每笔退款都卡着等人点批准。必须同步停下来等人放行的是哪些动作,允许先执行、事后再抽样复核的又是哪些?
- 思考文本里已经在念剩余额度,提示也写了每单最多 0.3 美元和 8 次工具,为何账单照样被打穿?强制扣减该发生在循环的哪一拍?
- 接口返回 429、参数没过 schema、捏造未登记方法名,三种故障出现在同一轮。能不能共用一条重试路径?
- 进度停在「正在检索」,同一对 (工具, 参数哈希) 却连打 12 次。如何识别原地打转并安全拆掉,而不是仅仅加步数封顶?
- 坐席助手有时刚开口三句就丢给人工,有时对方已经在发火还埋头检索。升级该依据哪些能看见的信号,而不是听它说自己「感觉不自信」?
- 照片发票上的金额和嘴里说的对不上。跨模态该如何对齐,而不是偏信一侧或把两个数字平均?
- 老柜面没有可编程接口,要把一笔账过掉,得去点窗体上的键。Computer-Use Agent 走完一圈,把键上写着过账的字认出来常常不是最棘手的那一拍;落点若偏出二十来个像素会引发什么后果?
- 前两个钟头还按 runbook 调整配置,后两个钟头却去动不相干的服务并称之为优化,一条迁移任务全程大约四小时,每步仍自称对准目标。轨迹上哪些信号能说明是目标句被挤出窗口,而不是权重突然坏了?
- 库存接口显示有货,仓储侧已经盘亏核销。两边打架时,该按什么规则拍板,而不是折中出一个「大约一半」?
- 字段大约四十个的网申,交给浏览器 Agent 去填。瞄准控件时为何优先走 DOM / accessibility tree,而不是去猜像素?树涨到数万节点时,丢什么、留什么?
- 若评分只看最终答复对不对,会让这样的 agent 拿满分:工具名字选对了,却绕路走了 20 步,过程中还越权去读邻组文档。轨迹要记哪些字段,分数该怎样拆开?
- 什么是 Agent?核心组件是什么?它与普通 LLM 调用、固定 Workflow 有什么区别?
- 设计一个 Agent 核心执行循环。
- ReAct 是什么?生产实现中有哪些问题?
- 如何设计 Agent 状态机?
- Agent 如何判断任务完成?
- Agent 循环有哪些基础防护,如何避免无效循环?
- 如何保证 Agent 可恢复、可重放?
- Agent 中哪些逻辑应由代码控制,哪些适合交给模型?
- 如何处理中途需要用户澄清的任务?
- 什么是 HITL?如何划分审批边界并绑定具体动作?
- 如何设计可扩展的 Tool 注册体系?
- Tool 参数校验要做哪些层次?
- 如何让多个 Tool 并行调用?
- Tool 超时和重试如何设计?
- Tool 异常如何降级?
- Tool 调用链路应记录什么?
- 如何定义统一 Tool 错误模型?
- 如何防御 Tool 相关的 Prompt Injection?
- Tool 描述太多导致上下文膨胀,怎么办?
- 如何处理 Tool 输出过大?
- Agent Planning 如何做任务分解,有哪些实现方式?
- 哪些前提满足时才应该使用 Multi-Agent?
- Multi-Agent 有哪些架构?
- 什么是 Agent as Tool?
- Agent 与工作流引擎如何结合?
- 多 Agent 如何避免任务重复、状态冲突?
- 如何量化 Multi-Agent 相比单 Agent 的净收益?
- 搜索 Agent 与普通搜索有什么差别?
- 如何设计复杂问答 Agent?
- Agent 如何用于推荐?
- 交易决策类 Agent 有哪些特殊要求?
- 如何处理搜索/推荐中的实时性?
- MCP 是什么?解决什么问题?
- MCP 架构中有哪些角色和安全边界?
- MCP Tool 与普通内部 Tool 有什么区别?
- A2A 解决什么问题?与 MCP 有何区别?
- 设计 A2A 协作时要关注什么?
- 什么是 Function Calling?和传统的工具调用有什么区别?
- ReAct 框架的核心思想是什么?
- 多智能体系统(Multi-Agent)有哪些典型架构?
- Agent 的记忆系统怎么设计?短期记忆和长期记忆?
- Function Calling 经常格式不对/参数错,怎么办?
- Agent 循环失控(无限调用工具)怎么处理?
- Tool Retrieval(工具检索)为什么需要?什么时候需要?
- 怎么评估一个 Agent 系统的好坏?
- AutoGPT 类自主 Agent 和 Claude/GPT 类对话 Agent 有什么本质区别?
- 设计一个「订机票 Agent」,你会怎么拆?
- 用大白话说清什么是 Agent,和传统对话系统 / Siri 的边界?
- Agent 和 Workflow 怎么区分?判断依据是什么?
- 什么时候不该用 Agent?
- ReAct 的流程、优点、缺点?
- ReAct 和 Plan-Execute-RePlan 的区别与选型?
- 最小可用 Agent 除了工具调用还必须有什么?
- 怎么防止 Agent 死循环?为什么要三层防护?
- 停止条件怎么设计?
- CoT / ToT / Reflexion 分别解决什么?
- 反思机制怎么设计才不会无限修正?
- Anthropic 五种工作流模式?Orchestrator-Workers 与 Parallelization 的区别?
- 什么是 ACI?工具描述怎么写模型才选得对?
- 为什么 Agent 项目比传统后端更难测?
- 线上 Agent 一直调工具但不返回结果,怎么 Debug?
- Agent 落地最大的瓶颈是什么?
- Function Calling 原理?模型怎么知道调哪个工具?
- 返回的 Function Call 参数格式不对,工程上怎么处理?
- MCP 是什么,解决了什么问题?
- MCP 的 Host / Client / Server 分别是什么?通信方式有哪些?
- MCP 和 Function Calling 的区别?
- MCP Server 具体怎么开发?
- 接入第三方 MCP Server 有什么风险?如何兼顾扩展性与安全性?
- A2A 和 MCP 什么关系?多 Agent 通信协议怎么设计?
- MCP 和 Skills 有什么区别?Function Call / MCP / Skill 三者边界?
- Skill 的渐进式披露怎么实现?为什么能省 token?
- 注册上百个候选 Skill / 工具怎么处理?
- 如何决定哪个 Agent 能访问哪些 MCP?
- 工具报错、长时间无响应、连续失败,重试与异常隔离怎么设计?
- 没有 MCP 之前多 Agent 协同怎么做?
- 大规模工具集下如何降低工具幻觉?
- 多 Agent 相比单 Agent 的优势?什么时候反而更差?
- 常见的多 Agent 架构模式有哪些?怎么选型?
- 子 Agent 之间如何通信?串行还是并行?
- 主 Agent 怎么知道子 Agent 执行完了?结果怎么回收?
- 多个 Agent 结论不一致怎么处理?
- 多 Agent 用 JSON 消息异步通信怎么设计?失败有哪些兜底?
- 用 Markdown 在 Agent 间传任务,怎么防止拆分错误一路传播?
- 多个 Agent 如何做到完全隔离?
- 中心化还是去中心化调度?怎么做到失败可回退、进度可观测?
- 多智能体真的提升效率吗?独特价值怎么证明?
- 子 Agent 执行中发现需要新任务,怎么流转和审批?
- 为什么多 Agent 的 token 成本这么高?怎么控制?
- 主 Agent 和子 Agent 该用一样大的模型吗?
- A2A 和 MCP 在多 Agent 系统里各管什么?
- 怎么避免死锁 / 死循环?
- 用大白话说清什么是 Agent
- Agent 与传统对话系统 / Siri 的边界
- 为什么要用 Agent 而不是直接调大模型
- Agent 和 Workflow 的区别,判断依据
- 什么时候**不该**用 Agent
- 单次提示词 / Workflow / Agent 三者怎么选型
- 常见 Agent 架构模式
- ReAct 是什么,流程、优缺点
- ReAct 和 Plan-Execute-RePlan 的区别
- Plan-Execute 为什么需要监管 Agent
- 最小可用 Agent 的核心模块有哪些
- 企业落地 Agent 最大的瓶颈
- Agent 项目与传统后端项目的架构差异
- 怎么选底层模型?主/子 Agent 要一样大吗
- 复杂场景如何兼顾全局规划与实时反馈
- Prompt / Context / Harness Engineering 三者区别
- Harness 到底做什么
- 为什么 Harness 这个概念现在才火
- LangChain 和 LangGraph 的区别
- LangGraph 的状态快照怎么实现
- 执行链执行失败怎么降级
- 未来是 Super Agent 还是 Host + Sub Agents
- Function Calling 原理,模型怎么知道调哪个工具
- 如何理解 Tool Use
- 参数格式不对怎么处理
- 工具描述怎么写模型才选得对
- MCP 是什么,解决什么问题
- MCP 底层原理,与传统工具注册区别
- MCP 与 Function Calling 的区别
- MCP 的通信方式有哪些
- MCP Server 怎么开发
- MCP 如何兼顾扩展性与安全性
- 没有 MCP 之前多 Agent 怎么协同
- A2A 和 MCP 什么关系
- MCP 和 Skills 的区别
- Function Call / MCP / Skill 三者边界
- Skill 渐进式披露怎么实现,为何省 token
- 上百个 Skill / 工具怎么处理
- 大规模工具集如何降低调用幻觉
- 工具编排放 Skill 还是 Agent?工具在哪定义
- 如何决定哪个 Agent 能访问哪些 MCP
- 工具报错/超时/连续失败的策略
- 多 Agent 相比单 Agent 的优势
- 什么时候多 Agent 反而更差
- 常见协作模式与选型
- 子 Agent 之间怎么通信
- 主 Agent 怎么知道子 Agent 完成了
- 结论不一致怎么处理
- 异步 JSON 消息怎么设计,失败兜底
- 如何做到完全隔离
- 中心化还是去中心化调度
- 怎么证明多 Agent 独特价值
- 为什么 token 成本这么高,怎么控
- 怎么避免死锁/死循环
- 30 行写一个 ReAct loop
- 实现 Function Calling 的参数校验与重试
- 实现滑动窗口 + 摘要压缩
- 实现 BM25 + RRF 融合
- 实现 MCP 的 `tools/list` / `tools/call`
- 实现 Orchestrator-Workers 并行与汇总
- 实现 `pass^k` 评测与轨迹打分
- 实现幂等工具调用与 HITL 暂停恢复
- 手算 scaled dot-product attention
- 检测重复工具调用并终止循环
- 如果让你从 0 到 1 设计一个企业级 Agent,你会如何设计整体架构?
- 一个 Agent 系统应该拆分成哪些核心模块?每个模块分别负责什么?
- 腾讯如果要把大模型能力同时接入不同产品,不同产品之间应该如何划分职责?
- 整个 Agent 是怎么运转的?从用户输入到最终完成任务,中间经历了哪些步骤?
- ReAct 加 COT 执行流程和区别(Agent 初级)
- 为什么企业级 Agent 要采用分层架构?
- 单 Agent 与 Multi-Agent 如何选择?
- Multi-Agent 的优势和缺点是什么?
- 企业级 Coding Agent 与通用 Agent 的架构有哪些区别?
- 如果让你设计一个支持百万级用户的企业级 Agent,你会重点优化哪些模块?
- 意图理解模块如何处理多轮对话中的指代消解和意图漂移?
- 短期记忆和长期记忆之间如何做数据同步与遗忘策略?
- 多个子任务之间存在依赖关系时,编排引擎如何处理死锁或循环依赖?
- 如何设计 Prompt Injection 检测机制,是否存在误报问题?
- Replanning 与简单 Retry 的边界如何界定,什么情况下触发哪种策略?
- 如果是 Multi-Agent 架构,模块之间如何划分职责边界,避免功能重叠?
- Context Engineering 的核心目标是什么?
- 动态上下文如何组装?
- 多 Agent 如何进行任务编排?
- 如何设计 Agent 的状态管理机制?
- 多模型 Router 如何设计?
- 如何避免不同业务团队重复建设知识库?
- 如何设计统一模型接入层?
- 多模型路由策略如何设计?
- Prompt 仓库如何进行版本管理?
- 如何统一管理多个业务知识库?
- 如何实现跨业务 Agent 能力复用?
- 如何设计统一工具中心(Tool Hub)?
- 如何建设企业级 Agent 治理体系?
- Agent 编排层如何管理多轮上下文和任务状态?
- 流式输出在高并发场景下如何保证稳定?
- 如何防止 Prompt 注入和敏感数据泄露?
- 线上模型输出异常时如何快速定位根因?
- 单 Agent 和多 Agent 架构如何选择?
- 为什么没用 LangChain、Spring AI 这些 Agent 开发框架?
- LangChain 和 LangGraph 的区别以及各自适用场景(Agent 初级)
- LangGraph、AutoGen、CrewAI 等框架分别适合哪些场景?
- 如何结合 Reflection、ReAct、Plan-and-Execute 等模式构建执行框架?
- 如果让你从 0 到 1 设计一个面向千万用户的大模型应用平台,你会如何划分整体架构?
- 企业级 Agent 平台的 Harness Architecture 一般包含哪些核心模块?
- 为什么采用 AI 中台模式而不是每个业务独立建设 Agent?
- 多业务共享模型时如何进行资源隔离?
- Agent 平台与业务平台之间如何解耦?
- 如何评估不同业务线 Agent 的效果?
- AI 中台如何进行成本核算和分摊?
- 如何建设统一 Agent 开发平台?
- Agent 平台如何支持私有化部署?
- 多业务共享 RAG 平台时如何进行数据隔离?
- 大规模 Agent 平台如何实现高可用和容灾?
- Agent 平台的组织架构如何设计?
- 腾讯级别千万用户规模下如何保障平台稳定性与成本可控?
- 千万用户并发下,模型调用链路如何做限流和削峰?
- 如何设计模型网关支持多模型路由和降级?
- 如何评估平台整体效果和用户满意度?
- 多租户场景下如何做资源隔离和计费?
- 平台如何做灰度发布和 A/B 实验?
- 工具调用失败时,系统如何区分是参数错误还是工具本身不可用?
- 权限分级的具体判定依据是什么(操作类型、数据敏感度、用户角色)?
- 成功/失败判定是基于规则还是引入了 LLM 作为 Judge?
- 如何评估整个 Agent 系统的端到端可靠性(SLA、成功率指标)?
- Tool Calling 如何做失败重试和降级?
- 如何实现 Agent 全链路可观测与调试?
- 多业务场景下如何实现权限隔离?
- RAG 知识库如何支持实时更新和权限隔离?
- 长任务失败后如何实现断点续跑?
- 企业知识库权限如何和 Agent 结合?
- 如何评估 Agent 最终任务完成质量?
- 如何控制 Agent 调用成本和 Token 消耗?
- 如何实现 Agent 全链路可观测和问题定位?
- 一个企业级 Agent 系统应该拆分成哪些核心模块?规划器、执行器、工具层及记忆层和评测层如何协作?
- Agent Runtime 包含哪些核心模块?
- Runtime 与 Workflow Engine 有什么区别?
- Harness Engineering 与 Prompt Engineering 有什么区别?
- 为什么 Agent 更强调 Harness 而不是 Prompt?
- RAG 在 Harness 中承担什么角色?
- MCP 在 Harness Engineering 中如何接入?
- 如何评估 Harness Engineering 的效果?
- Harness Engineering 如何支持长任务、多轮任务和断点恢复?
- 规划器和执行器为什么要拆开?
- 如何设计 Agent 的任务状态机?
- Agent Loop 如何防止无限循环和步数爆炸?
- 如何对 Agent Loop 的工具调用做滥用与风险护栏?
- 如何对 LLM 的结构化输出在 Loop 中做校验与修复?
- Harness 如何为 Agent Loop 动态分配上下文窗口预算?
- 工具结果如何压缩与裁剪才能既省 Token 又不丢关键信息?
- Prompt Cache 失效或未命中时,Harness 如何避免成本与延迟飙升?
- Harness 如何区分 Loop 中的可重试错误与不可重试错误?
- Harness 在部分步骤失败时,如何决定回滚、补偿还是继续?
- Harness 如何设计断点续跑的状态序列化以保证可恢复?
- Harness 组件如何抽象为可插拔接口以支持灵活组装?
- 多租户场景下 Harness 如何做隔离与配额治理?
- Harness 如何做版本化、回滚与生产级压测?
- 多Agent通信和进度同步怎么做?
- A2A通信超时、子Agent服务宕机、工具调用雪崩场景下的熔断、降级、流量隔离、备用Agent兜底策略(Agent高级)
- 多个Agent返回的信息互相矛盾,你会设计怎样的处理逻辑;完整任务状态流转如何设计(Agent中级)
- Multi-Agent 如何通信?
- 如何避免多个 Agent 死循环?
- Shared Memory 如何设计?
- Planner Agent和Executor Agent如何协作?
- 多Agent之间如何共享上下文?
- 多Agent如何避免重复工作?
- Critic Agent和Executor Agent为什么要分离?
- Reflection Agent应该独立部署吗?
- 多Agent互相评审会不会增加成本?
- 黑板模式和消息总线模式各自的优缺点是什么?分别适合什么场景?
- 如果两个Agent同时修改同一个共享状态,怎么保证一致性?
- Task DAG中如果某个节点执行失败,如何决定是重试、跳过还是整体回滚?
- 如何设计消息的幂等性,防止重复消费导致任务被执行两次?
- 多子Agent输出信息冲突、结论不一致时,构建一套自动校验、权重打分、可信度排序、冲突消解机制(Agent高级)
- 心跳机制的超时阈值怎么设定?误判Agent"假死"怎么处理?
- 多Agent之间如果出现循环依赖,怎么检测和避免?
- 多Agent并发修改同一文件时如何解决冲突?
- 相比单体应用,Multi-Agent系统的可观测性(Observability)怎么设计?
- 多 Agent 系统的评测集应该如何设计?
- 如何判断某个 Agent 角色是否值得独立拆分?
- 多 Agent 协作中如何归因某次失败是哪个环节导致的?
- Orchestrator本身如果挂掉了,怎么保证整体任务不丢失?
- 多Agent协同时如何实现链路关联?
- 多Agent系统如何进行链路追踪?
- 复杂任务如何拆分子任务下发给子Agent,怎么避免任务重复下发、重复执行(Agent中级)
- A2A多智能体通信场景下,Agent调用超时、接口报错、服务宕机,重试、降级、兜底的完整方案(Agent中级)
- 多 Agent 如何进行任务分配?
- Multi-Agent任务如何拆分?
- Agent是单Agent还是多Agent?为什么这么设计?有没有考虑过另一种方案?(百度Agent)
- 多Agent主流两种架构:中心化调度、去中心化自治,分别讲实现方式、优缺点、适配什么业务场景(Agent中级)
- 对A2A架构是否了解;什么场景下单一Agent无法完成任务,需要引入多Agent协同处理(Agent初级)
- 大规模多Agent集群架构:中心化管控、联邦式协同、去中心化自治三种架构的取舍、优缺点、适配业务场景(Agent高级)
- Supervisor Agent 如何调度多个 Agent?
- Supervisor Agent的职责是什么?
- 为什么大模型调用经常使用异步编程?
- Runtime 如何支持流式输出?
- 规则引擎和 LLM 分类器各自优缺点,如何融合使用
- 如何提高任务分类的准确率?
- 分类置信度(Confidence Score)如何计算?
- Agent如何选择合适的Tool或Skill?
- RAG在任务理解阶段起什么作用?
- Agent如何进行上下文检索和上下文压缩?
- 多Agent系统中任务拆解如何进行协作?
- Coding Agent的任务拆解流程与普通Agent有什么不同?
- 多Agent协作时如何进行任务拆分与分配?
- 企业级Agent如何实现可观测性(Observability)?
- Tool Selection具体如何实现?
- 如何降低Agent的工具调用成本?
- Agent执行日志和链路追踪如何设计?
- Agent如何保存Execution Trace?
- 哪些场景必须引入人工干预?
- 如何设计任务回放的数据结构?
- 如何在任务回放中复现当时的模型输出?
- OpenHands如何实现Plan-Execute循环?
- Devin如何进行长链路任务执行?
- 企业级Agent如何实现可观测性和链路追踪?
- Agent执行过程如何记录审计日志?
- 如何设计Agent执行成本监控体系?
- Agent 与传统 ChatBot 的区别是什么?
- 为什么 RAG 不能直接解决所有上下文问题?
- 混合检索(Hybrid Search)相比纯向量检索有什么优势?
- 企业级代码库如何快速定位相关代码?
- Tool Registry 如何设计才能支持动态扩展?
- Memory 在整个执行流程中的作用是什么?
- Working Memory 与 Long-term Memory 有什么区别?
- 企业级 Agent 如何设计权限与风险控制?
- 如何实现 Agent 的可观测性(Observability)?
- 如何记录 Agent 的执行轨迹(Trace)?
- Multi-Agent 相比单 Agent 的优势有哪些?
- Allow/Ask/Deny 权限模型的判定依据是什么?是静态规则还是动态风险评分?
- 短期记忆和长期记忆分别用什么存储介质实现?如何做检索(向量检索/关键词检索)?
- 在多 Agent 协作场景下,Agent 之间如何通信和协调?
- 相比传统的 RPA 或规则引擎,这种 Agent 架构的核心优势和成本在哪里?
- 分布式锁有哪些实现方案?
- 令牌桶和漏桶有什么区别?
- 如何设计多级限流体系?
- 限流阈值如何动态调整?
- 模型TPS、RPM、TPM分别代表什么?
- 如何判断两个自然语言请求属于同一个任务?
- 多个用户共享同一个任务结果时,权限如何隔离?
- 任务结果缓存多久合适?
- 反思机制怎么做?
- 说下你对Agent的理解,如何通过反思机制提升整体任务执行成功率?(Agent中级)
- ReAct 与 Plan-and-Execute 有什么区别?
- Reflection 有什么作用?
- ReAct模式与Plan-Execute模式分别适用于哪些场景?
- Task Planning有哪些常见算法或实现方式?
- Reflection机制通常在什么阶段使用?
- Reflection与Replanning有什么区别?
- Plan-and-Execute与ReAct各自适用于哪些场景?
- LLM如何判断自己的结果是否正确?
- ReAct模式如何处理执行失败问题?
- Coding Agent中的反思机制如何实现?
- RAG系统中的反思机制如何实现?
- 人工反馈如何参与反思闭环?
- MCP 在 Agent 中解决了什么问题?
- Reflection 机制如何避免陷入无限重试/死循环?
- Reflection和Retry有什么区别?
- Reflection机制什么时候触发?
- 如何避免无限反思循环?
- Reflection最多允许执行多少轮?
- 如何量化反思效果?
- 如何设计Agent规划器,避免频繁重新规划?
- Agent在执行任务过程中,如何判断当前步骤是否成功?失败后如何重试、回滚或重新规划?
- Agent反复循环调用同一个工具、重复执行任务,怎么排查根源并优化(Agent初级)
- Agent幂等性怎么设计?
- 多个用户同时触发同一个Agent任务时,如何设计幂等机制,避免任务重复执行?
- Agent任务分布式调度,海量异步任务如何分片、负载均衡,如何避免分布式重复任务、死任务堆积(Agent高级)
- 为什么需要 Planner?
- Planner 如何进行任务拆解?
- Runtime 如何调度 Tool?
- Runtime 如何支持异步任务?
- Runtime 如何实现状态管理?
- CancelScope 为什么重要?
- Retry 应该如何设计?
- Workflow 与 Planner 有什么关系?
- 如何设计长任务执行流程?
- 如何实现任务恢复?
- 当任务分类错误时,Agent如何进行纠错?
- 一个Skill需要包含哪些信息?
- Workflow与Skill之间是什么关系?
- Planner通常由哪些模块组成?
- Workflow与Planner分别负责什么?
- Skill和Workflow有什么区别?
- Agent执行失败后如何进行重试或重新规划?
- 如何设计一个可扩展的Planner模块?
- 企业级Agent如何管理超长任务和长时间运行任务?
- 从用户输入到最终完成任务,Agent整体执行链路是怎样的?
- Agent为什么需要任务拆解,而不是一次性生成最终答案?
- Planner模块通常如何设计?
- Execution Plan一般包含哪些核心内容?
- 如何确定任务拆解的粒度?
- 什么情况下需要重新规划(Replanning)?
- 如何设计一个支持断点续跑(Checkpoint)的Agent?
- Agent如何管理长时间运行任务的状态?
- 如何设计Agent的任务队列(Task Queue)?
- 当工具调用失败时,Agent如何自动恢复?
- 如果让你设计一个支持复杂软件开发的Agent,其任务规划模块会如何实现?
- DAG和Workflow有什么区别?
- Agent如何实现动态重规划(Replan)?
- Agent如何决定是否调用工具?
- Function Calling底层机制是什么?
- 工具调用失败如何恢复?
- 如何避免工具调用循环?
- Retry策略如何设计?
- Replan和Retry有什么区别?
- 如何实现任务暂停与恢复?
- 长时间运行任务如何管理状态?
- Agent如何处理中断和超时?
- 什么情况下应该重试,什么情况下应该直接重新规划?
- 如何避免Agent陷入无限重试循环?
- 多Agent协作场景下如何进行失败恢复?
- Agent任务回滚和数据库事务回滚有什么区别?
- Checkpoint机制如何设计才能支持断点续跑?
- Agent如何实现任务暂停、恢复和回放?
- 如何设计补偿事务(Compensation)机制?
- Planner和RePlanner的职责边界是什么?
- Agent如何定位失败原因来自模型还是工具?
- 长链路Agent任务如何保证最终一致性?
- 企业级Agent如何实现高可用和故障恢复?
- 如何评估RePlanning是否有效?
- LangGraph、AutoGen、CrewAI分别如何实现失败恢复机制?
- 为什么不能仅根据HTTP 200判断任务成功?
- Retry应该在哪一层实现,Tool层还是Agent层?
- 什么情况下应该Retry,什么情况下应该直接Replan?
- Exponential Backoff为什么比固定间隔重试更合适?
- 如何避免Agent进入无限重试循环?
- Rollback与Compensation Transaction有什么区别?
- Agent如何保证外部资源操作的幂等性?
- 什么情况下需要Checkpoint机制?
- Durable Execution如何支持任务恢复?
- Agent如何判断失败原因是模型问题还是工具问题?
- Replanning需要重新调用Planner还是局部修改计划?
- 多Agent执行过程中,一个Agent失败如何影响整个Workflow?
- Human-in-the-loop通常在什么场景介入?
- 如何设计Agent的错误分类体系?
- 如何统计Agent任务成功率、重试率和恢复率等指标?
- Agent任务状态机应该如何设计?
- 任务暂停后,恢复时如何保证上下文不丢失?
- 重试时如何避免重复执行有副作用的操作?
- Agent回滚和传统数据库事务回滚有什么区别?
- 如果工具调用已经成功但模型认为失败,如何处理?
- 如何区分可重试错误和不可重试错误?
- Agent多步骤任务如何保证最终一致性?
- Tool Calling失败后如何重新规划?
- Agent执行失败后如何回滚?
- LangGraph 的 Checkpoint 机制是如何实现的?
- OpenAI Agent SDK 如何保证任务恢复?
- AutoGen 多 Agent 如何避免重复执行?
- CrewAI 如何设计任务状态管理?
- 企业级 Agent 平台如何实现全链路幂等控制?
- Agent 为什么需要 Planning,而不是直接调用 LLM?
- Task Planning 一般有哪些实现方式?
- 如何设计一个可扩展的 Planner?
- Agent 如何设计 Retry、Rollback 与 Replan 策略?
- 什么情况下应该重新规划,而不是继续执行?
- 如何避免 Agent 陷入无限循环执行?
- Planner 如何处理任务分解出错或子任务失败的情况?是否有回退(fallback)机制?
- Orchestrator 和 Planner 是否是同一模块?两者的边界如何划分?
- Observability 模块具体记录哪些指标?如何定位一次任务失败的根因?
- Agent为什么不能只依赖重试机制?
- Agent如何判断当前步骤成功还是失败?
- Task ID 和 Idempotency Key 有什么区别?
- Agent 为什么比普通 Web 服务更需要幂等性?
- 幂等性和一致性是什么关系?
- 幂等性和事务有什么区别?
- 如何保证发送邮件操作的幂等性?
- 如何保证 Git Commit 的幂等性?
- 如何保证 Jira 工单创建不重复?
- Tool 调用失败后如何重试?
- Tool 超时但实际执行成功怎么办?
- Checkpoint 如何设计?
- Workflow 如何断点续跑?
- Step 粒度应该如何划分?
- Saga 和 Checkpoint 有什么区别?
- Agent 如何实现任务恢复?
- 多个 Agent Worker 同时执行同一个任务怎么办?
- Kafka 如何实现幂等消费?
- Exactly Once 在 Agent 中如何落地?
- Event Sourcing 如何帮助实现幂等性?
- 为什么Agent系统必须采用异步队列架构?
- 如何设计百万级任务调度系统?
- 多Agent协作场景如何避免任务堆积?
- 如何解决任务饥饿问题?
- 长任务和短任务如何隔离?
- OpenAI接口限流后如何处理?
- 模型服务过载时有哪些降级方案?
- Worker宕机后任务如何恢复?
- 如何保证任务至少执行一次(At-Least-Once)?
- 如何保证任务恰好执行一次(Exactly-Once)?
- 如何实现Agent平台的弹性扩缩容?
- 高峰流量突然增长10倍时系统如何自适应处理?
- taskKey应该由哪些字段组成?
- Redis分布式锁失效会带来什么问题?
- 如何避免锁过期后任务被重复执行?
- RUNNING状态任务长时间不结束怎么处理?
- Agent中间步骤失败后如何保证不重复执行副作用操作?
- 幂等机制放在网关层、调度层还是执行层?
- 如何设计任务重试和补偿机制?
- Agent如何做任务识别,比如判断一个任务是简单问答、代码解释、代码修改,还是复杂开发任务?
- 用户输入一个需求以后,Agent如何理解用户意图,并进行任务拆解?
- 对于复杂任务,Agent应该如何进行任务拆解和执行计划生成?
- Agent执行复杂任务时,如何支持暂停、恢复、重试、回滚、人工干预和任务回放?
- Agent 如何识别用户意图?
- 如何进行任务分类?
- 如何判断一个任务是否属于复杂任务?
- DAG 为什么适合复杂任务?
- 上下文多轮对话下,如何避免任务识别偏差
- 任务识别置信度低时,反思 Agent 具体执行逻辑
- 复杂开发任务如何拆解为子任务并分配对应子 Agent
- 如何设计量化指标评估任务识别准确率
- 短模糊 Prompt、需求不完整场景下优化识别方案
- 任务识别模块如何做迭代优化与冷启动设计
- 为什么不能直接让LLM回答所有任务,而需要任务识别?
- Agent如何区分简单任务和复杂任务?
- 任务复杂度一般如何评估?有哪些指标?
- 如何设计一套Task Classification体系?
- Rule Engine和LLM分类各有什么优缺点?
- 为什么企业级Agent通常采用Rule + LLM的混合路由方案?
- Agent什么时候应该向用户发起澄清(Clarification)?
- Skill Router通常如何设计?
- Planner在任务识别之后承担什么职责?
- 如何判断一个任务需要任务拆解(Task Decomposition)?
- 如何设计企业级Agent的执行路由(Execution Routing)?
- 如何评估任务识别模块的效果?常用指标有哪些?
- 任务识别模块如何支持新增Skill和业务能力,保证系统具备良好的可扩展性?
- 如果同一个用户请求同时包含问答、代码修改和文档生成等多种意图,Agent应如何进行多意图识别与编排执行?
- Agent如何识别用户真实意图,而不是字面意思?
- 为什么复杂任务不能一次性交给LLM完成?
- Agent如何处理用户需求存在歧义的情况?
- Agent如何利用Memory提升意图识别准确率?
- Agent如何判断一个任务是否需要拆解?
- Cursor Agent如何决定搜索代码还是生成代码?
- Agent 如何控制 Token 消耗?
- Intent Classification 具体用什么模型/方法实现?规则、传统机器学习模型、还是 LLM 分类,各自的优劣是什么?
- 如何控制大模型推理成本?
- Agent如何判断是否需要调用RAG或外部工具?
- Tool Selection通常依据哪些信息?
- Agent如何判断某一步执行成功?
- 如何评估任务拆解质量和执行计划的合理性?
- Agent如何根据任务自动选择工具(Tool Selection)?
- Agent如何评估每一步执行结果是否成功?
- Agent如何判断当前步骤执行成功?
- Agent如何设计Validator模块?
- Agent任务成功率如何量化评估?
- Agent如何设计Success Criteria(成功判定标准)?
- 如何设计统一的Validator框架?
- Agent 如何构建高质量上下文(Context)?
- Agent 如何选择最合适的 Tool?
- Tool Calling 的整体架构如何设计?
- Agent 如何判断工具调用是否成功?
- 如何评估 Agent 每一步执行质量?
- 如果工具调用返回结果不可信或格式错误,系统如何兜底?
- 如何评估整个 Agent 系统的效果(准确率、任务完成率、延迟等指标)?
- 没有标准答案时如何做结果评估?
- 如何检测模型幻觉?
- 任务拆解以后,Agent如何决定先做什么、后做什么?什么时候调用模型,什么时候调用工具?
- DAG任务调度完整执行流程(Agent初级)
- 高并发任务如何排队和限流?
- Rule 与 Prompt 如何协同工作?
- Skill Matching 如何实现?
- Workflow 如何支持并行执行?
- 不同类型任务对应 Agent 资源调度策略差异
- 多文件代码修改任务如何进行规划?
- 多Agent系统中的任务分发(Task Dispatch)如何设计?
- Task Tree和DAG任务规划有什么区别?
- Agent如何确定子任务之间的依赖关系?
- 如何降低LLM在任务拆解过程中的幻觉风险?
- Task Tree和DAG任务编排有什么区别?
- 如何处理子任务之间的依赖关系?
- Agent如何实现串行执行和并行执行?
- 如何避免任务拆解过细导致执行效率下降?
- Agent如何进行动态任务调度(Dynamic Scheduling)?
- Executor模块通常负责哪些工作?
- 如何设计Agent的任务优先级调度策略?
- Agent如何构建任务DAG?
- 如何识别任务之间的依赖关系?
- 如何实现任务优先级计算?
- Agent如何支持并行任务执行?
- 什么是关键路径(Critical Path)?
- Agent执行过程中如何实现人工审批和人工接管?
- 如何设计Agent的状态机?
- Skill 与 Prompt 有什么区别?
- Agent 如何实现 Skill 的发现与复用?
- 企业级 Agent 如何实现高并发、高可用与可扩展架构?
- 多个子任务并发执行时,如何处理任务间的依赖关系和结果聚合?
- Kafka、RabbitMQ、Redis Stream分别适用于什么场景?
- 如何防止某个租户占满全部资源?
- 优先级队列如何实现?
- 如何实现公平调度(Fair Scheduling)?
- 队列消息丢失如何处理?
- 日活百万用户的Agent系统如何设计限流?
- GPU资源不足时如何调度任务?
- 如何自定义工具供给大模型调用,开发工具的关键参数、完整实现流程(Agent初级)
- Tool 如何实现动态发现?
- Tool Calling 与 Function Calling 有什么区别?
- 如何接入 HTTP、本地函数、数据库、Shell、Python、MCP 等不同类型工具?
- MCP 在 Agent 工具调用体系中解决了哪些问题?
- MCP协议的核心组成部分有哪些?
- MCP Client 和 MCP Server 如何通信?
- MCP与Function Calling有什么区别?
- MCP相比传统Plugin机制优势是什么?
- MCP如何实现工具发现(Tool Discovery)?
- MCP如何实现权限控制和安全隔离?
- MCP如何支持动态工具注册?
- MCP资源(Resources)和工具(Tools)有什么区别?
- MCP在企业内部落地会遇到哪些挑战?
- MCP如何支持多Agent协作?
- MCP工具调用过程中如何进行权限校验?
- 如何设计沙箱与外部工具调用(Tool Calling)之间的安全通信协议?
- LangChain 和 Spring AI 的核心区别是什么?
- 自研 Agent 框架如何避免重复造轮子?
- Spring AI 更适合哪些 Java 企业应用场景?
- Tool Calling与MCP协议有什么区别?
- MCP与Tool Calling如何融合?
- 工具调用过程中各类异常怎么捕获、兜底处理(Agent初级)
- 工具调用返回200,但业务逻辑错误怎么办?
- Tool 调用失败如何恢复?
- 工具调用失败后如何进行重试和回退?
- 如何设计工具调用的超时机制?
- 工具执行如何支持并发和 DAG 调度?
- 如何避免 Agent 无限循环调用工具?
- 如何实现 Tool Call 的幂等性?
- 如何设计统一的 Tool Executor?
- Agent 如何管理 API Key 和敏感凭据?
- 如何设计 Tool Call 的日志、指标和链路追踪?
- Agent如何支持灰度发布和自动回滚?
- Agent执行失败后如何恢复现场?
- 如何设计完整的Tool Audit Log?
- 如何防止多个Agent同时操作同一资源导致冲突?
- Agent如何保证工具调用的幂等性?
- 如果不用框架,Tool 调用系统怎么设计?
- 如何防止 Agent 工具循环调用?
- 如何做 Agent 执行链路追踪?
- LangChain 的 Agent Executor 有哪些局限?
- 工具调用失败时如何重试和降级?
- 工具超时如何处理?
- 如何记录Agent执行审计日志?
- Workflow Mining 如何实现?
- DAG任务编排如何实现?
- Agent工具调用系统应该怎么设计?工具如何注册、调用、鉴权、限流和追踪?
- Agent生成SQL、代码或Shell命令时如何设计沙箱,了解如何确认机制?
- Agent沙箱设计方案(附加专题)
- Tool Registry 如何设计?
- Agent 如何从数百个工具中快速选择最合适的工具?
- OAuth2、JWT、RBAC、ABAC 在 Agent 中分别适用于哪些场景?
- 如何设计企业级工具权限模型?
- 工具调用如何实现限流、配额和调用预算控制?
- 如何设计熔断、降级和备用工具切换策略?
- 如何防止第三方工具调用拖垮整个 Agent 系统?
- Tool Call 的结果如何写入 Memory 并参与后续推理?
- 如何对 Tool Calling 系统进行性能优化和压测?
- Agent如何判断一个工具是否属于高风险工具?
- 如何设计Tool的权限模型?
- RBAC与ABAC分别适用于哪些场景?
- 风险评分如何影响Agent的执行策略?
- Human-in-the-Loop应该在哪些场景下介入?
- 如何避免Agent误删代码或误删文件?
- 如何防止Prompt Injection诱导Agent执行恶意工具?
- Tool调用前、中、后分别需要做哪些安全检查?
- Agent如何实现命令沙箱隔离?
- Git Push为什么通常需要审批?
- 如何防止Agent直接向主分支提交代码?
- 如何设计统一的Policy Engine管理所有工具权限?
- Agent执行数据库DDL或DML操作应有哪些额外保护机制?
- 如何平衡Agent自动化效率与人工审批带来的成本?
- 容器隔离和虚拟机隔离(如Firecracker)在安全性和性能上的具体权衡是什么?
- 如何设计沙箱的冷启动优化方案,降低池化管理的资源浪费?
- seccomp的系统调用过滤策略具体如何配置,有哪些常见的危险syscall需要屏蔽?
- 如果Agent需要执行任意用户上传的代码,沙箱逃逸(sandbox escape)风险如何防范?
- 沙箱执行超时后如何优雅终止任务并保证资源正确回收?
- 沙箱的审计日志系统如何设计,以支持安全事件的快速定位与回溯?
- 在大规模并发场景下,沙箱集群如何做弹性伸缩与调度?
- 企业级 Agent 为什么更强调可控性?
- 如何设计高风险工具的审批机制?
- 如何保证工具调用的安全性?
- 工具调用失败如何自动恢复?
- Tool参数生成错误如何治理?
- 如何设计Agent工具调用白名单?
- 如果用户确认了高危命令,系统还要不要拦截?
- Agent生成的SQL如何做影响范围评估?
- 如何在自动化效率和人工审批安全之间做平衡?
- SQL写操作如何做到可回滚?
- Shell命令如何防止误删宿主机文件?
- 沙箱逃逸风险如何防护?
- Workflow 失败后如何恢复执行?
- Workflow 如何进行状态持久化?
- 如何判断一个 Workflow 是否值得沉淀?
- Skill如何支持参数化和动态配置?
- 如何评估Skill的效果和ROI?
- Skill调用失败后如何降级处理?
- Skill Selection 的评估指标有哪些?
- 如何避免 Skill 数量爆炸?
- 如何评估一个 Skill 的使用价值?
- Episodic Memory 如何转化为 Skill?
- 长期记忆是否可以直接生成 Skill?
- Skill执行日志如何追踪?
- Skill调用失败如何降级?
- Skill沉淀体系应该怎么设计?什么样的任务适合沉淀成Skill?
- Skill分层体系是怎么设计的?为什么要这样分层?不同层级Skill的职责边界是什么?
- 有没有Skill沉淀机制?Skill是系统自动沉淀,还是只能用户手动构造?
- Tool 与 Skill 有什么区别?
- Skill Registry 如何设计?
- 如何设计 Agent 的 Skill 沉淀机制?
- Skill与Workflow有什么区别?
- Prompt什么时候应该升级成Skill?
- 如何判断一个任务值得沉淀为Skill?
- Skill Registry应该如何设计?
- Skill元数据通常包含哪些字段?
- Agent如何检索最合适的Skill?
- 如何避免Skill数量越来越多导致维护困难?
- 如何设计Skill的版本管理机制?
- Skill如何支持灰度发布和回滚?
- 如何设计Skill之间的依赖关系?
- Skill是否支持嵌套调用(Skill调用Skill)?
- 如何设计企业级Skill市场(Skill Marketplace)?
- 如何构建可持续演进的Skill沉淀体系?
- Skill如何进行版本管理?
- Skill如何实现热更新?
- Skill 应该如何定义元数据(Metadata)?
- Skill 如何实现动态加载和热更新?
- Skill 注册中心应该如何设计?
- Skill Marketplace 应该具备哪些能力?
- 用户请求进来后如何匹配对应 Skill?
- Workflow Skill 如何实现任务编排?
- 如何设计一个企业级 Skill 沉淀体系?
- Skill 之间如何管理依赖关系?
- 如何建设组织级 Skill 资产库?
- Bug Fix Skill 如何设计?
- 自动开发 Agent 的 Skill 体系如何规划?
- 企业级 Coding Agent 如何实现 Skill 复用与共享?
- 什么样的任务适合沉淀成 Skill?
- Skill 与 Prompt Template 的区别是什么?
- Skill 与 Workflow 的关系是什么?
- Skill 是否支持嵌套调用?
- 如何从执行日志中抽取 Skill?
- 自动生成 Skill 的质量如何评估?
- Memory 和 Skill 的区别是什么?
- Skill 如何做版本管理?
- Skill 如何回滚?
- Skill 如何做灰度发布?
- Skill 如何做权限隔离?
- Skill 如何做依赖管理?
- 企业 Agent 的 Skill Store 应该如何设计?
- 多 Agent 如何共享 Skill?
- Skill 如何跨团队复用?
- Skill Marketplace 应该如何设计?
- 如何构建一个可持续进化的 Skill 沉淀体系?
- 如何根据仓库类型动态选择Skill?
- 如何构建Skill知识库?
- Skill之间如何传递上下文?
- Planner和Skill Router的边界是什么?
- 多Agent协作时如何共享Skill?
- 企业级Agent一般有多少个Skill?
- Skill注册中心如何设计?
- 如何评估一个Skill是否值得沉淀?
- 如何建立Skill运营体系?
- 如何实现Skill自动发现与推荐?
- 如何实现分层Skill架构?
- MCP和Skills有什么区别?
- 用户输入进来以后,系统如何匹配相关Skill?
- 如何自动发现可沉淀的Skill?
- Planner如何决定调用Skill还是重新规划?
- Skill如何避免能力重叠?
- Skill Router应该如何设计?
- 多个Skill都匹配时如何决策?
- Skill匹配准确率如何评估?
- Skill召回率和精确率如何平衡?
- 为什么不能直接让 Agent 调用 Tool,而要增加 Skill 层?
- Skill Router 应该基于规则还是基于 LLM?
- 多个 Skill 同时匹配时如何排序?
- 如何提高 Skill 召回率和准确率?
- Coding Agent 的核心 Skill 应该有哪些?
- Agent 如何发现高频任务?
- 经验库如何设计?
- Coding Agent如何匹配代码相关Skill?
- Code Review Skill如何设计?
- 如何根据代码上下文提升Skill匹配准确率?
- 为什么Skill匹配需要向量检索?
- 如何解决Skill语义重叠问题?
- Tool Calling与Skill Routing如何协同?
- 如何设计百万级Skill检索系统?
- 如何构建自学习的Skill推荐系统?
- 一个Skill内部应该如何调用多个Tool?
- Skill和Tool有什么区别?
- Skill 和 Tool 的本质区别是什么?
- 什么样的任务适合沉淀为 Skill?
- MCP Tool 和 Skill 的边界是什么?
- 一个复杂任务如何拆分多个Skill?
- MCP和Skill体系是什么关系?
- 工具注册中心(Tool Registry)应该如何设计?
- 为什么工具需要使用 JSON Schema 描述?
- Planner 如何决定调用一个工具还是多个工具?
- 工具参数校验应该放在哪一层完成?
- 如何利用 OpenTelemetry 构建 Agent 的可观测体系?
- Langfuse、Phoenix 等平台在 Agent 调试中的作用是什么?
- 如何设计企业级、多租户、多版本的工具管理平台?
- 如何评估 Agent 工具调用的准确率、成功率和整体执行效率?
- Risk Score应该包含哪些评估维度?
- Trace ID如何贯穿整个Agent执行链路?
- 多租户场景下如何防止侧信道攻击(side-channel attack)?
- 什么场景适合用 LangChain,什么场景适合自研 Agent 框架?
- Agent 的任务编排是用状态机、DAG 还是 Planner?
- 如何设计 Agent 的 Memory 模块?
- 如何做上下文窗口和 Token 成本控制?
- 如何保证 Agent 输出结果可靠?
- 如何评估工具调用质量?
- 如何限制代码执行的CPU、内存和网络访问?
- 如何判断一个Agent操作属于低风险、中风险还是高风险?
- Rule Routing和LLM Routing如何选择?
- DAG 编排和链式编排有什么区别?
- 如何避免错误经验被学习?
- BM25和Embedding检索如何融合?
- Rerank模型如何设计?
- OpenClaw 中 Cron、Heartbeat、Hooks 和 Task Flow 应如何选型?
- OpenClaw 如何实现多 Agent 协作?
- Agentic RAG 和普通 RAG 的区别
- Agent 工程化应该关注什么?
- Agent Tool 封装怎么讲?
- Skill、Tool、Subagent 有什么区别?
- Agent Runtime 和 Middleware 怎么讲?
- Agent 工作台和产品闭环怎么讲?
- 从 RAG 到 Agent 答复应该怎么评测?
- 生产化 RAG/Agent 要考虑什么?
- Agent 工程详细拆解
- 面试避坑回答
- 自测清单
- 最后总结