🤖 Vibium: Browser Automation for AI Agents - A Hands-On Review

Introduction

With AI coding assistants like Claude Code becoming increasingly popular, there's growing demand for tools that allow AI agents to interact with browsers. Vibium is a new project in this space, positioning itself as "browser automation infrastructure built for AI agents".

The project makes some interesting design choices: built on the WebDriver BiDi standard rather than proprietary protocols, zero configuration required, and an MCP server baked in from day one. I took Vibium for a hands-on test drive to see how it works in practice.

The Tech

• Vibium GitHub Repository
• WebDriver BiDi Protocol

Vibium is a lightweight Go binary (~10MB) that handles three core responsibilities:

• Browser lifecycle management - Downloads and launches Chrome for Testing automatically
• WebDriver BiDi proxy - Routes commands to the browser via WebSocket
• MCP server - Exposes browser control to AI agents via stdio interface

The design philosophy centers on developer joy - browser visible by default (so you can see what the AI is doing), zero config to get started, and sensible defaults throughout.

Installation

Getting started is genuinely frictionless:

# JavaScript/TypeScript
npm install vibium
 
# Python
pip install vibium
 
# For Claude Code integration
claude mcp add vibium -- npx -y vibium

The package automatically downloads Chrome for Testing to platform-specific cache directories - no manual browser setup required.

Let's See the Code

Here's a practical example demonstrating Vibium's API using the-internet.herokuapp.com - a purpose-built testing playground:

const fs = require('fs');
const { browserSync } = require('vibium');
 
// Launch browser (visible by default)
const vibe = browserSync.launch();
 
// Navigate to the test site
vibe.go('https://the-internet.herokuapp.com/');
 
// Take a screenshot (returns PNG Buffer)
const screenshot = vibe.screenshot();
fs.writeFileSync('screenshot.png', screenshot);
 
// Find elements using CSS selectors
const heading = vibe.find('h1.heading');
console.log(heading.info.text);  // "Welcome to the-internet"
console.log(heading.info.tag);   // "h1"
console.log(heading.info.box);   // { x, y, width, height }
 
// Run JavaScript in the browser
const title = vibe.evaluate('return document.title');
console.log(title);  // "The Internet"
 
// Navigate to the inputs page
vibe.go('https://the-internet.herokuapp.com/inputs');
 
// Find input and type - note: type() is on the ELEMENT
const input = vibe.find('input');
input.type('12345');
 
// Verify with evaluate()
const value = vibe.evaluate("return document.querySelector('input').value");
console.log(value);  // "12345"
 
// Navigate to dynamic content demo
vibe.go('https://the-internet.herokuapp.com/add_remove_elements/');
 
// Click a button
const button = vibe.find('button');
button.click();
 
// Auto-wait: find() polls for elements that appear dynamically
const newElement = vibe.find('.added-manually');
console.log(newElement.info.text);  // "Delete"
 
// Clean up
vibe.quit();

API Overview

Browser methods:

• go(url) - Navigate to URL
• find(selector, { timeout }) - Find element (auto-waits)
• screenshot() - Capture viewport as PNG Buffer
• evaluate(script) - Run JavaScript in browser
• quit() - Close browser

Element methods:

• click() - Click the element
• type(text) - Enter text
• text() - Get text content
• getAttribute(name) - Get attribute value
• boundingBox() - Get position/size

Launch options:

// Headless mode (no visible browser)
const vibe = browserSync.launch({ headless: true });

Sync and Async APIs

Both synchronous and asynchronous APIs are available:

// Async API
const { browser } = await import('vibium');
const vibe = await browser.launch();
await vibe.go('https://the-internet.herokuapp.com/');
const el = await vibe.find('h1', { timeout: 5000 });
await el.click();
await vibe.quit();

# Python sync
from vibium import browser_sync
vibe = browser_sync.launch()
vibe.go("https://the-internet.herokuapp.com/")
vibe.quit()
 
# Python async
import asyncio
from vibium import browser
 
async def main():
    vibe = await browser.launch()
    await vibe.go("https://the-internet.herokuapp.com/")
    await vibe.quit()
 
asyncio.run(main())

AI Agent Integration

The standout feature is the MCP (Model Context Protocol) server. Once configured, Claude Code can control browsers directly:

claude mcp add vibium -- npx -y vibium

Available MCP tools:

This enables natural language browser automation: "Go to Hacker News, find the top story, and tell me what it's about" - which the AI can execute step by step with visual feedback.

What Works Well

• Zero configuration - Downloads Chrome automatically, no PATH setup, no driver management. It genuinely just works.
• AI-first design - MCP server built-in for seamless Claude Code integration.
• Standards-based - Built on WebDriver BiDi, not proprietary protocols.
• Browser visible by default - You can watch what the AI is doing, which builds trust and aids debugging.
• Auto-wait on find() - Elements are polled automatically, handling dynamic content.
• Element metadata - Returns tag name, text content, and bounding box - useful context for agents.
• Simple API - About 10 methods total. Easy to learn.
• Cross-platform - Works on Linux, macOS (Intel + Apple Silicon), and Windows.

Current Limitations

As an early-stage project (V1 just shipped), there are some limitations to be aware of:

• CSS selectors only - No getByRole, getByText, or other semantic locators yet
• No assertions - This is browser automation, not a test framework
• Limited element interactions - Basic click/type supported, advanced interactions (drag-drop, file upload) not yet implemented
• Chrome only - Firefox and Edge support planned for V2

These are known limitations that the team is actively working on - check the roadmap for planned improvements.

The V2 Vision: Sense → Think → Act

The team has an ambitious roadmap following a robotics-inspired architecture:

V1 shipped Act (Clicker). V2 adds Sense and Think.

Planned V2 features:

• AI-powered locators - Natural language element finding (vibe.find("the blue submit button"))
• Video recording - Capture sessions as MP4/WebM
• Network tracing - Request inspection and HAR export
• Cortex memory layer - Persistent navigation graphs across sessions
• Java client - For enterprise users

The AI-powered locators are particularly interesting - they could make element selection much more robust for AI agents.

Vibium vs Playwright: Different Tools, Different Jobs

Use Vibium when: You need an AI agent to perform browser tasks - web scraping, form filling, data extraction, automated workflows.

Use Playwright when: You need robust test automation with assertions, parallelization, CI integration, and comprehensive reporting.

Conclusion

Vibium is a focused tool that does one thing well: giving AI agents simple, reliable browser control. For that specific use case, it delivers a clean API that works out of the box.

The MCP integration with Claude Code is the headline feature - it's clearly what the project was built for. The zero-config installation and visible-by-default browser make for a great first experience.

If you're building AI agents that need to interact with browsers, Vibium is worth exploring. If you're doing traditional test automation, stick with Playwright or Cypress - they're designed for that job.

My take: A promising early-stage project with a clear vision. The V2 roadmap shows ambition, and the team is responsive to feedback. Worth watching as it matures.

Try It Yourself

npm install vibium
 
node -e "
const { browserSync } = require('vibium');
const vibe = browserSync.launch();
vibe.go('https://the-internet.herokuapp.com/');
console.log(vibe.find('h1').text());
vibe.quit();
"

Resources

• Vibium GitHub Repository
• Getting Started Tutorial
• V2 Roadmap
• WebDriver BiDi Specification