Chrome Extensions for Browser Agents

Short answer

Use Chrome extensions when your agent needs persistent, browser-side logic that scripts or prompts keep breaking. Steel's Extensions API (currently in beta) lets you upload an extension once for your organization—via .zip, .crx, or a Chrome Web Store URL—and inject it into any session by passing extensionIds or the shortcut all_ext when you create the session. That keeps shared DOM observers, UI overlays, and compliance helpers available to every workflow without rewriting CDP code each time.

Skip extensions when a lightweight Playwright step or content script edit will do. Extensions load only when the Steel session starts, they carry the permissions declared in manifest.json, and they add weight to the session. If the logic is simple, keep it inside your orchestrator; if it needs to run quietly beside the agent every time, make it an extension.

When extensions belong inside the workflow

Instead of patching scripts forever, treat extensions as shared instrumentation

Extensions turn one-off glue into an asset. Because Steel stores them at the org level, you upload once, list IDs with client.extensions.list(), and keep reusing them across agents, SDKs, and regions. That means the agent prompt can stay simple (“click @e4, read the card, return JSON”) while the extension handles the gnarly parts: injecting schema hints, suppressing pop-ups, or masking PII before snapshots land in your evidence folder. They also play nicely with human-in-the-loop steps: an overlay the extension renders into the page carries through to both the live WebRTC embed and the MP4/HLS replay, so a reviewer watching either one sees the same guardrails.

Implementation path

1. Package or pick your extension
   • Zip your manifest.json plus source, or copy a Chrome Web Store URL.
   • Remember: the permissions you declare apply to every session that loads it; keep them as narrow as possible.
2. Upload once per organization

   await client.extensions.upload({
     file: fs.readFileSync('extensions/redactor/redactor.zip')
   });
   // or
   await client.extensions.upload({
     url: 'https://chromewebstore.google.com/detail/...'
   });

3. Discover the IDs you need to reference

   // Steel normalizes extension names (truncated + underscored), so match on
   // the id you stored from upload() rather than the fragile display name.
   const { extensions } = await client.extensions.list();
   const redactor = extensions.find((ext) => ext.id === REDACTOR_ID);

4. Attach extensions when you create sessions

   session = client.sessions.create(
       extension_ids=[redactorId, 'helper_metrics']  # or ['all_ext']
   )

   Extensions load and initialize when the session boots, so plan to start a new session when you change the set. Each session boots a clean Chrome, so extension state does not persist across sessions unless you re-attach via extensionIds each time.
5. Verify inside the run
   • Use steel browser live or the debug URL to confirm the extension shows up in chrome://extensions and renders its UI.
   • Capture a steel browser screenshot so the evidence includes the extension's overlay or output.
6. Update or retire as workflows evolve

   await client.extensions.update(redactorId, {
     file: fs.readFileSync('extensions/redactor/v2.zip')
   });
   await client.extensions.delete(redactorId);      // remove single
   await client.extensions.deleteAll();             // wipe everything

   Updates replace the stored artifact; deletions keep future sessions lean without touching past traces.

Guardrails and trade-offs

Extensions run isolated in the browser, so they cannot call Steel services (Files, Credentials, Profiles) directly — your orchestrator still has to push that data into Steel artifacts.

Next steps

• Read the Extensions API overview for every endpoint (upload, list, update, delete, deleteAll).
• Follow the Upload and run browser extensions cookbook recipe for end-to-end TypeScript and Python examples.
• Start a fresh Steel session with extension_ids=['all_ext'] and confirm your helper loads before the agent runs its first step.
• Write down which workflows truly need an extension (shared overlays, instrumentation) and leave everything else to lightweight scripts.

Humans use Chrome. Agents use Steel.