Introducing Amazon Bedrock AgentCore Browser Tool

At AWS Summit New York City 2025, Amazon Web Services (AWS) announced the preview of Amazon Bedrock AgentCore browser tool, a fully managed, pre-built cloud-based browser. This tool enables generative AI agents to interact seamlessly with websites. It addresses two fundamental limitations: first, foundation models (FMs) are trained on large but static datasets and need dynamic access to current information when API access isn’t readily available; second, organizations face significant challenges when attempting to scale web automation with AI for enterprise use cases.

The development of agentic AI systems is moving toward applications that can execute complex, multistep tasks. For these agents to be effective, they require access to dynamic, real-time data, particularly from websites and web applications that don’t offer APIs or where API integration would be complex. Moreover, as businesses seek to deploy AI-powered automation across their operations, they need solutions that can reliably scale without the operational overhead of managing browser farms or solving complex concurrency issues. The AgentCore Browser Tool provides these capabilities, allowing agents to perform tasks such as automating research, streamlining operations, and interacting with web-based applications—all with the scalability, reliability, and security of the AWS Cloud infrastructure. By providing a fully managed cloud-based browser, AWS addresses the critical need for enterprises to deploy AI automation at scale across thousands of concurrent sessions, supporting use cases from customer service automation to large-scale data collection and analysis, without the traditional complexity and resource constraints of self-managed browser automation frameworks.

In this post, we introduce the newly announced Amazon Bedrock AgentCore Browser Tool. We explore why organizations need cloud-based browser automation and the limitations it addresses for FMs that require real-time data access. We talk about key use cases and the core capabilities of the AgentCore Browser Tool. We walk through how to get started with the tool.

Why do you need the cloud-based AgentCore Browser Tool?

Traditional browser automation approaches have typically required significant infrastructure management, security considerations, and development expertise. The introduction of a fully managed, cloud-based browser automation solution addresses several critical needs, including simplified infrastructure management, enterprise-grade security, global availability and scaling, and cost optimization. Organizations no longer need to provision, maintain, and scale browser instances to support their automation needs. AWS now handles the complex infrastructure requirements, so developers can focus on building intelligent agent capabilities rather than managing browser farms. Cloud-based browser automation provides isolated execution environments with AWS security controls, reducing the risk of data exfiltration or unauthorized access that might occur in less controlled environments. With a cloud-based browser, you can instantaneously deploy browser instances across the global infrastructure of AWS so that browser automation can scale. By offering browser automation as a managed service, organizations can use a consumption-based pricing model instead of maintaining always-on infrastructure, which can substantially reduce costs for intermittent workloads.

Use cases for cloud-based browser automation

Handling repetitive web tasks: With the introduction of Amazon Bedrock AgentCore Browser Tool, organizations can now implement sophisticated browser automation at scale. Cloud-based browser automation excels at minimizing manual execution of repetitive tasks across web interfaces. AI agents can populate complex web forms across multiple systems, validate entries, and maintain compliance with business rules. Agents can navigate to internal dashboards, extract critical metrics, and compile reports without human intervention. For organizations managing large user-generated content domains, agents can assist human moderators by prescreening content across multiple web interfaces.

AI powered research and intelligence gathering: With cloud-based browser automation, AI agents become powerful research assistants. They automatically track related websites for pricing changes, new product launches, or content updates with regular monitoring. You can use AI agents to gather and analyze consumer sentiment across various web forums, review sites, and social domains to inform product development. With the AgentCore Browser Tool, you can create automated systems that regularly scan trusted information sources to keep internal knowledge bases current.

Complex workflow automation across systems: Many organizations operate across numerous web applications that lack integrated workflows. Use the AgentCore Browser Tool to automate customer setup across multiple software-as-a-service (SaaS) systems when APIs are unavailable. This helps maintain consistency and reduces error rates. You can monitor supplier portals, inventory systems, and logistics services to maintain visibility across complex supply chains. By automating account creation and permission settings across numerous internal web applications, employee onboarding becomes streamlined.

Testing and quality assurance: Cloud-based browser automation enables robust testing at scale. You can use AgentCore Browser Tool to validate user experiences and functionality across different scenarios, devices, and browsers in parallel. Deploy agents to continuously interact with critical business applications and set up alerts to your teams about performance issues before customers encounter them. With AgentCore Browser Tool, you can regularly test web applications for accessibility compliance, security vulnerabilities, or regulatory requirements.

Legacy system integration: Many organizations maintain legacy systems that lack modern APIs. Enable modern AI capabilities to interact with legacy web applications that would be costly to replace or modernize. Apply intelligent automation to systems that were never designed for programmatic access. As a result, you can extract valuable organizational data trapped in older web applications through regular, automated harvesting.

Core capabilities

The Amazon Bedrock AgentCore Browser Tool empowers AI agents to interact with web content the same way humans do, through a fully managed remote browser infrastructure that minimizes traditional complexity while delivering enterprise-grade security and scalability.

Web interaction capabilities

