Migrate AWS AgentCore Browser to Notte

What changes

AWS AgentCore Browser: Amazon Bedrock AgentCore Browser provides isolated managed browser sessions with live interaction and AWS observability. Browser automation libraries use its streaming endpoints; the surrounding AWS execution layer is a separate choice.

Notte: Notte combines cloud browser sessions with deployed Python automations and website authentication tools. You can control the browser over CDP or use Notte's actions, then deploy repeated work as a Function.

Port the browser actions separately from the provider integration. A session endpoint, a saved profile identifier and a managed login connection belong to the provider that created them; replacing an API key does not migrate those resources.

Map the resource contract

Sources: docs.aws.amazon.com [1] ↗docs.notte.cc [2] ↗docs.notte.cc [3] ↗docs.notte.cc [4] ↗docs.notte.cc [5] ↗docs.notte.cc [6] ↗docs.notte.cc [7] ↗

1. Replace session ownership

Create or select a Browser Tool, then start an isolated browser session. The documented default session timeout is 15 minutes and the maximum is eight hours. Browser automation uses the session's WebSocket endpoints.

Create an owned browser session, connect Playwright or Puppeteer over CDP, and stop the session when the work finishes. Browser lifecycle management remains necessary even when the control socket disconnects.

Create the target session through its documented API, keep its returned identifier with the application job, and implement the target release path before testing failures.

Sources: docs.aws.amazon.com [1] ↗docs.notte.cc [2] ↗

2. Re-establish saved state and authentication

AWS AgentCore Browser: The Browser Tool documentation describes ephemeral sessions that reset after use. State that must outlive a session needs an explicit storage or authentication design rather than an assumption of permanent browser state.

Notte: Profiles save cookies, local storage and session storage. Sessions start with fresh state by default. Persisting a profile writes state back when the session ends; a running session can also save its state explicitly.

Notte: Vaults substitute credential placeholders in supported browser actions outside the model context. Managed Auth checks requested saved connections before automation. Personas supply an inbox and optional phone number for verification workflows.

Use a supported export/import path only if both products document it. Otherwise establish an authorized login on the target and save its state there. Never reuse a source provider's resource ID as a target profile or connection.

Sources: docs.aws.amazon.com [1] ↗docs.notte.cc [2] ↗docs.notte.cc [3] ↗

3. Move the execution layer deliberately

AWS AgentCore Browser: The Browser Tool supplies the browser environment. An external process or another AWS execution service runs the application code that controls it. Identify that service and its runtime before comparing it with a deployed browser Function.

Notte: Functions deploy Python code with a run() entry point. Invoke them over HTTP or with an SDK, inspect run history, and roll back code by redeploying an earlier version as the latest version.

Keep the existing runner for the first browser test when possible. If execution moves to a hosted Function or app action, separately port the entry point, dependencies, invocation, results and cancellation behavior.

Sources: docs.aws.amazon.com [1] ↗docs.notte.cc [2] ↗

Check the browser connection

Install playwright-core in your application and provision a session through the provider's documented creation flow. Run this smoke test from the intended controller region with the returned CDP endpoint. It checks connection and navigation, not login, rendering parity or a complete business workflow.

Keep browser connection URLs on your backend. After the test, release the owned session through the provider's API. Product-specific lifecycle APIs and profile identifiers are not portable between providers.

import { chromium } from "playwright-core";

// Provision the owned browser using the provider's documented session API.
// Keep the connection URL in your backend's secret environment.
const endpoint = process.env.BROWSER_CDP_URL;
if (!endpoint) throw new Error("Set BROWSER_CDP_URL for an owned session");

const browser = await chromium.connectOverCDP(endpoint);
try {
  const context = browser.contexts()[0] ?? await browser.newContext();
  const page = context.pages()[0] ?? await context.newPage();
  await page.goto("https://example.com", { waitUntil: "domcontentloaded" });
  if ((await page.title()) !== "Example Domain") {
    throw new Error("The browser did not reach the expected page");
  }
  console.log({ connected: true, expectedPage: true });
} finally {
  await browser.close();
  // Release the owned session with the provider's documented API as well.
  // A disconnected socket alone is not a portable session-cleanup contract.
}

Sources: playwright.dev ↗

4. Prove the same task still completes

After the connection smoke test, run the same authorized business workflow on both providers. Verify the account, output and expected website state. Record each provider's session identifier and the implementation version with its result.

• Test a fresh session and a second session with restored state.
• Exercise a controlled failure and check the retained evidence.
• Verify the target concurrency and duration entitlements.
• Stop the target execution and release the owned browser.
• Retain the source integration until the acceptance checks pass.

5. Recalculate costs and limits

The public plans list 5, 25 and 100 concurrent browser sessions, with custom limits on Enterprise. Session duration and concurrent capacity are separate plan limits; a larger technical API limit does not override the plan.

The public usage rates are $0.01 per browser-hour, $0.05 per Function-hour and $10 per GB of managed proxy traffic. Paid plans return their price as usage credits. Price the relevant meters and plan eligibility for the workload.

A saved profile restores browser state; it does not prove that a website still considers the user signed in. Use Managed Auth when the workflow needs connection readiness before it starts.

Sources: notte.cc [1] ↗

Keep comparing