Agent

const agent = stagehand.agent({
    mode: "cua",
    model: "google/gemini-3-flash-preview",
    systemPrompt: "You are a helpful assistant...",
});

await agent.execute({
    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
    maxSteps: 20,
    highlightCursor: true
})

const agent = stagehand.agent({
    mode: "cua",
    model: "openai/computer-use-preview",
    systemPrompt: "You are a helpful assistant...",
});

await agent.execute({
    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
    maxSteps: 20,
    highlightCursor: true
})

const agent = stagehand.agent({
    mode: "cua",
    model: "anthropic/claude-sonnet-4-6",
    systemPrompt: "You are a helpful assistant...",
});

await agent.execute({
    instruction: "Go to Hacker News and find the most controversial post from today, then read the top 3 comments and summarize the debate.",
    maxSteps: 20,
    highlightCursor: true
})

const stagehand = new Stagehand({
  env: "BROWSERBASE",
  experimental: true, // Required for hybrid mode
});
await stagehand.init();

const agent = stagehand.agent({
  mode: "hybrid",
  model: "google/gemini-3-flash-preview",
});

const page = stagehand.context.pages()[0];
await page.goto("https://example.com");

await agent.execute({
  instruction: "Click the sign up button and fill out the registration form",
  maxSteps: 20,
});

const stagehand = new Stagehand({
  env: "BROWSERBASE",
  experimental: true, // Required for hybrid mode
});
await stagehand.init();

const agent = stagehand.agent({
  mode: "hybrid",
  model: "anthropic/claude-haiku-4-5-20251001",
  systemPrompt: "You are a helpful assistant that interacts with web pages visually.",
});

await agent.execute({
  instruction: "Navigate the page and interact with the form elements",
  maxSteps: 15,
  highlightCursor: true, // Enabled by default in hybrid mode
});

import { tool } from "@browserbasehq/stagehand";
import { z } from "zod";

const agent = stagehand.agent({
  model: "openai/gpt-5",
  tools: {
    getWeather: tool({
      description: 'Get the current weather in a location',
      inputSchema: z.object({
        location: z.string().describe('The location to get weather for'),
      }),
      execute: async ({ location }) => {
        // Your custom logic here
        const weather = await fetchWeatherAPI(location);
        return {
          location,
          temperature: weather.temp,
          conditions: weather.conditions,
        };
      },
    }),
  },
  systemPrompt: 'You are a helpful assistant with access to weather data.',
});

await agent.execute("What's the weather in San Francisco and should I bring an umbrella?");

import { tool } from "@browserbasehq/stagehand";
import { z } from "zod";

const agent = stagehand.agent({
  mode: "cua",
  model: "anthropic/claude-sonnet-4-6",
  tools: {
    searchDatabase: tool({
      description: 'Search for records in the database',
      inputSchema: z.object({
        query: z.string().describe('The search query'),
        limit: z.number().optional().describe('Max results to return'),
      }),
      execute: async ({ query, limit = 10 }) => {
        const results = await db.search(query, limit);
        return { results };
      },
    }),

    calculatePrice: tool({
      description: 'Calculate the total price with tax',
      inputSchema: z.object({
        amount: z.number().describe('The base amount'),
        taxRate: z.number().describe('Tax rate as decimal (e.g., 0.08 for 8%)'),
      }),
      execute: async ({ amount, taxRate }) => {
        const total = amount * (1 + taxRate);
        return { total: total.toFixed(2) };
      },
    }),
  },
});

await agent.execute("Find products under $50 and calculate the total with 8% tax");

import { tool } from "@browserbasehq/stagehand";
import { z } from "zod";

