Smooth CLI - Browser Agent API for AI Agents

TL;DR

TL;DR: Smooth CLI is a browser agent API that gives AI agents a natural language interface for web automation instead of low-level click/type/scroll actions, making it 5x faster and 7x cheaper than traditional browser tools.

Source and Accuracy Notes

• Project page: smooth.sh
• Documentation: docs.smooth.sh
• HN launch thread: news.ycombinator.com/item?id=46901233
• License: Proprietary (commercial SaaS)
• Pricing: Free tier with welcome credits, Starter $50/month, Growth $500/month
• Source last checked: 2026-06-17

What Is Smooth CLI?

Smooth CLI solves a fundamental problem with current browser automation tools for AI agents: they expose low-level actions like click(x=342, y=128), type("search query"), and scroll(down=500). This forces your agent to think about button positions instead of your actual goals.

From the official docs:

Current browser tools for agents (like —chrome, Playwright MCP, agent-browser) all make the same mistake: they expose low-level actions like click, type, and scroll. This forces your agent to think about button positions instead of your actual goals.

Smooth takes a different approach. Instead of hundreds of low-level tools, it gives agents a simple natural language interface. Your agent says what it wants, and Smooth figures out how to do it.

The Three Problems Smooth Solves

| Problem | Why It Matters | |---------|----------------| | Slow and expensive | Using a massive model to click buttons is wasteful. Every action costs tokens and time. | | Context pollution | Every click and keystroke fills up the context window with UI noise instead of your task. | | Wrong expertise | General-purpose models aren’t trained to handle iframes, shadow DOMs, and the messy reality of websites. |

Performance Claims

Smooth claims significant improvements over traditional browser automation:

• 20x faster — A specialized model handles the clicking so your agent can focus on thinking
• 5x cheaper — Stop using 1T+ parameter models and burning tokens on UI navigation
• 92% WebVoyager score — State-of-the-art reliability benchmark
• 7x cheaper than browser-use — Uses small and efficient AI models

Setup Workflow

Step 1: Install the CLI

pip install smooth-py

Step 2: Configure Your API Key

Get your API key from app.smooth.sh, then run:

smooth config --api-key YOUR_API_KEY

Step 3: Add to Claude Code

For Claude Code integration, use the plugin marketplace:

/plugin marketplace add circlemind-ai/smooth-sdk
/plugin install smooth-browser

Alternatively, you can copy the SKILL.md file directly to your agent’s skill folder at ~/.claude/skills/.

Step 4: Give Claude a Task

Ask Claude to do something on the web. It will use Smooth automatically:

Find a one-way flight from London to NY leaving tomorrow

You can also give Claude complex goals. The skill teaches Claude how to break them into subtasks and distribute them across multiple concurrent browser sessions automatically.

API Usage

Authentication

All API endpoints require authentication via the apikey header:

curl -X POST "https://api.smooth.sh/api/v1/task" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task": "Go to hacker news and get the top story"}'

Simple Tasks

Run one-shot tasks that execute and return results:

# Submit a task
curl -X POST "https://api.smooth.sh/api/v1/task" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task": "Go to hacker news and get the top 5 stories"}'

# Response: {"r": {"id": "task_abc123", "status": "running", ...}}

# Poll for results
curl -X GET "https://api.smooth.sh/api/v1/task/task_abc123" \
  -H "apikey: YOUR_API_KEY"

# Response: {"r": {"id": "task_abc123", "status": "done", "output": "..."}}

Session Workflows

For multi-step workflows, create a session and send actions:

# Create a session (task=null)
curl -X POST "https://api.smooth.sh/api/v1/task" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"task": null, "url": "https://example.com"}'

Key Features

P2P Tunnel

Route traffic through your machine to avoid captchas, access geo-restricted content, and reach localhost services.

Stay Logged In

Let your agent access your accounts without re-authenticating. Smooth persists cookies and authentication across tasks using browser profiles.

Extract Data

Pull structured information from any webpage. Perfect for scraping behind logins or automating data collection workflows.

Upload and Download Files

Pass files to tasks and download results. Useful for form filling, document processing, and automated workflows.

Watch Your Agent Work

Real-time monitoring and observability for debugging and verification.

Pricing

Smooth offers three tiers:

Free Tier

• Free welcome credits
• 2 concurrent browsers
• $0.005/step

