Most AI agents still wait for someone to start a conversation.
A developer opens a chat window, writes a prompt, and the agent begins working:
User
|
v
Prompt
|
v
AI Agent
|
v
Action
|
v
ResponseThat model works well for interactive applications.
But many enterprise problems do not start with a user prompt.
A document arrives in Amazon S3. A monitoring alert fires. A scheduled report becomes due. A database change occurs. A support ticket is created.
In those situations, the system already knows that something happened.
The developer should not have to tell an AI agent:
"A new document has arrived. Please process it."That is where the idea of an ambient agent becomes useful.
Amazon Bedrock AgentCore can be used to build event-driven agents that react to signals such as S3 uploads, scheduled jobs, monitoring events, and other application events. AWS describes the ambient-agent pattern as:
Event
|
v
Signal
|
v
Agent
|
+---- Human approval, if required
|
v
ActionInstead of waiting for a chat prompt, the event itself starts the workflow.
What Is an Ambient Agent?
An ambient agent is an AI agent that operates in response to events rather than waiting for a user to explicitly start a conversation.
A traditional agent looks like:
User
|
v
"Analyze this file"
|
v
Agent
|
v
ResultAn ambient agent looks like:
File Uploaded
|
v
Event
|
v
Agent
|
v
Analyze File
|
v
ResultThe difference is the trigger.
AWS's current AgentCore guidance describes ambient agents as a pattern where an event creates a job for an agent. Depending on configuration, that job can wait for human review or execute automatically.
This makes the pattern useful for workloads where the environment already produces meaningful signals.
Why Do We Need Ambient Agents?
Consider a document-processing team.
Every day, hundreds of files arrive in an S3 bucket.
The traditional process might be:
File Uploaded
|
v
Notification
|
v
Employee Notices File
|
v
Opens File
|
v
Reads File
|
v
Classifies File
|
v
Routes FileAn agent can automate much of this:
File Uploaded
|
v
Event
|
v
Ambient Agent
|
+-- Read document
+-- Classify
+-- Extract information
+-- Check rules
|
v
Human Approval
|
v
Next ActionThe agent becomes part of the system instead of another application that users have to remember to open.
Event-Driven Agent Architecture
A practical architecture can contain several AWS services.
Amazon S3
|
| Object Created
v
Event Processing
|
v
Amazon SQS
|
v
Agent Job / Signal
|
v
Amazon Bedrock AgentCore
|
+-------+-------+
| |
v v
AI Model Tools
| |
+-------+-------+
|
v
Agent Decision
|
+-------+-------+
| |
v v
Human Review ActionAWS's current reference pattern uses AgentCore Runtime together with services such as Lambda, SQS, and DynamoDB to support event-driven execution, state management, and human-in-the-loop workflows.
The exact architecture can be simpler or more complex depending on the workload.
The Event Becomes the Prompt
This is one of the most important ideas behind ambient agents.
In a chat application, the prompt might be:
Analyze this invoice and determine whether
it should be approved.In an ambient system, the event itself provides the initial context:
{
"eventType": "ObjectCreated",
"bucket": "incoming-documents",
"key": "invoices/invoice-10482.pdf"
}The event processor can turn this into an agent job.
Conceptually:
S3 Event
|
v
Signal
|
v
"Analyze invoice-10482.pdf"
|
v
AgentThe developer does not need to create a new chat request for every file.
What Is an Ambient Signal?
AWS's reference implementation introduces an ambient signal as the configuration that maps an event source to an agent.
When an event occurs, the signal processor can create a job for the configured agent.
A simplified representation is:
Signal
--------------------------------
Event Source
Agent
Execution Mode
Metadata
--------------------------------For example:
Event Source:
S3 object-created event
Agent:
InvoiceAnalyzer
Execution:
Human review requiredOr:
Event Source:
Scheduled event
Agent:
DailyOperationsAgent
Execution:
AutomaticThis gives the event source a defined destination.
Human Approval Can Be Part of the Workflow
One of the strongest aspects of the ambient-agent pattern is that the agent does not have to run completely autonomously.
AWS's reference implementation uses a human-in-the-loop approach where an agent can pause and request human input through an ask_human tool.
The workflow becomes:
Event
|
v
Agent
|
v
Analyze
|
v
Needs Approval?
|
+---- No ----> Continue
|
Yes
|
v
Ask Human
|
v
Human Response
|
v
Resume AgentThis is important for enterprise workflows.
For example, an invoice-processing agent could automatically extract:
Vendor
Invoice Number
Amount
Date
Purchase OrderBut before approving a high-value payment, the agent can stop:
"Invoice amount is $85,000.
Approval is required before proceeding."A human approves or rejects the action.
The agent then continues.
Automatic Execution vs Review First
The current AWS ambient-agent pattern supports two important execution modes.
With autoExecute: false, the default in the reference implementation, a new job can wait for a human to review and run it.
With autoExecute: true, the agent can begin processing automatically, and a human is only involved if the agent explicitly asks for help.
That gives you two models:
Review-First
Event
|
v
Create Job
|
v
Human Review
|
v
Run AgentAutonomous
Event
|
v
Create Job
|
v
Run Agent
|
v
Human Only When NeededReview-first is usually the safer starting point for high-impact workflows.
Example: Document Processing
Suppose an insurance company receives documents through S3.
The bucket receives:
claims/
claim-1001.pdf
claim-1002.pdf
claim-1003.pdfAn ambient agent can process each new document.
S3 Upload
|
v
Event
|
v
Agent Job
|
v
Read Document
|
+-- Identify document type
+-- Extract claim information
+-- Check required fields
+-- Detect missing information
|
v
DecisionIf everything looks normal:
Agent
|
v
Create Processing RecordIf something is unusual:
Agent
|
v
Ask Human
|
v
Claims EmployeeThis is much closer to how organizations actually work.
The agent handles routine cases and escalates exceptions.
Example: Monitoring Alerts
Ambient agents are not limited to documents.
Consider an AWS environment producing CloudWatch alarms.
CloudWatch Alarm
|
v
Event
|
v
Ambient Agent
|
+-- Inspect alarm
+-- Check recent logs
+-- Inspect metrics
+-- Identify likely cause
|
v
Incident SummaryAWS has demonstrated a similar pattern with AgentWatch, an ambient monitoring agent deployed on AgentCore Runtime. It can be triggered on a schedule, inspect CloudWatch information, summarize infrastructure status, and support on-demand investigation.
A useful result might be:
Database CPU alarm triggered.
Observed:
- CPU increased from 42% to 91%.
- Query latency increased at the same time.
- Five application instances are affected.
Likely cause:
Increased read traffic.
Recommended next step:
Review the top queries from the last 15 minutes.The agent does not necessarily fix the problem.
It first turns a low-level signal into useful operational context.
Example: Scheduled Agents
An ambient agent does not need a physical event such as a file upload.
A schedule can be the trigger.
For example:
Every Morning
|
v
EventBridge Scheduler
|
v
AgentCore Runtime
|
v
Daily Operations Agent
|
+-- Review incidents
+-- Check system metrics
+-- Summarize failures
|
v
Slack / Email / DashboardAWS documents direct invocation of AgentCore Runtime from EventBridge Scheduler as one option for event-driven agent workloads.
This is useful for:
Daily reports
Scheduled analysis
Compliance checks
Cost reviews
Data-quality checks
Infrastructure summaries
Long-Running Agent Tasks
Some event-driven tasks are not finished in a few seconds.
A document might require several processing steps.
A large investigation might involve:
Event
|
v
Agent
|
+-- Search logs
+-- Query database
+-- Inspect metrics
+-- Call external service
+-- Analyze results
|
v
Final ResultAgentCore Runtime supports asynchronous and long-running agent workloads. AWS documents support for agents that can continue processing after the initial response and for long-running operations.
This makes the architecture different from a simple Lambda function that must finish everything inside a short request window.
AgentCore Runtime provides a dedicated execution environment for agents and supports extended execution times.
Where Does State Go?
An event-driven agent needs more than a model.
It needs to know:
What happened?
What has already been done?
What is waiting?
What should happen next?
Join the conversation! Your thoughts help the community grow.