Steel.dev Docs Mirror

Appearance

AI Agent Frameworks ​

Steel connects with seven AI agent frameworks, giving your agents reliable cloud browser infrastructure with anti-bot capabilities, proxy support, and session recording out of the box.

How Agents Connect Through Steel ​

All frameworks follow the same lifecycle: create a Steel session, connect your agent, run tasks, release the session.

Stagehand ​

Language: TypeScript / Python | Connection: CDP WebSocket | LLM: OpenAI

Stagehand is an open-source library that lets you write browser automations in natural language. The Steel integration connects Stagehand with cloud browser infrastructure for seamless automation of web tasks and workflows.

Requirements ​

  • Steel API Key
  • OpenAI API Key
  • Node.js or Python environment

Quick Setup (Node.js) ​

typescript
import Steel from "steel-sdk";
import { Stagehand } from "@browserbasehq/stagehand";

const steel = new Steel({ steelAPIKey: process.env.STEEL_API_KEY });
const session = await steel.sessions.create();

// Connect Stagehand to the Steel session via CDP
const cdpUrl = `wss://connect.steel.dev?apiKey=${process.env.STEEL_API_KEY}&sessionId=${session.id}`;

// Pass cdpUrl to Stagehand and start automating
// ...

// Cleanup
await steel.sessions.release(session.id);

Resources ​

Browser-Use ​

Language: Python | Connection: CDP WebSocket | LLM: GPT-4o, Claude 3 (vision-capable)

Browser-Use enables AI agents to control and interact with browsers programmatically. Agents can navigate websites, fill forms, click buttons, extract data, and complete multi-step tasks using Steel's cloud browsers.

Requirements ​

  • Python 3.11+
  • Steel API Key
  • OpenAI API Key (or another vision-capable model)

Quick Setup ​

python
import os
from steel import Steel
from browser_use import Agent, BrowserSession
from browser_use.llm import ChatOpenAI
from dotenv import load_dotenv

load_dotenv()
STEEL_API_KEY = os.getenv("STEEL_API_KEY")

client = Steel(steel_api_key=STEEL_API_KEY)
session = client.sessions.create()

cdp_url = f"wss://connect.steel.dev?apiKey={STEEL_API_KEY}&sessionId={session.id}"
browser_session = BrowserSession(cdp_url=cdp_url)

model = ChatOpenAI(
    model="gpt-4o",
    temperature=0.3,
    api_key=os.getenv("OPENAI_API_KEY"),
)

agent = Agent(
    task="Go to Wikipedia and search for machine learning",
    llm=model,
    browser_session=browser_session,
)

result = await agent.run()

# Cleanup
client.sessions.release(session.id)

Resources ​

CrewAI ​

Language: Python | Connection: Steel SDK | LLM: Any (OpenAI default)

CrewAI is a lean, lightning-fast Python framework for orchestrating autonomous multi-agent systems. The Steel integration connects CrewAI's Crews (autonomous agent teams) and Flows (event-driven orchestration) with cloud browsers for scalable, enterprise-ready web automation.

Capabilities ​

  • Automate complex web workflows: search, navigate, form-fill, extract, validate
  • Mix autonomy (Crews) with precise control (Flows)
  • Share memory and state across steps
  • Return structured outputs (JSON/typed)
  • Human-in-the-loop checkpoints for sensitive actions

Requirements ​

  • Python 3.10 -- 3.13
  • Steel API Key
  • LLM API Key (e.g., OpenAI)
  • Optional: Search tools (Serper.dev), vector stores, custom tools

Quick Setup ​

python
from steel import Steel
# Install: pip install crewai steel-sdk

# 1. Create Steel session
client = Steel(steel_api_key="your-steel-api-key")
session = client.sessions.create()

# 2. Define agents with Steel browser tools
# 3. Create Crews or Flows that use Steel sessions
# 4. Run the orchestrated workflow

# 5. Cleanup
client.sessions.release(session.id)

Resources ​

AgentKit (Inngest) ​

Language: TypeScript | Connection: Steel SDK | LLM: OpenAI, Anthropic, Gemini

AgentKit is a TypeScript library by Inngest for creating and orchestrating AI agents, from single-model calls to multi-agent networks with deterministic routing, shared state, and rich tooling via MCP.

Capabilities ​

  • Drive Steel browsers from AgentKit agents (navigate, search, fill forms, extract)
  • Orchestrate multi-agent Networks with shared State and code/LLM-based Routers
  • Plug in MCP servers as tools for real-world actions
  • Stream live tokens and steps to your UI
  • Capture traces locally during development
  • Mix deterministic flows with autonomous handoffs

