Choose the right agent workload
Builders deciding which agent architecture fits their use case before writing code. If you already know your workload type, jump straight to its overview: Conversational, Workflow, or Coding. If you haven't deployed anything on AgentCore yet, start with Get Started first.
The Conversational, Workflow, and Coding categories on this site are reference patterns created to organize architecture guidance. They are not AgentCore product types, named tiers, or mandatory configurations. AgentCore capabilities (Runtime, Memory, Gateway, Identity, Guardrails, Evaluations, Observability) are modular — you combine them based on your use case. These categories help you reason about which combination typically fits a given problem.
AgentCore supports many agent archetypes including the following three. Each is optimized for a different interaction model, trigger pattern, and operational profile. Pick the one that matches your use case, then follow its Quick Start to deploy in minutes.
Workload Types at a Glance
Conversational Agents
Human-initiated chat agents with memory, identity, and real-time streaming. Customer support, internal assistants, and co-pilots.
Workflow Agents
Event-driven automation agents that reason, act, and adapt. Claims processing, incident response, and document routing.
Coding Agents
Long-running code generation, review, and migration agents. Feature implementation from tickets, automated PR review, and refactoring.
When to Use Each Workload
| Use Case | Why This Fits |
|---|---|
| Conversational | |
| Customer support / helpdesk agent | Human-initiated, multi-turn, needs memory of prior exchanges |
| Internal knowledge assistant (HR, IT, etc.) | Q&A with employees, auth-scoped answers per user |
| Sales co-pilot / deal desk assistant | Real-time advice during live user interactions |
| NL-to-SQL / self-serve analytics | User asks a question, agent queries data and responds |
| Workflow | |
| Claims processing / adjudication | Event-triggered, rules-based, needs bounded autonomy |
| IT incident response / auto-remediation | Alert fires, agent triages and acts without a human |
| Document intake and routing | Document uploaded → classify → route → notify |
| Compliance monitoring / drift detection | Scheduled scan → detect → remediate or escalate |
| Order fulfillment exception handling | System event (stuck order) triggers investigation |
| Email / ticket triage and auto-response | Inbound message → classify → auto-reply or route |
| Coding | |
| Feature implementation from Jira tickets | Ticket created → agent generates code → PR for review |
| Automated code review / security scanning | PR opened → agent reviews → comments inline |
| Codebase migration / refactoring | Batch task: transform patterns across many files |
| Test generation from specifications | Spec updated → agent writes/updates test suites |
| Documentation generation from code | Code merged → agent generates/updates docs |
Decision Criteria at a Glance
Use this table to map your requirements to a reference category. Multiple "best fit" matches in a row point to the same workload.
| Criterion | Conversational | Workflow | Coding |
|---|---|---|---|
| Trigger source | Human typing a message | System event (alert, webhook, schedule, queue) | Ticket, PR, CI event, or schedule |
| Human interaction | Continuous, real-time back-and-forth | Minimal during execution; human-in-the-loop (HITL) for approvals on high-risk actions | Review gate at the end (PR/approval) |
| Action risk | Low-to-medium (user-scoped actions) | Medium-to-high (autonomous system actions) | Medium (code change, auto-merged PR) |
| Duration | Minutes to hours across many turns | Seconds to minutes per invocation | Minutes to hours per task |
| Identity model | End-user identity (OAuth bearer token) | Service identity (machine-to-machine) | Developer identity (repo/CI access) |
| State / memory | Session + long-term per user | Per-entity cross-invocation context | Project-scoped codebase context |
| Latency requirement | Low (streaming token-by-token to UI) | Tolerant (results to downstream systems) | Tolerant (background task) |
| Integration pattern | Frontend / chat UI, IdP, streaming API | EventBridge, SNS, SQS, S3, webhooks | GitHub/GitLab, Jira, CI/CD pipelines |
How They Compare
| Dimension | Conversational | Workflow | Coding |
|---|---|---|---|
| Trigger | User message (human-initiated) | System event (machine-initiated) | Ticket/PR/schedule (machine-initiated) |
| Session duration | Minutes to hours (multi-turn) | Seconds to minutes (single invocation) | Minutes to hours (long-running task) |
| Identity model | End-user OAuth bearer tokens (acts as user) | Service identity (acts as system) | Developer identity (acts as developer) |
| Memory | Session + long-term per user | Cross-invocation context per entity | Project-scoped context |
| Streaming | Token-by-token to UI | Optional (results go to downstream systems) | Optional (progress updates to IDE/CI) |
| Primary output | Natural language response to human | Actions taken + structured events emitted | Code artifacts + PR/review comments |
| Scaling pattern | Concurrent sessions (many users) | Event throughput (many events per second) | Concurrent tasks (many repos/PRs) |
| Key metrics ² | Builtin.Helpfulness, Builtin.Correctness | Builtin.GoalSuccessRate, trajectory match evaluators | Code quality, test pass rate (no code-specific built-in evaluator) |
| Idle cost ³ | Scale-to-zero between sessions | Scale-to-zero between events | Scale-to-zero between tasks |
| Compute lifecycle | Up to 8 hours (session affinity) ¹ | Short-lived by design; sessions stop at the default 15-minute idle timeout ¹ | Up to 8 hours (long-running) ¹ |
| Guardrails focus | Content filters, PII, prompt injection | Tool-level policies (Cedar), bounded autonomy | Code quality gates, security scanning |
¹ Session duration and scaling behaviors are architecture guidance based on typical AgentCore usage patterns, not per-workload limits — the maximum compute lifetime is the same for every runtime. Verify current limits in the AgentCore service quotas.
²
Builtin.*names are AgentCore Evaluations built-in evaluators. Trajectory matching is a family:Builtin.TrajectoryInOrderMatch,Builtin.TrajectoryAnyOrderMatch, andBuiltin.TrajectoryExactOrderMatch.³ Runtime uses active-resource consumption pricing; idle agents scale to zero after their sessions stop.
Decision Guide
Choose Conversational when:
- A human is typing messages and expecting real-time responses
- You need multi-turn memory and session continuity
- The agent acts on behalf of the end-user (their identity, their permissions)
Choose Workflow when:
- A system event triggers the agent (alert, webhook, schedule, file upload)
- The agent needs to make decisions and take actions autonomously
- You need bounded autonomy: the agent should act within defined guardrails, not freely
Choose Coding when:
- The output is code, tests, documentation, or PR comments
- Tasks are long-running and involve file system or repository operations
- You need sandbox isolation for code execution and validation
Getting Started Resources
Once you've chosen your workload type, jump to the quickstart that fits:
| Path | What you get | Link |
|---|---|---|
| CLI quickstart | Scaffold any agent project with agentcore create, iterate locally with hot-reload, deploy with one command | Build from CLI |
| Managed harness | Configure rather than code: AgentCore manages the agent loop, memory, and system prompt | First Agent (Harness) |
| Conversational quickstart | Sample-driven path for chat agents with identity, memory, and streaming | Conversational Quick Start |
| Workflow quickstart | Event-driven agent with bounded autonomy and tool gates | Workflow Quick Start |
| Coding quickstart | Long-running code agent with sandbox execution | Coding Quick Start |
For CLI reference and the full set of agentcore create options, see the AgentCore CLI project creation guide.
Next Steps
Conversational Overview →
Deep dive into chat agent architecture, use cases, and platform configuration.
Workflow Overview →
Event-driven patterns, bounded autonomy, and the 5-step execution model.
Coding Overview →
Long-running code agents with sandbox execution and review gates.
Any agent created with the commands on this page is a prototype until you have applied the controls in Preparing for production. Do not use a prototype endpoint to serve real user traffic.