Smooth CLI - Browser Built for AI Agents

TL;DR

TL;DR: Smooth CLI replaces low-level browser automation tools (click, type, scroll) with a natural-language interface. Instead of telling an agent to “click the third button,” you tell it what you want and Smooth figures out the rest — cutting token costs and latency significantly.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: smooth.sh
• Documentation: docs.smooth.sh
• HN launch thread: news.ycombinator.com/item?id=46901233 — 109 points, Feb 2026
• License: Proprietary (free tier available, no open-source license confirmed)

What Is Smooth?

Smooth CLI is a browser built specifically for AI agents. The core problem it solves: existing browser automation tools expose low-level primitives like click, type, scroll, and goto — forcing a large language model to think about button positions and DOM structure instead of the actual goal.

From the official docs:

“AI agents like Claude Code are powerful, but they’re mostly stuck in the terminal. Meanwhile, most valuable work happens in the browser. Current browser tools for agents 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.”

The result is three compounding problems:

| Problem | Impact | |---|---| | 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 the context window with UI noise instead of your task. | | Wrong expertise | General-purpose models are not trained to handle iframes, shadow DOMs, and messy real-world websites. |

Smooth flips this: your agent describes what it wants in plain language, and Smooth’s specialized model handles the DOM interaction.

Setup Workflow

Step 1: Install the SDK

Smooth provides Python and TypeScript SDKs with identical interfaces:

pip install smooth-py

npm install @circlemind-ai/smooth-ts

Step 2: Get an API Key

Sign up at app.smooth.sh to receive free welcome credits. No credit card is required.

Step 3: Run Your First Task

from smooth import SmoothClient

smooth_client = SmoothClient(api_key="cmzr-YOUR_API_KEY")
task = smooth_client.run(
    "Go to google flights and find the cheapest flight from London to Paris today"
)

print(f"Live URL: {task.live_url()}")
print(f"Agent response: {task.result()}")

import { SmoothClient } from "@circlemind-ai/smooth-ts";

const client = new SmoothClient({
  api_key: "cmzr-YOUR_API_KEY",
});

const task = await client.run({
  task: "Go to google flights and find the cheapest flight from London to Paris today",
});

console.log("Live URL:", await task.live_url());
console.log("Agent response:", await task.result());

For direct API usage:

curl -X POST https://api.smooth.sh/api/v1/task/smooth \
          -H "apikey: cmzr-YOUR_API_KEY" \
          -H "Content-Type: application/json" \
          -d '{"max_steps": 32, "task": "your_task_description"}'

Step 4: Connect to Claude Code or Other Agents

Smooth provides integrations for Claude Code, OpenClaw, and any agent that supports command-line browser tools. See the official setup guide for your specific agent.

Deeper Analysis

Architecture

Smooth runs a specialized browser agent locally that receives natural-language task descriptions via the SDK. The agent uses a purpose-built model for DOM interaction rather than a general-purpose LLM, which is the source of the token and speed improvements.

Key Features

• Natural language interface — agents describe goals, not actions
• P2P Tunnel — route browser traffic through your local machine to bypass CAPTCHAs, access geo-restricted content, and reach localhost services
• Persistent profiles — maintain logged-in sessions across tasks
• Structured output — extract JSON data directly from pages
• File upload and download — pass files to tasks and receive results
• Live share — watch the agent work in real time
• Video recording — record the entire agent run
• Proxy support — use custom proxies for regional or privacy requirements
• Zero Data Retention — optional mode where browsing data is not stored

Performance Claims

The docs claim 20x faster and 5x cheaper compared to low-level automation approaches, achieved by using a specialized model for DOM operations instead of a general-purpose LLM. These figures are from the official docs — I have not independently verified them.

Practical Evaluation Checklist

• [ ] Successfully installed Python SDK (pip install smooth-py)
• [ ] Created account and retrieved API key from app.smooth.sh
• [ ] Ran a simple task (e.g. page navigation, data extraction)
• [ ] Verified live_url() provides a shareable live view
• [ ] Tested structured output extraction from a dynamic page
• [ ] Attempted a multi-step workflow (e.g. login + scrape behind auth wall)
• [ ] Checked pricing page for any usage limits on free tier

Security Notes

• Smooth runs in an isolated environment with no permissions by default
• Zero Data Retention mode is available for sensitive workflows — browse the docs for details
• API key is required for all API calls; treat it like a password

FAQ

Q: Does Smooth run entirely in the cloud or locally? A: The browser agent runs via Smooth’s infrastructure, accessed through the SDK. The P2P Tunnel feature lets you route traffic through your local machine for localhost access and geo-restricted content.

Q: How does this compare to Playwright MCP or browser-use tools? A: Playwright MCP and similar tools expose low-level actions (click, type, goto). Smooth uses a natural-language interface — you describe what you want, not the steps to get there. This reduces token usage and context pollution significantly.

Q: Is there a free tier? A: Yes — app.smooth.sh provides free welcome credits with no credit card required. See the pricing page for details on what is included.

Q: Can I self-host Smooth? A: The documentation focuses on the cloud API access model. Self-hosting options are not prominently documented as of this writing.

Q: What agents is Smooth compatible with? A: Official integrations exist for Claude Code and OpenClaw. A generic CLI interface allows connection to any agent supporting command-line browser tools.

Conclusion

Smooth CLI addresses a real bottleneck in AI agent workflows: the mismatch between goal-oriented agents and button-level browser automation. By giving agents a natural-language browser interface, it cuts token waste and context pollution — the two biggest silent taxers on agent performance and cost.

If you are building agentic workflows that interact with the web, the low-level click/type approach burns tokens fast. Smooth is worth evaluating as a drop-in replacement, especially for agents working on multi-step web tasks like research, scraping, form filling, and QA testing.

Next steps:

• Get your free API key at app.smooth.sh
• Read the full CLI documentation
• Browse use cases and guides to see real-world examples