---
type: "post"
id: "taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7"
slug: "taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7"
title: "Taxonomy of agentic primitives in Amazon Quick"
description: "AWS describes Amazon Quick through four questions—when work starts, what it must do, who does it, and how it is done—and maps them to triggers, agents, and capabilities."
retrieval_nugget: "AWS describes Amazon Quick through four questions—when work starts, what it must do, who does it, and how it is done—and maps them to triggers, agents, and capabilities. The taxonomy offers builders a vocabulary for choosing between flexible guidance and deterministic execution, though AWS presents it as a design framework rather than a new product capability."
published_at: "2026-11-07"
updated_at: "2026-11-07"
record_date: "2026-11-07"
date_kind: "published_at"
topics: ["agents","enterprise-agents","agent-workflows"]
entities: ["Amazon Quick","Amazon Web Services","Model Context Protocol"]
related_patterns: ["agent-ready-software-exposes-capabilities"]
novelty_label: "new_fact"
what_changed: "The story introduces a taxonomy of agentic primitives in Amazon Quick, adding a conceptual framework beyond prior Quick approvals and deployment coverage."
prior_refs: []
source_url: "https://aws.amazon.com/blogs/machine-learning/taxonomy-of-agentic-primitives-in-amazon-quick"
source_urls: ["https://aws.amazon.com/blogs/machine-learning/taxonomy-of-agentic-primitives-in-amazon-quick"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7/","markdown":"https://newruntime.com/posts/taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7.md","json":"https://newruntime.com/posts/taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7.json"}
markdown_url: "https://newruntime.com/posts/taxonomy-of-agentic-primitives-in-amazon-quick-c14bf7.md"
---

# Taxonomy of agentic primitives in Amazon Quick

## Retrieval answer

AWS describes Amazon Quick through four questions—when work starts, what it must do, who does it, and how it is done—and maps them to triggers, agents, and capabilities. The taxonomy offers builders a vocabulary for choosing between flexible guidance and deterministic execution, though AWS presents it as a design framework rather than a new product capability.

## Summary
AWS describes Amazon Quick through four questions—when work starts, what it must do, who does it, and how it is done—and maps them to triggers, agents, and capabilities. The taxonomy offers builders a vocabulary for choosing between flexible guidance and deterministic execution, though AWS presents it as a design framework rather than a new product capability.

## What happened
AWS says its agents in Amazon Quick grew from answering questions to taking actions such as scheduling meetings, conducting research, and generating reports. As the system evolved, the same underlying ideas were rebuilt under different names, creating confusion in product design and for users. AWS's post proposes a shared taxonomy based on four questions: When, What, Who, and How.

A trigger handles both when work begins and what the task is. AWS lists four kinds: a human opening a conversation, one agent delegating a subproblem to another, a scheduled task such as weekly financial research, and an external event such as a new email, Slack mention, file change, or webhook. The kind of trigger can affect execution: a scheduled background task might do nothing when uncertain, while an interactive agent might ask a question instead.

AWS defines an agent as a persistent, learning actor. It consists of standing instructions, capabilities that can be updated dynamically, and learned context such as effective queries, user formatting preferences, and edge cases. AWS treats the underlying language model as a replaceable parameter; conversation history is session state, and triggers belong to the platform. Under this framing, a request to monitor Slack and send a morning digest can be a trigger added to an existing agent, rather than a reason to create a separate agent or workflow.

Capabilities include tools, skills, and workflows. Tools are atomic operations with typed schemas, such as sending email, querying a database, or reading a file; AWS says the caller sees a consistent interface whether a tool is a local function, an MCP server, or another agent behind a protocol boundary. Skills package instructions and resources such as templates or scripts, allowing judgment rather than prescribing a rigid sequence. They use progressive disclosure: the agent first sees names and short descriptions, then loads full instructions when relevant. Workflows instead encode declared steps, branches, and error handling in a fixed order, with decision logic in code.

AWS calls the distinction between skills and workflows a confidence contract: how much latitude the agent retains versus how much the user fixes in advance. The same scheduled digest could use a one-line instruction, a skill with formatting and channel priorities, or a deterministic workflow. AWS says skills and workflows retain value even as models improve: skills capture and share institutional expertise, while workflows provide auditability and predictable coordination. In Quick, the company says a well-understood skill can become a workflow, while a workflow encountering repeated edge cases can loosen into a skill. AWS says this is part of its continuous learning framework, which it plans to describe in a later post.

## What the archive adds
New Runtime's earlier coverage includes [Amazon Quick's launch in the AWS Asia Pacific (Singapore) Region](https://newruntime.com/posts/amazon-quick-launches-in-the-aws-asia-pacific-c226a2/) on 2026-10-30. That was an availability update; this is a new conceptual account of how AWS organizes agent work in Quick, not a restatement of the launch.

## Trend signal
This supports [agent-ready software exposes capabilities](https://newruntime.com/patterns/agent-ready-software-exposes-capabilities/): AWS distinguishes tools, skills, and workflows as composable ways for an agent to act, with tools exposed through typed interfaces. The post is a taxonomy, however, not evidence that these interfaces are broadly available to external agents or standardized across products.

## Why now
AWS says the taxonomy emerged as Amazon Quick's agents moved from answering questions to taking actions, and as repeated primitives created confusion for builders and users. The post is also the first in a planned series: AWS says later installments will cover its agentic operating system, background learning, and proactive feeds.

## Why it matters
Teams often start with a prompt and then add tools, schedules, and control flow until the system becomes difficult to reason about. AWS's distinctions help make an important design choice explicit: leave ordering and judgment to the agent when flexibility is acceptable, or encode the sequence in a workflow when predictability and auditability matter. Skills occupy a middle ground, preserving reusable expertise without hard-coding every step.

The taxonomy also offers a practical way to avoid unnecessary agent proliferation. A scheduled task may be a trigger for an existing agent rather than a new agent with its own identity. That separation can make ownership and changes easier to manage. Still, the framework comes from AWS's own product experience; teams should test whether its categories clarify their architecture rather than adopting the vocabulary as a universal standard.

## Limits and uncertainty
AWS presents a product-design framework, not measured evidence that this taxonomy improves task success, reliability, or cost. The post gives no quantitative results for learned context, the transition between skills and workflows, or how the system decides when to make that transition. It also does not detail the implementation, governance, or portability of learned context. The distinctions are useful as design guidance, but their performance and applicability outside Amazon Quick remain unverified here.

## Skill to build now
Take one recurring agent task and write down its trigger, standing instructions, available capabilities, and information that should persist between runs. Then identify which steps need fixed ordering or explicit error handling and which can safely leave room for agent judgment. This exercise turns the taxonomy into a concrete architecture review without assuming that every task needs a new agent or a full workflow.

## Reader takeaway
Treat the trigger, the actor, and the method of execution as separate design decisions. Use tools for atomic actions, skills for reusable guidance with judgment, and workflows when the sequence must be deterministic; choose the least rigid design that meets the task's confidence requirement.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Agents](https://newruntime.com/topics/agents.md): Explore the agents topic hub.
- topic hub: [Enterprise Agents](https://newruntime.com/topics/enterprise-agents.md): Explore the enterprise-agents topic hub.
- topic hub: [Agent Workflows](https://newruntime.com/topics/agent-workflows.md): Explore the agent-workflows topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)