const agent = stagehand.agent({
  model: "google/gemini-2.0-flash",
  tools: {
    sendEmail: tool({
      description: 'Send an email via SendGrid',
      inputSchema: z.object({
        to: z.string().email().describe('Recipient email address'),
        subject: z.string().describe('Email subject'),
        body: z.string().describe('Email body content'),
      }),
      execute: async ({ to, subject, body }) => {
        const response = await fetch('https://api.sendgrid.com/v3/mail/send', {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            personalizations: [{ to: [{ email: to }] }],
            from: { email: 'noreply@example.com' },
            subject,
            content: [{ type: 'text/plain', value: body }],
          }),
        });

        return {
          sent: response.ok,
          messageId: response.headers.get('X-Message-Id'),
        };
      },
    }),
  },
});

await agent.execute("Fill out the contact form and send me a confirmation email at user@example.com");

const agent = stagehand.agent({
    mode: "cua",
    model: "openai/computer-use-preview",
    integrations: [
      `https://mcp.exa.ai/mcp?exaApiKey=${process.env.EXA_API_KEY}`,
    ],
    systemPrompt: `You have access to web search through Exa. Use it to find current information before browsing.`
});

await agent.execute("Search for the best headphones of 2025 and go through checkout for the top recommendation");

import { connectToMCPServer } from "@browserbasehq/stagehand";

const supabaseClient = await connectToMCPServer(
  `https://server.smithery.ai/@supabase-community/supabase-mcp/mcp?api_key=${process.env.SMITHERY_API_KEY}`
);

const agent = stagehand.agent({
    mode: "cua",
    model: "openai/computer-use-preview",
    integrations: [supabaseClient],
    systemPrompt: `You can interact with Supabase databases. Use these tools to store and retrieve data.`
});

await agent.execute("Search for restaurants and save the first result to the database");

import { z } from "zod";

const stagehand = new Stagehand({
  env: "LOCAL",
  experimental: true, // Required for structured output
});
await stagehand.init();

const agent = stagehand.agent({
  model: "anthropic/claude-sonnet-4-5-20250929",
});

const page = stagehand.context.pages()[0];
await page.goto("https://www.google.com/flights");

const result = await agent.execute({
  instruction: "Find the cheapest flight from NYC to LA for next week",
  maxSteps: 20,
  output: z.object({
    price: z.string().describe("The price of the flight"),
    airline: z.string().describe("The airline name"),
    departureTime: z.string().describe("Departure time"),
    arrivalTime: z.string().describe("Arrival time"),
  }),
});

// Access the structured output
console.log(result.output);
// { price: "$199", airline: "Delta", departureTime: "8:00 AM", arrivalTime: "11:30 AM" }

const result = await agent.execute({
  instruction: "Extract all items from the shopping cart",
  output: z.object({
    items: z.array(z.object({
      name: z.string().describe("Product name"),
      quantity: z.number().describe("Quantity in cart"),
      unitPrice: z.string().describe("Price per item"),
      totalPrice: z.string().describe("Total price for this item"),
    })).describe("List of items in the cart"),
    subtotal: z.string().describe("Cart subtotal before tax"),
    tax: z.string().optional().describe("Tax amount if shown"),
    total: z.string().describe("Final total"),
  }),
});

console.log(`Found ${result.output?.items.length} items in cart`);
console.log(`Total: ${result.output?.total}`);

const agent = stagehand.agent({
  model: "anthropic/claude-sonnet-4-5-20250929",
  stream: true,
});

const streamResult = await agent.execute({
  instruction: "Find the top 3 search results",
  output: z.object({
    results: z.array(z.object({
      title: z.string().describe("The title of the search result"),
      url: z.string().url().describe("The URL of the search result"),
      snippet: z.string().describe("A brief description or snippet"),
    })).max(3).describe("Top 3 search results"),
  }),
});

// Stream the text output
for await (const delta of streamResult.textStream) {
  process.stdout.write(delta);
}

// Get the structured output from the final result
const finalResult = await streamResult.result;
console.log(finalResult.output?.results);

// Set maxSteps to control how many actions the agent can take
await agent.execute({
  instruction: "Sign me up for a library card",
  maxSteps: 15 // Agent will stop after 15 steps if task isn't complete
});