Requirements ​

  • Node.js v20+
  • Steel API Key
  • npm i @inngest/agent-kit inngest (AgentKit >= v0.9.0)
  • Model provider key (OpenAI, Anthropic, or Gemini)

Quick Setup ​

typescript
import { Steel } from "steel-sdk";
// npm i @inngest/agent-kit inngest steel-sdk

// 1. Create Steel session
const steel = new Steel({ steelAPIKey: process.env.STEEL_API_KEY });
const session = await steel.sessions.create();

// 2. Define Agents with Steel browser tools
// 3. Create Networks with Routers for task orchestration
// 4. Build the execution pipeline
// 5. Run tasks

// 6. Cleanup
await steel.sessions.release(session.id);

Resources ​

Agno ​

Language: Python | Connection: Steel SDK | LLM: 23+ providers (model-agnostic)

Agno is a full-stack Python framework for building multi-agent systems with shared memory, knowledge, and reasoning. It is model-agnostic across 23+ providers and natively multi-modal. The Steel integration enables browser control as Agno tools within single agents or coordinated agent teams.

Capabilities ​

  • Launch and control Steel sessions as Agno tools
  • Automate multi-step web workflows with shared context and memory
  • Combine Agentic RAG with web automation using vector stores
  • Use reasoning models or Agno's built-in ReasoningTools
  • Return structured outputs (JSON/typed)
  • Monitor runs end-to-end

Requirements ​

  • Python environment
  • Steel API Key
  • Model provider key (OpenAI, Anthropic, etc.)
  • Optional: Vector DB + memory/session storage for Agentic RAG

Quick Setup ​

python
from steel import Steel
# Install: pip install agno steel-sdk

# 1. Create Steel session
client = Steel(steel_api_key="your-steel-api-key")
session = client.sessions.create()

# 2. Create Steel browser tools for Agno agents
# 3. Build agent(s) or teams with Steel capabilities
# 4. Run tasks and collect structured results

# 5. Cleanup
client.sessions.release(session.id)

Resources ​

Magnitude ​

Language: TypeScript | Connection: CDP WebSocket | LLM: Anthropic

Magnitude is a browser agent framework that connects to Steel via CDP. It provides natural language actions (agent.act) and structured data extraction (agent.extract with Zod schemas), powered by Anthropic models.

Requirements ​

  • Node.js 20+
  • Steel API Key
  • Anthropic API Key

Quick Setup ​

typescript
import { Steel } from "steel-sdk";
import { startBrowserAgent } from "magnitude-core";
import { z } from "zod";

const STEEL_API_KEY = process.env.STEEL_API_KEY!;
const client = new Steel({ steelAPIKey: STEEL_API_KEY });
const session = await client.sessions.create();

const agent = await startBrowserAgent({
  url: "https://github.com/steel-dev/leaderboard",
  narrate: true,
  llm: {
    provider: "anthropic",
    options: {
      model: "claude-3-7-sonnet-latest",
      apiKey: process.env.ANTHROPIC_API_KEY,
    },
  },
  browser: {
    cdp: `${session.websocketUrl}&apiKey=${STEEL_API_KEY}`,
  },
});

// Extract structured data using a Zod schema
const data = await agent.extract(
  "Find the user with the most recent commit",
  z.object({
    user: z.string(),
    commit: z.string(),
  })
);

// Perform natural language actions
await agent.act("Find the pull request behind the most recent commit");

// Cleanup
await agent.stop();
await client.sessions.release(session.id);

Resources ​

Notte ​

Language: Python | Connection: CDP WebSocket | LLM: Gemini (default)

Notte is a Python browser agent framework that connects to Steel via CDP. It provides a simple agent interface with configurable reasoning models and step limits. Run tasks in a live cloud browser with easy session management.

Requirements ​

  • Python 3.11+
  • Steel API Key
  • Gemini API Key

Quick Setup ​

python
import os
import notte
from steel import Steel
from dotenv import load_dotenv

load_dotenv()
STEEL_API_KEY = os.getenv("STEEL_API_KEY")

client = Steel(steel_api_key=STEEL_API_KEY)
session = client.sessions.create()

cdp_url = f"{session.websocket_url}&apiKey={STEEL_API_KEY}"

with notte.Session(cdp_url=cdp_url) as notte_session:
    agent = notte.Agent(
        session=notte_session,
        max_steps=5,
        reasoning_model="gemini/gemini-2.0-flash",
    )
    response = agent.run(
        task="Go to Wikipedia and search for machine learning"
    )
    print(response.answer)

# Cleanup
client.sessions.release(session.id)

Resources ​

SOP Documentation Hub - Built from Steel.dev Official Docs

Powered by VitePress + Claude RAG