Autonomous agent that navigates, clicks, types, and extracts data from any website. Monitor production. Automate workflows. Ship faster.
curl -fsSL https://nikeGunn.github.io/yeti-agent/install.sh | bash
From simple scraping to complex multi-step workflows. Yeti Agent handles it all with zero configuration.
Supports OpenAI, Anthropic, Google Gemini, Groq, Ollama, and more. The agent sees the page and decides what to do next — like a human would.
Schedule autonomous agents to continuously test critical user flows — checkout, login, search, payments. Get alerted before your users notice.
Domain allowlists, data masking, proxy support, headless mode, and security watchdogs. Built for production environments with strict compliance requirements.
Extract data into Pydantic models with type validation. Define your schema, point the agent at a page, get clean structured JSON back.
Extend the agent with your own Python functions. Register custom tools that the LLM can invoke during automation — API calls, database queries, anything.
Run locally with your own Chrome, connect to remote CDP endpoints, or use cloud browser sessions. Deploy anywhere — Docker, Kubernetes, Lambda.
Agent autonomously manages multiple tabs. Opens links in new tabs, switches context, aggregates data across pages — just like a power user.
Works as a Model Context Protocol server for Claude Desktop. Also connects to external MCP servers to extend agent capabilities.
Built on async Python with event-driven architecture. Watchdog services handle downloads, popups, dialogs, and crashes in the background.
The fastest path from idea to running agent. Works with your existing stack.
from browser_use import Agent, Browser
from browser_use import ChatOpenAI
agent = Agent(
task="Go to HackerNews and find the top 3 AI stories",
llm=ChatOpenAI(model="gpt-4o"),
)
result = agent.run_sync()
print(result.final_result())
from browser_use import Agent, Browser, BrowserProfile
from browser_use import ChatAnthropic
# Production-safe browser config
profile = BrowserProfile(
headless=True,
allowed_domains=["your-app.com", "*.your-app.com"],
)
agent = Agent(
task="""
1. Go to https://your-app.com/login
2. Login with test credentials
3. Navigate to checkout, add an item
4. Verify payment form loads correctly
5. Report any errors or broken elements
""",
llm=ChatAnthropic(model="claude-sonnet-4-20250514"),
browser=Browser(browser_profile=profile),
)
# Run on a cron schedule for continuous monitoring
result = await agent.run(max_steps=50)
from pydantic import BaseModel
from browser_use import Agent, ChatOpenAI
class ProductData(BaseModel):
name: str
price: float
rating: float
in_stock: bool
agent = Agent(
task="Extract all products from the first page",
llm=ChatOpenAI(model="gpt-4o"),
output_model_schema=ProductData,
)
# Returns typed, validated data — not messy HTML
products = await agent.run()
from browser_use import Agent, Tools, ChatGoogle
tools = Tools()
@tools.action(description="Send Slack alert when issue found")
def send_alert(message: str, severity: str) -> str:
# Your alerting logic here
slack.post(channel="#alerts", text=f"[{severity}] {message}")
return "Alert sent"
agent = Agent(
task="Monitor checkout flow and alert on any failures",
llm=ChatGoogle(model="gemini-2.0-flash"),
tools=tools,
)
From startups to enterprises, teams use Yeti Agent to automate what humans shouldn't spend time on.
Run autonomous agents 24/7 that test checkout flows, login pages, and critical user journeys. Get alerted before customers complain.
Replace brittle Selenium scripts with AI agents that adapt to UI changes. Write tests in plain English — the agent figures out the selectors.
Extract pricing, product data, and market intelligence from competitor websites. Output directly to Pydantic models for clean data pipelines.
Automate multi-step workflows across web apps — form filling, report generation, data entry. Works with any website, no API needed.
Deploy agents post-release to verify nothing broke. Smarter than screenshot diffing — agents understand context and intent.
Verify partner/vendor portals meet SLA requirements. Agents navigate, measure response times, check content, and generate compliance reports.
Event-driven architecture with watchdog services. Each component manages isolated state.
Decoupled services communicate through an event bus. Watchdogs for security, popups, downloads, DOM, and crashes all run independently.
Uses cdp-use for typed Chrome DevTools Protocol access. Full control over browser state, network, DOM, and JavaScript execution.
All data models use Pydantic v2 with strict validation. Type-safe from browser state through LLM output to your application code.
Security, observability, and reliability features built for teams that can't afford downtime.
Domain allowlists/blocklists, sensitive data masking, proxy support, permission handling, and configurable security watchdogs.
Structured logging, telemetry, GIF generation of runs, conversation export, and integration with Laminar for distributed tracing.
Docker-ready, Kubernetes-compatible, cloud browser support. Run headless in CI/CD, serverless functions, or dedicated infrastructure.
One command to install. Three lines to run.
curl -fsSL https://nikeGunn.github.io/yeti-agent/install.sh | bash