Amazon Quick has introduced a formal taxonomy that breaks every agentic workflow into four distinct primitives: triggers, agents, capabilities, and learned context. For engineers building, operating, or securing these workflows, the change provides a concrete vocabulary that separates activation, responsibility, execution method, and memory, making system design and troubleshooting more systematic.
Four Core Primitives
The taxonomy maps each step of a task to a specific question:
- Trigger (When / What) – The activation point that also carries the instruction. Types include human‑initiated messages, agent‑delegated calls, scheduled timers, and event‑driven signals such as Slack mentions or webhooks.
- Agent (Who) – A persistent, learning entity that interprets triggers. An agent bundles three components: static
instructions(persona, role, operating principles), dynamiccapabilities(tools, skills, workflows), andlearned context(memory of past interactions, formatting preferences, edge‑case handling). - Capability (How) – The concrete means an agent uses to act. Capabilities sit on a confidence contract axis ranging from fully deterministic tools (e.g., send‑email API) to higher‑level skills that allow judgment (e.g., generate a report). All capabilities expose a uniform interface: name, description, typed parameters, and result.
- Learned Context – The session‑level memory that accumulates across executions, enabling later runs to improve without changing instructions.
By treating a request like “monitor my Slack channel and send a daily digest” as a new trigger attached to an existing agent, the model avoids proliferating redundant agents or workflows.
Architectural Impact
Adopting the primitives forces a clean separation of concerns:
- Triggers become the only entry point for external events, allowing a single routing layer to handle human, scheduled, and event‑driven inputs.
- Agents act as the stateful core; their instructions can be versioned independently of the capabilities they invoke.
- Capabilities are interchangeable modules with a stable contract, making it straightforward to add, replace, or remove tools without touching the agent or trigger logic.
- Learned context is isolated to the agent’s runtime, enabling targeted persistence strategies (e.g., per‑agent storage) and simplifying rollback or replay scenarios.
This decomposition aligns with micro‑service principles and supports incremental rollout: you can introduce a new capability behind an existing agent without redeploying the trigger infrastructure.
Operational and Security Implications
From an operations perspective, the taxonomy clarifies monitoring and alerting boundaries. Trigger logs capture when and why work started, while agent logs record interpretation and capability usage. Separate logs make it easier to trace failures back to the originating primitive.
Security reviews benefit from the same clarity. Because capabilities expose a defined interface, auditors can enumerate exactly which external actions an agent may perform. The distinction between a trigger (often external) and an agent (internal, persistent) helps isolate untrusted inputs and reduces the attack surface of the runtime. Learned context, being agent‑specific, can be scoped with appropriate storage permissions, limiting inadvertent data leakage across agents.
Related CloudNinjas coverage: AWS.
What This Means For Practitioners
- Map existing Quick workflows to the four primitives to expose hidden coupling and simplify refactoring.
- Design trigger handling as a thin, stateless service that forwards to the appropriate agent, enabling uniform authentication and rate‑limiting.
- Version agent
instructionsseparately from capability contracts to allow safe capability upgrades. - Implement per‑agent storage for learned context and enforce least‑privilege access controls on that storage.
- Instrument separate logs for triggers, agents, and capabilities to improve observability and incident response.