Starter — $50/month

• Includes $50 API credits each month
• 10 concurrent browsers
• Custom proxy support
• Persistent sessions
• Stealth mode
• $0.005/step

Growth — $500/month

• Everything in Starter
• Includes $500 API credits each month
• 50 concurrent browsers
• 24/7 support from the founders

Enterprise — Custom pricing with unlimited concurrent browsers, single tenant, BYOC, BAA agreements, SSO and SAML authentication.

Practical Evaluation Checklist

When evaluating Smooth CLI for your AI agent workflows:

• [ ] Token efficiency — Does natural language interface reduce token usage compared to click/type/scroll?
• [ ] Reliability — 92% WebVoyager score is impressive, but test with your specific use cases
• [ ] Cost — $0.005/step adds up. Calculate expected monthly cost based on your task volume
• [ ] Latency — “5x faster” claim needs verification with your actual workflows
• [ ] Security — End-to-end encryption and zero-trust access controls are mentioned, verify compliance requirements
• [ ] Integration — Claude Code plugin is ready, but check if your agent framework is supported
• [ ] Localhost access — P2P tunnel feature is critical if you need to test local dev environments

Security Notes

Smooth mentions enterprise-grade security features:

• End-to-end encryption
• Zero-trust access controls
• Isolated browser environments with no permissions by default
• Enterprise tier offers single tenant, BYOC (Bring Your Own Cloud), and BAA agreements

However, you’re sending browser automation tasks to a third-party API. Consider:

• Data sensitivity — Are you comfortable with Smooth seeing your web automation traffic?
• Authentication tokens — Persistent sessions mean Smooth stores your cookies and auth state
• Compliance — Check if Smooth meets your industry’s compliance requirements (HIPAA, SOC 2, etc.)
• On-premise options — Enterprise tier mentions BYOC, but self-hosted option is not clearly documented

For highly sensitive workflows, evaluate whether the convenience outweighs the security trade-offs.

FAQ

Q: How does Smooth compare to Playwright MCP or Puppeteer?

A: Playwright and Puppeteer expose low-level browser automation primitives (click, type, scroll). Smooth abstracts this into natural language tasks. Instead of writing code to click specific coordinates, you say “find the cheapest flight” and Smooth handles the navigation. This reduces token usage and context pollution for AI agents.

Q: Can Smooth access localhost or geo-restricted content?

A: Yes. Smooth includes a P2P tunnel feature that routes traffic through your machine. This lets your agent access localhost services during development and bypass geo-restrictions or captchas that block cloud IPs.

Q: Does Smooth work with agents other than Claude Code?

A: Yes. While the Claude Code plugin is the most documented integration, Smooth provides docs for OpenClaw and generic agent setups. Any agent that can make HTTP requests or use MCP tools can integrate with Smooth’s REST API.

Q: What happens if a task fails or gets stuck?

A: Smooth provides task status polling. You can check task status via the API and cancel running tasks if needed. The docs mention a polling mechanism for checking results and events.

Q: Is there a self-hosted option?

A: The Enterprise tier mentions BYOC (Bring Your Own Cloud) and single tenant options, but there’s no clearly documented self-hosted deployment. Contact Smooth sales for enterprise deployment options.

Q: How does the pricing work?

A: You pay $0.005 per step (browser action). The Starter and Growth tiers include monthly API credits ($50 or $500 respectively). Free tier comes with welcome credits to test the service.

Conclusion

Smooth CLI represents a shift in how AI agents interact with the browser. Instead of forcing agents to think like humans clicking buttons, it lets them express intent in natural language and handles the browser automation underneath.

The 92% WebVoyager score and claims of 5x faster, 7x cheaper performance are compelling, but you should validate these with your specific use cases. The pricing model ($0.005/step) is transparent but can add up quickly for high-volume automation.

For developers building AI agents that need browser access — whether for research, form filling, QA testing, or workflow automation — Smooth CLI is worth evaluating. The Claude Code integration is particularly smooth (pun intended), and the ability to stay logged in and access localhost makes it practical for real-world workflows.

The main trade-off is security and data privacy. You’re sending browser automation tasks to a third-party API, which may not be suitable for highly sensitive workflows. For most development and automation use cases, however, the convenience and efficiency gains likely outweigh this concern.