Control interfaces
A control interface is the way your code or agent tells a Steel browser what to do. Steel's interfaces differ in who decides each step: your script, a language model that reads the page, or a model that looks at the screen. All of them except Quick actions drive a session, so you can choose one per task and still use the same session.
Compare the interfaces
| Interface | Who drives | What you install | It fits when |
|---|---|---|---|
| CDP | Your Playwright or Puppeteer code | The Steel SDK and Playwright or Puppeteer | You have browser scripts, or you need full control of the browser. |
| Commands | An agent, through the Steel CLI or your own agent harness | The Steel CLI, or any HTTP client | A model reads the page and acts one step at a time. |
| Computer actions | A computer-use model | The Steel SDK | The model works from screenshots and screen coordinates. |
| MCP server | An agent in an MCP client | Nothing | The agent cannot run shell commands, such as Claude on the web or the Claude desktop app. |
| Steel CLI | A coding agent, or you in a terminal | The Steel CLI | The agent runs shell commands, such as Claude Code, Codex or Cursor, or you test a page by hand. |
| Quick actions | Your code | The Steel SDK | You need one page as Markdown, a screenshot or a PDF, and no session. |
CDP
CDP is the Chrome DevTools Protocol. Playwright and Puppeteer use it to drive Chrome. A Steel session accepts a CDP connection over a WebSocket, at the session's websocketUrl. The URL holds a token for the session, so the client needs no API key. Your existing script then runs against the cloud browser with few changes.
Your code decides every step, and it has full CDP control, such as network interception. That makes CDP the choice for scripts that you already have and for tasks that need low-level control. Use the browser context that the session already has, so that your pages share its state and show in its live view.
CDP needs a library for your language. For a model that should decide the next step from the page, Commands are a better fit.
Commands
Commands drive a session over HTTP. Each request sends up to 50 commands, such as navigate, snapshot, click and fill. Steel runs them inside the session, next to the browser, and returns the result of each one.
Commands are built for agents. A snapshot turns the page into a short text list of its elements. Each element that the model can act on or point to has a ref, such as e1. The model reads the list, picks a ref, and sends it back in the next command. A request can also return a new snapshot, or the changes since the last one, so the model sees the effect of its step. Snapshots and refs explains how refs work and when they go stale.
Commands need no browser library. They work from any language that has an HTTP client. A request can name the response that came before it, so a retry of the same request does not run twice.
Computer actions
Computer actions drive a session the way a person drives a computer: move the mouse, click, drag, scroll, press keys and type. An action can return a screenshot, so the model sees the result.
Use them with a computer-use model, such as the ones from Anthropic, OpenAI and Google. These models look at a screenshot and answer with an action at a point on the screen. Steel runs the action in the session. The model never sees the page's structure, only its pixels.
The integrations for Claude, OpenAI and Gemini connect each model's tool to Computer actions.
MCP server and CLI
The MCP server and the Steel CLI give an agent a browser, and you write no code. Both run on Commands, so they work the same way: a snapshot, a ref, an action on the ref. If the agent can run shell commands, use the CLI. If it cannot, use the MCP server.
- Steel hosts the MCP server. You add its URL to an MCP client, sign in, and the agent gets tools such as
session_create,snapshot,clickandsession_release. It fits any client that supports remote MCP servers. - The Steel CLI is the
steelcommand.steel browserruns commands on a session from the terminal, and thesteel-browserskill teaches a coding agent to use it. The CLI fits agents that run shell commands, and it lets you try a step by hand.
Set up your agent sets up the CLI with one prompt, and Connect Claude to Steel sets up the MCP server.
Quick actions
Quick actions do one job in one request: Scrape returns a page as Markdown, HTML or readable text, Screenshot returns an image of it, and PDF returns a PDF. You send a URL. Steel opens it in a fresh browser, returns the result and leaves nothing running.
You do not create or release a session yourself. Steel runs each Quick action in a short-lived session, which counts toward your plan's concurrent sessions and is billed for its browser time, as Pricing shows. Use a Quick action when the task is to read one page. Use a session when the task needs a login, a click, a form or several pages in a row.
Mix interfaces in one session
Every interface except Quick actions acts on a session by its id. You can start a session with the SDK, drive it with Playwright, and read it with a snapshot. The Steel CLI can drive a session that the SDK or MCP server created. A person can also act in the session from the live view.
Each interface sees the browser as it is now, but Commands track only their own changes. A Commands response sets epochChanged when another Commands request or a browser restart has changed the session since your last request. Changes from a CDP client or from the live view do not count. After other code changes the page, take a new snapshot before you use old refs.
Let one interface act at a time. Two interfaces that click at once make each other's steps unpredictable.