Amazon Quick 智能体原语分类体系

过去一年,在构建 Amazon Quick 的过程中,我们的智能体从回答问题转向执行动作:安排会议、开展研究、生成报告。随着系统不断演进,有一个问题反复浮现:对于构成智能体式工作的那些原语,始终没有统一的定义。同样的少数几个概念不断以不同的名称被重复构建:执行工作的执行者、启动工作的信号、打包好的流程,以及把经验传承下去的記憶。这种重复渗透进了产品设计,也传导到了用户身上。
以一位用户说“监控我的 Slack 频道,每天给我发一份摘要”为例。这是一个新的智能体,是发给现有智能体的定时指令,是一个工作流,还是一项技能?这些是不同的问题,但如果没有共享的词汇,它们就会坍缩成一个令人困惑的选择。
本文分享我们最终收敛出的分类体系:通过把智能体式工作拆解为四个朴素的问题——何时?做什么?谁来做?如何做?——得到的一组原语。按照设计,这套框架的大部分对最终用户是不可见的,但对于在其之上构建系统的人来说,共享的词汇能让整个系统更容易被理解和推演。
图 1:触发器、智能体与能力之间的关系,学习结果从会话运行时反馈回来
触发器启动工作并承载任务(何时与做什么),智能体承接任务(谁来做),并使用其能力(工具、技能和工作流)来执行任务(如何做)。本文介绍这些原语以及它们之间的相互关系。这是系列文章的第一篇,后续文章将涵盖我们的智能体式操作系统、后台学习、主动推送的信息流等内容。
触发器是让工作得以完成的激活机制,但它们同时也承载指令:一条人类消息既是激活的时刻,也是对要做什么的描述。它们同时是一个任务的「何时做?」和「做什么?」。
触发器的类型会影响执行方式:一个定时的后台任务可能保持保守(例如,不确定时就什么都不做),而由人类发起的任务则会更具响应性(例如,宁可询问而不是停止)。
我们将智能体定义为一个持续存在、能够学习的行为主体。它是任何一次执行中的「谁?」,也是学习得以累积所依托的锚点。两个被赋予相同输入的智能体可能表现不同,因为它们携带不同的指令、能力和历史。智能体并不是它所遵循的指令,而是解释这些指令的实体。它由三部分组成:
其他一切都是外在的:智能体底层的大语言模型(LLM)是一个可替换的模型参数,对话历史是按会话存在的状态,而触发器属于平台。
这一定义带来的一个结果是,用户提出「我想要一个监控我的 Slack 并每天早上发送摘要的智能体」这类请求时,通常只是给已有的智能体添加了一个触发器,而不是新建一个智能体或工作流。按照这种框架,我们可以把聊天型、定时型和「自主型」智能体合并为一个行为主体——你可以与它对话、为它安排日程,它也能编排并检视自己过去的工作。
能力是智能体行动的方式,涵盖从完全智能体式到完全确定性的一个谱系。这条轴实际上是一份置信度契约:智能体保留多少自主空间,相对于用户预先固定多少。
工具是带有类型化 schema 的原子操作:发送邮件、查询数据库、读取文件。无论它是本地函数、Model Context Protocol(MCP)服务器,还是位于协议边界之后的另一个智能体,调用方看到的都是同一套接口:名称、描述、参数、结果。
技能是留有判断空间的结构化指导:与资源(模板、脚本、示例)打包在一起的指令,描述的是处理思路,而不是固定的执行顺序。它们通过渐进式披露加载,因此智能体只会看到名称和简短描述,直到某个技能变得相关,才去读取完整指令。这样一来,一个技能就能打包任意深度的专业知识,而不必付出持续的成本。
工作流是确定性的协调:以固定顺序执行的声明式步骤、控制流、分支与错误处理,决策逻辑写在代码中,而不是由模型推理完成。可以想出一条采购审批路径:预算检查、经理签批,再到财务,每一步都有记录。路径是固定的,但每一步之内的判断仍然由智能体做出。
图 2:技能与工作流的对比,二者的区别在于由智能体还是由代码来决定步骤顺序
一个自然而然的问题是:如果模型持续进步,技能和工作流会不会变得没有必要?我们不这么认为,因为两者的价值都与模型能力无关。技能是捕获、版本化并共享组织专业知识的单元,而工作流提供可审计性、逐步可见性以及确定性的多服务协调能力。两者也并非一成不变:一个已被充分理解的技能可以收紧为工作流(结晶化),一个不断撞上边界情况的工作流也可以放松回技能(消解)。在 Quick 中,这一过程通过我们的持续学习框架实现,我们将在未来的文章中加以介绍。
回到“监控我的 Slack 频道并每天给我发一份摘要”这个例子。由于这些原语可以组合,同一个请求可以用几种同样有效的方式来满足:
三者都会按计划生成每日摘要。区别在于置信契约。信任智能体的用户想要第一种,被不一致性坑过的用户想要第二种,而运行合规敏感流程的用户想要第三种。
学习会随时间推移改变这条轨迹。一个最初只是一句话的任务(“检查我的邮件里有没有紧急事项”)会逐步积累与领域绑定的学习成果:有效的查询、偏好的格式,以及哪些发件人重要。第十次运行会明显更好,而这一切无需任何人手工编码。正确的设计是:在满足用户置信度要求的前提下采用最简方案,并在用户需要更多时,提供一条经由自主学习逐步升级的路径。
这套智能体原语分类体系的价值在于:四个朴素的问题——何时(When)、做什么(What)、由谁(Who)、怎么做(How)——就足以定位任何一项智能体工作,从一行聊天请求到按计划执行、符合合规要求的流程。共用同一套词汇,既让构建者能够对系统进行推理,也让产品得以把复杂性隐藏起来。最妙的是,用户完全无需学习其中任何内容。他们只需说出自己想要什么,系统便会组装出合适的原语来完成他们的任务。
本系列的下一篇:构建在这些原语之上、为 Amazon Quick 提供支撑的智能体操作系统。
托马斯(Thomas)是 Amazon Quick 团队的高级首席技术专家,也是 Amazon Quick Desktop 背后创始团队的成员之一。他的工作聚焦于协同为人们完成实际工作的智能体系统。工作之外,你可能会在独木舟上看到他,探索太平洋西北地区最美好的一切。
阿迪(Adi)是 Amazon Quick 团队的首席科学家,也是 Quick Research 和 Quick Desktop 的创始成员。他的专业领域涵盖面向企业的智能体式 AI 系统、神经符号推理,以及能够从经验中持续学习的自我改进智能体。工作之外,阿迪热爱运动、历史和旅行。
罗恩(Ron)是 AWS 的科学经理,负责管理 Amazon Quick 在桌面端、网页端、移动端和扩展插件等所有界面上的核心体验。他的职业兴趣包括智能体式 AI 系统、应用推理,以及打造能够无缝融入日常工作流的智能助手。工作之外,罗恩正在探索抱石和攀岩的世界。
译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。
查看英文原文(Taxonomy of agentic primitives in Amazon Quick)
Over the past year, as we built Amazon Quick, our agents went from answering questions to taking actions: scheduling meetings, running research, generating reports. As the system evolved, one problem kept resurfacing: there was no shared definition of the primitives that agentic work is built from. The same few ideas kept getting rebuilt under different names: an actor that does the work, a signal that starts it, a packaged procedure, and a memory that carries lessons forward. This repetition leaked into product design and onto the user.
Take the user who says “monitor my Slack channel and send me a daily digest”. Is that a new agent, a scheduled instruction to an existing one, a workflow, or a skill? These are different questions, but without a shared vocabulary they collapse into one confusing choice.
This post shares the taxonomy we converged on: one set of primitives found by decomposing agentic work into four plain questions: When?, What?, Who?, and How? Most of the framework stays invisible to end users by design, but a shared vocabulary makes the system easier to reason about for anyone building beneath it.
The framework at a glance
Figure 1: How triggers, agents, and capabilities relate, with learning feeding back from the session runtime
A trigger starts the work and carries the task (When and What), an agent takes it on (Who) and uses its capabilities (tools, skills, and workflows) to perform the task (How). This post describes these primitives and how they relate to one another. It’s the first post in a series, and upcoming posts cover our agentic operating system, background learning, proactive feeds, and much more.
Triggers: What causes work to begin
Triggers are the activation mechanism for getting work done, but they also carry instructions: a human message is both the moment of activation and the description of what to do. They are both the When? and the What? of a task.
- Human-initiated: A person opens a conversation and asks the agent to do something. Interactive, synchronous, conversational.
- Agent-delegated: One agent, mid-task, invokes another to handle a sub-problem. Programmatic, composable, potentially recursive.
- Scheduled: Time-based activation, like “run financial research every Monday at 9am.” Deterministic, with the same standing instructions applied across runs.
- Event-driven: A signal from an external system, such as a new email, a Slack mention, a file change, or a webhook.
The type of trigger conditions the execution: a scheduled background task might stay conservative (for example, do nothing if uncertain), while a human-initiated one would be responsive (for example, ask rather than stop).
Agents
We define an agent as a persistent, learning actor. It’s the Who? in any execution, and the anchor against which learning accrues. Two agents given identical input can differ, because they carry different instructions, capabilities, and histories. The agent isn’t the instructions it follows. It’s the entity that interprets them. It consists of three things:
- Instructions: Standing guidance defining persona, role, context files, and operating principles. A Finance Agent behaves differently from a general assistant primarily because of this.
- Capabilities: The tools, skills, workflows, and sub-agents available for use, updated dynamically. A charting library can be added in one session and removed the next.
- Learned context: Memory that accumulates through use: the queries that work for a tool, the formatting users prefer, the edge cases they care about. This is how the tenth execution beats the first without anyone changing the instructions.
Everything else is extrinsic: the large language model (LLM) underlying the agent is a swappable model parameter, conversation history is per-session state, and triggers belong to the platform.
A consequence of this definition is that a user request “I want an agent that monitors my Slack and sends a digest every morning” is usually a trigger added to an existing agent, not a new agent or workflow. With this framing, we can merge chat, scheduled, and “autonomous” agents into one actor that you can converse with, schedule, and that can orchestrate and inspect its own past work.
Capabilities
Capabilities are How an agent acts, spanning a spectrum from fully agentic to fully deterministic. That axis is really a confidence contract: how much latitude the agent keeps versus how much the user fixes in advance.
Tools are atomic operations with a typed schema: send an email, query a database, read a file. Whether a local function, a Model Context Protocol (MCP) server, or another agent behind a protocol boundary, the caller sees the same interface: name, description, parameters, result.
Skills are structured guidance with room for judgment: instructions bundled with resources (templates, scripts, examples) that describe an approach rather than a rigid sequence. They load through progressive disclosure, so the agent sees only names and short descriptions until one becomes relevant, then reads the full instructions in. A skill can therefore bundle arbitrary depth of expertise without a constant cost.
Workflows are deterministic coordination: declared steps, control flow, branching, and error handling that execute in fixed order, with decision logic in code rather than model inference. Think of a purchase-approval route: budget check, manager sign-off, then finance, each recorded. The route is fixed, but the judgment inside a step is still the agent’s.
Figure 2: Skills versus workflows, which differ in whether the agent or the code decides the step order
Why skills and workflows outlast model improvements
A natural question arises: if models keep improving, won’t skills and workflows become unnecessary? We don’t think so, because each holds value independent of model capability. Skills are the unit for capturing, versioning, and sharing institutional expertise, while workflows deliver auditability, step-wise visibility, and deterministic multi-service coordination. Nor are they fixed: a well-understood skill can tighten into a workflow (crystallization), a workflow that keeps hitting edge cases can loosen back into a skill (dissolution). This is done in Quick through our continuous learning framework, which we will describe in a future post.
What this means in practice
Return to “monitor my Slack channel and send me a daily digest”. Because these primitives compose, the same request can be met several valid ways:
- A scheduled task with a one-line instruction, leaving the agent to figure out the rest.
- The same task backed by a skill with explicit formatting rules and channel priorities.
- The same task invoking a workflow with deterministic steps and error handling.
All three produce a daily digest on a schedule. What differs is the confidence contract. A user who trusts the agent wants the first, one burned by inconsistency the second, one running a compliance-sensitive process the third.
Learning shifts that trajectory over time. A task that starts as one sentence (“check my email for urgent items”) accumulates domain-bound learnings: effective queries, preferred formatting, and which senders matter. The tenth run is markedly better, with no one encoding that by hand. The right design is the simplest option that meets the user’s confidence requirement, with a path to graduate through autonomous learning when they need more.
Conclusion
The value of this agentic primitive taxonomy is that four plain questions, When, What, Who, and How, are enough to place any piece of agentic work, from a one-line chat request to a scheduled, compliance-grade process. Sharing one vocabulary lets builders reason about the system and lets the product hide complexity. Best of all, the user never has to learn any of it. They say what they want, and the system assembles the appropriate primitives to do their job.
Next in the series: the agentic operating system that builds on these primitives and powers Amazon Quick.
Keep exploring
- Ready to try? Start with the Amazon Quick getting-started guide.
About the authors
Thomas Delteil
Thomas is a Senior Principal Technologist on the Amazon Quick team and one of the members of the founding team behind Amazon Quick Desktop. His work centers on agentic systems that coordinate to do real work for people. Outside of work, you might find him in a canoe, exploring the best of what the Pacific Northwest has to offer.
Adi Kalyanpur
Adi is a Principal Scientist on the Amazon Quick team and a founding member of Quick Research and Quick Desktop. His expertise spans agentic AI systems for the enterprise, neuro-symbolic reasoning, and self-improving agents that learn continually from experience. Outside of work, Adi loves sports, history, and travel.
Ron Litman
Ron is a Science Manager at AWS, where he manages the core Amazon Quick experience across all surfaces — desktop, web, mobile, and extensions. His professional interests include agentic AI systems, applied reasoning, and building intelligent assistants that integrate seamlessly into daily workflows. Outside of work, Ron is exploring the world of bouldering and climbing.
正文保留英文原文,标题与摘要由机器翻译。
原文发布于 AWS Machine Learning(Taxonomy of agentic primitives in Amazon Quick),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。