• Complete navigation control across websites and multipage workflows
• Interaction with JavaScript-heavy applications and dynamic content
• Form manipulation, including text fields, dropdown menus, and file uploads
• Humanlike interaction patterns such as scrolling, hovering, and clicking

Serverless browser infrastructure

• Zero-management browser fleet with automatic patching
• Seamless scaling from single session to thousands based on demand
• Global deployment options with usage-based pricing
• Optimized performance without infrastructure overhead

Visual understanding

• Full-page screenshots enabling AI comprehension of layout and content
• Visual element identification by appearance and position
• Content extraction from graphical elements
• Resolution and device emulation capabilities

Human-in-the-loop integration

• Real-time interactive viewing and control for human operators
• Session recording for review, training, and compliance

Enterprise-grade security

• Complete session isolation for each browser instance
• AWS Identity and Access Management (IAM) controls for access management
• Ephemeral browser sessions that reset after each use

Complex web application support

• Full compatibility with modern JavaScript frameworks
• Authentication handling and session persistence
• Processing of asynchronous content and real-time updates
• Intelligent interaction with complex UI patterns

Audit and compliance

• Detailed interaction logging and session recording
• Integration with AWS CloudTrail for comprehensive tracking

Observability

• Performance metrics on latency and resource usage
• Integration with Amazon CloudWatch for unified monitoring
• Session record and replay for observability

This comprehensive set of capabilities bridges the fundamental gap between AI agents and the human web, enabling organizations to build intelligent agents that can understand and interact with content designed for humans rather than being limited to API-based integrations.

How an AI agent can use AgentCore Browser Tool

Amazon Bedrock AgentCore Browser runs in a secure, isolated containerized environment within AgentCore, insulating web activity from your local system. You can interact with the AgentCore Browser Tool using browser actuation libraries, such as Playwright, or use AI agentic frameworks specialized for browser automation, such as Amazon Nova Act and Browser Use. You can also integrate browser automation as a tool in a multi-agentic workflow.

Amazon Nova Act or Browser Use works with the AgentCore Browser Tool to take natural language instructions from the user and convert them to actuations on the browser by following this workflow:

1. The user sends a query such as “search for shoes on Amazon”
2. An agentic framework such as Amazon Nova Act or Browser Use passes the query to the large language model (LLM)
3. The LLM reasons and generates instructions in a structured output format (for example, JSON encoded)
4. The agentic framework maps these instructions into browser actuation commands (such as Playwright, Puppeteer, or Selenium)
5. The browser actuation commands are executed on the AgentCore Browser over a secure WebSocket connection
6. The response from the browser and a screenshot are sent to the agent to reason further

This process repeats until the original task is complete. The flow is illustrated in the following diagram.

Get started

The Amazon Bedrock AgentCore Browser Tool is available for use today. For a collection of open source examples, visit the amazon-bedrock-agentcore-samples repository on GitHub.

Prerequisites

To use the Amazon Bedrock AgentCore Brower Tool, you need to complete the following prerequisites:

• Python 3.10+
• Verify your IAM user or role has the permissions to use AgentCore Browser:

git clone https://github.com/awslabs/amazon-bedrock-agentcore-samples.git
pip install bedrock-agentcore 

For browser visualization on your local machine, you need the BrowserViewerServer component in the repository you cloned at: 01-tutorials/05-AgentCore-tools/02-Agent-Core-browser-tool/interactive_tools

You can also visualize the browser live on the Amazon Bedrock AgentCore console at https://us-east-1.console.aws.amazon.com/bedrock-agentcore/builtInTools

The following Python code demonstrates how to use the AgentCore Browser Tool directly with the Playwright library and the Amazon Bedrock AgentCore SDK. This example initiates a secure browser session, connects to it, and automates a straightforward workflow in which it navigates to https://www.amazon.com and searches for a product.

1. To get started with playwright:

cd 01-tutorials/05-AgentCore-tools/02-Agent-Core-browser-tool

2. Install dependencies:

pip install playwright

3. Author your playwright-based script:

from playwright.sync_api import sync_playwright, Playwright, BrowserType
from bedrock_agentcore.tools.browser_client import browser_session
from browser_viewer import BrowserViewerServer
import time
from rich.console import Console
console = Console()
def run(playwright: Playwright):
    # Create the browser session and keep it alive
    with browser_session('us-west-2') as client:
        ws_url, headers = client.generate_ws_headers()
        # Start viewer server
        viewer = BrowserViewerServer(client, port=8005)
        viewer_url = viewer.start(open_browser=True)
        # Connect using headers
        chromium: BrowserType = playwright.chromium
        browser = chromium.connect_over_cdp(
            ws_url,
            headers=headers
        )
        context = browser.contexts[0]
        page = context.pages[0]
        try:
            page.goto("https://amazon.com/")
            console.print(page.title())
            # Keep running
            while True:
                time.sleep(120)
        except KeyboardInterrupt:
            console.print("nn[yellow]Shutting down...[/yellow]")
            if 'client' in locals():
                client.stop()
                console.print("✅ Browser session terminated")
        except Exception as e:
            console.print(f"n[red]Error: {e}[/red]")
            import traceback
            traceback.print_exc()
