Skip to content

Control interfaces

Set up your agent

Give your coding agent a Steel browser and the Steel skills, so that it browses and writes Steel code the right way. Learn more

Install the Steel CLI. It signs you in and installs the skills for your coding agents.

curl -fsS https://setup.steel.dev | sh

Or send this prompt to your coding agent, and it does the same:

Read https://setup.steel.dev/install.md and follow it to set up Steel for this coding client.
Then continue my requested task using the installed Steel skill.

Set up your agent →

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

InterfaceWho drivesWhat you installIt fits when
CDPYour Playwright or Puppeteer codeThe Steel SDK and Playwright or PuppeteerYou have browser scripts, or you need full control of the browser.
CommandsAn agent, through the Steel CLI or your own agent harnessThe Steel CLI, or any HTTP clientA model reads the page and acts one step at a time.
Computer actionsA computer-use modelThe Steel SDKThe model works from screenshots and screen coordinates.
MCP serverAn agent in an MCP clientNothingThe agent cannot run shell commands, such as Claude on the web or the Claude desktop app.
Steel CLIA coding agent, or you in a terminalThe Steel CLIThe agent runs shell commands, such as Claude Code, Codex or Cursor, or you test a page by hand.
Quick actionsYour codeThe Steel SDKYou 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, click and session_release. It fits any client that supports remote MCP servers.
  • The Steel CLI is the steel command. steel browser runs commands on a session from the terminal, and the steel-browser skill 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.