Taxonomy of agentic primitives in AWS Quick

The AWS Quick team has published the first post in a series laying out a shared taxonomy for agentic systems, written by Thomas Delteil, Adi Kalyanpur and Ron Litman. The post describes a vocabulary the team converged on after a year of building Quick, during which the product's agents moved from answering questions to taking actions such as scheduling meetings, running research and generating reports. The recurring problem, they write, was that the same handful of ideas kept being 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 — and that duplication leaked into product design and into what users were asked to choose between.
The taxonomy decomposes agentic work into four plain questions: When, What, Who and How. A trigger starts the work and carries the task, covering both When and What. An agent takes the work on, answering Who. Capabilities — tools, skills and workflows — determine How the task is carried out. Learning feeds back from the session runtime into the agent. The team says most of this stays invisible to end users by design, and that the shared vocabulary mainly helps anyone building beneath the surface.
Triggers are described as both the activation mechanism and the carrier of instructions, since a human message is simultaneously the moment work begins and the statement of what to do. The post names four kinds. Human-initiated triggers are interactive, synchronous and conversational: a person opens a conversation and asks for something. Agent-delegated triggers are programmatic and composable, and potentially recursive, with one agent mid-task invoking another to handle a sub-problem. Scheduled triggers fire on time, such as running financial research every Monday at 9am, and are deterministic, applying the same standing instructions across runs. Event-driven triggers react to an external signal — a new email, a Slack mention, a file change or a webhook.
The trigger type is said to condition how the execution behaves. A scheduled background task might stay conservative and do nothing when uncertain, whereas a human-initiated one would be expected to ask rather than stop. This is a useful design principle in practice: background work that guesses wrong costs the user trust, while interactive work that stalls wastes their time.
An agent is defined as a persistent, learning actor — the Who of any execution and the anchor against which learning accrues. Two agents given identical input can behave differently because they carry different instructions, capabilities and histories. The post is explicit that the agent is not the instructions it follows but the entity that interprets them. Three things constitute an agent. Instructions are standing guidance covering persona, role, context files and operating principles, and are the main reason a Finance Agent behaves differently from a general assistant. Capabilities are the tools, skills, workflows and sub-agents available, updated dynamically — a charting library can be added in one session and removed the next. Learned context is memory accumulated through use: which queries work for a tool, the formatting users prefer, the edge cases they care about. That memory is how the tenth execution beats the first without anyone editing the instructions.
Everything else sits outside the agent by this definition. The underlying large language model is a swappable parameter, conversation history is per-session state, and triggers belong to the platform. One consequence the team draws out: a request like wanting an agent that monitors Slack and sends a morning digest is usually a trigger added to an existing agent, not a new agent or a workflow. On this framing, chat agents, scheduled agents and so-called autonomous agents collapse into a single actor that can be conversed with, scheduled, and that can orchestrate and inspect its own past work.
Capabilities occupy a spectrum from fully agentic to fully deterministic, which the post frames as 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, such as sending an email, querying a database or reading a file. Whether the implementation is a local function, a Model Context Protocol server or another agent behind a protocol boundary, the caller sees the same interface of name, description, parameters and result. MCP is the widely used open protocol for exposing tools and data to models, so treating it as one implementation detail behind a uniform tool interface is a familiar pattern.
Skills are structured guidance with room for judgment: instructions bundled with resources such as templates, scripts and examples that describe an approach rather than a rigid sequence. They load through progressive disclosure, meaning the agent sees only names and short descriptions until a skill becomes relevant, then reads the full instructions. That lets a skill carry arbitrary depth of expertise without paying a constant context cost — an important practical detail, since context windows are finite and loading every procedure up front is expensive in both tokens and latency. Workflows are deterministic coordination: declared steps, control flow, branching and error handling executed in fixed order, with decision logic in code rather than model inference. The example given is a purchase-approval route — budget check, manager sign-off, then finance, each recorded — where the route is fixed but the judgment inside a step remains the agent's.
The post also argues that skills and workflows will not be made obsolete by better models, because each holds value independent of model capability. Skills are the unit for capturing, versioning and sharing institutional expertise; workflows deliver auditability, step-wise visibility and deterministic coordination across services. Nor are the two fixed: a well-understood skill can tighten into a workflow, which the team calls crystallization, and a workflow that keeps hitting edge cases can loosen back into a skill, called dissolution. Quick handles both through a continuous learning framework reserved for a future post. A likely trade-off is that moving between the two forms requires reliable evidence about where a task actually goes wrong, which is exactly what the learned context is meant to supply.
Returning to the Slack digest example, the team shows the same request can be satisfied three valid ways: a scheduled task with a one-line instruction leaving the agent to work out the rest; the same task backed by a skill with explicit formatting rules and channel priorities; or one 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, someone burned by inconsistency the second, and someone running a compliance-sensitive process the third. Learning shifts that trajectory over time, so a task that starts as a single sentence accumulates domain-bound knowledge and the tenth run is markedly better with nobody encoding it by hand. The recommended design is the simplest option that meets the user's confidence requirement, with a path to graduate through autonomous learning as needs grow.
The conclusion is that four plain questions are enough to place any piece of agentic work, from a one-line chat request to a scheduled, compliance-grade process, and that a shared vocabulary lets builders reason about the system while the product hides the complexity. Upcoming posts in the series will cover the agentic operating system built on these primitives, background learning and proactive feeds.
Why it matters: Teams building agent products now have a concrete vocabulary for separating what starts work, who performs it and how constrained the execution should be, which is a useful checklist when scoping features and deciding where determinism belongs. The distinction between an agent's durable learned context and swappable elements like the model and session history suggests a design pattern in which memory, not prompt engineering, is the thing to invest in and preserve across model upgrades. For product managers, the confidence-contract idea reframes a UX question — how much autonomy to expose — as a per-task decision rather than a global setting, though the post offers no measured results to show the framework improves outcomes.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
As we built Amazon Quick, its agents grew from answering questions to taking actions, and the same primitives kept getting rebuilt under different names. This post shares the taxonomy we converged on — triggers, agents, capabilities, and learned context — found by decomposing agentic work into four plain questions: When, What, Who, and How.