with sync_playwright() as playwright:
    run(playwright)

Alternatively, you can build a browser agent using Amazon Nova Act to automate web interactions:

4. Sign up for Nova Act at https://nova.amazon.com/act and generate an API key.
5. In the same Python virtual environment:

pip install nova-act

6. Author your Nova Act based script:

import time
from bedrock_agentcore.tools.browser_client import browser_session
from nova_act import NovaAct
from rich.console import Console
from browser_viewer import BrowserViewerServer
 
NOVA_ACT_API_KEY = "YOUR_NOVA_ACT_API_KEY"
console = Console() 
 
def main():
    try:
        # Step 1: Create browser session
        with browser_session('us-west-2') as client:
            print("r   ✅ Browser ready!                    ")
            ws_url, headers = client.generate_ws_headers()
 
            # Step 2: Start viewer server
            console.print("n[cyan]Step 3: Starting viewer server...[/cyan]")
            viewer = BrowserViewerServer(client, port=8005)
            viewer_url = viewer.start(open_browser=True)
 
            # Step 3: Use Nova Act to interact with the browser with NovaAct
            with NovaAct(
                    cdp_endpoint_url=ws_url,
                    cdp_headers=headers,
                    preview={"playwright_actuation": True},
                    nova_act_api_key=NOVA_ACT_API_KEY,
                    starting_page="https://www.amazon.com",
                ) as nova_act:
                    result = nova_act.act("Search for coffee maker and get the details of the lowest priced one on the first page")
                    console.print(f"n[bold green]Nova Act Result:[/bold green] {result}")
            
            # Keep running
            while True:
                time.sleep(1)
             
    except KeyboardInterrupt:
        console.print("nn[yellow]Shutting down...[/yellow]")
        if 'client' in locals():
            client.stop()
            print("✅ Browser session terminated")
    except Exception as e:
        print(f"n[red]Error: {e}[/red]")
        import traceback
        traceback.print_exc()
 
if __name__ == "__main__":
    main()

Alternatively, you can run the tutorial notebooks in the Amazon Bedrock AgentCore GitHub repository.

Pricing and availability

Amazon Bedrock AgentCore offers flexible, consumption-based pricing with no upfront commitments or minimum fees. AgentCore Browser can be used independently of the other services. You can try AgentCore services at no additional charge until September 16, 2025. After this date, AgentCore Browser Tool will be charged based on consumption. Billing is calculated per second, using the highest watermark of CPU and memory usage for that second, with a 1-second minimum. 128 MB minimum memory billing applies. Network data transfer through customer elastic network interfaces is billed at standard Amazon Elastic Compute Cloud (Amazon EC2) rates

For more information about pricing, visit Amazon Bedrock AgentCore (Preview) Pricing.

Conclusion

Amazon Bedrock AgentCore Browser Tool marks a transformative advancement in AI-powered web automation, offering organizations a fully managed, cloud-based browser solution. AgentCore Browser Tool addresses critical limitations faced by generative AI systems requiring real-time data access, enabling AI agents to interact naturally with websites through capabilities such as complete navigation control, visual understanding, and seamless integration with frameworks such as Playwright and Amazon Nova Act. By using this tool, businesses can now implement sophisticated automation at scale across various use cases—from streamlining repetitive web tasks and conducting AI-enhanced research to automating complex workflows and integrating with legacy systems—all while benefiting from the reliable cloud infrastructure of AWS that adapts to organizational needs without the operational overhead of managing browser farms.

Resources

To learn more and start building, visit the following resources:

• Amazon Bedrock AgentCore Developer Guide
• Amazon Bedrock AgentCore console

About the authors

Veda Raman is a Senior Specialist Solutions Architect for generative AI and machine learning at AWS. Veda works with customers to help them architect efficient, secure, and scalable machine learning applications. Veda specializes in generative AI services like Amazon Bedrock and Amazon SageMaker.

Rahul Sharma is a Senior Specialist Solutions Architect at AWS, helping AWS customers build and deploy, scalable Agentic AI solutions. Prior to joining AWS, Rahul spent more than decade in technical consulting, engineering, and architecture, helping companies build digital products, powered by data and machine learning. In his free time, Rahul enjoys exploring cuisines, traveling, reading books(biographies and humor) and binging on investigative documentaries, in no particular order.

Kishor Aher is a Principal Product Manager at AWS, leading the Agentic AI team responsible for developing first-party tools such as Browser Tool, and Code Interpreter. As a founding member of Amazon Bedrock, he spearheaded the vision and successful launch of the service, driving key features including Converse API, Managed Model Customization, and Model Evaluation capabilities. Kishor regularly shares his expertise through speaking engagements at AWS events, including re:Invent and AWS Summits. Outside of work, he pursues his passion for aviation as a general aviation pilot and enjoys playing volleyball.