My previous blog in my automation series was a first step on how to:

  • Install Vibium
  • Record a login scenario
  • Visualize recorded test

Refreshing, Vibium is an open source automation tool, written in Go with JS/TS, Python, and Java client libraries.

In this blog post, we will go through:

Table of Contents

The Protocol Bet: Why WebDriver BiDi

Vibium's design isn't a CLI choice, it's the protocol used underneath.

Browser automation has gone through three protocol generations:

WebDriver (2004–present): Selenium’s foundation. Uses HTTP + JSON with a request/response model that controls browsers in a one-way manner: the browser only responds when asked.

Chrome DevTools Protocol (2017–present): CDP swapped HTTP for WebSockets, and that unlocked bidirectional communication: the browser sends and receives events in real time like logs, network activity, and DOM changes. Puppeteer and Playwright are both built on CDP, but it is Chrome-internal.

WebDriver BiDi (2021–present): The W3C's answer to "what if we kept CDP's bidirectional WebSocket model but made it an actual cross-vendor standard?".

And that's the main reason I think Vibium is built directly on WebDriver BiDi.

Below is the diagram presenting these interactions:

Diagram instructions

Here our browser can push events, like messages, and when a page throws an error, WebDriver BiDi can receive them.

Browser support is still maturing with:

  • Chrome/Chromium supports BiDi via ChromeDriver
  • Firefox has native support
  • Edge inherits Chromium's support
  • Safari's support is in development

The tooling ecosystem is converging on this protocol, not just Vibium.

System Architecture

Vibium ships as a single compiled binary. This indicates that:

  • You can invoke it directly from the CLI.
  • You can use the MCP server and register it with an agent host.

Both surfaces funnel into the same internal command engine, which talks to Chrome over a BiDi WebSocket connection it manages internally.

Both methods target the Vibium binary, which interacts with Chrome using WebDriver BiDi over WebSocket.

integrations

Two details worth calling out:

  • Vibium uses the same core engine for CLI commands, MCP tools, and language clients. Client libraries connect to the binary through WebSocket instead of rebuilding browser automation logic.

  • Vibium can be installed as an agent skill via
    npx skills add https://github.com/VibiumDev/vibium --skill vibe-check
    allowing AI coding agents to discover and use it through a SKILL.md definition and automatically resolve the required binary.

Daemon Mode

Daemon mode improves performance. Instead of starting a new browser for every command, it keeps a background browser alive and reuses it across all commands.

vibium go https://example.com
vibium map
vibium click @e1

Enter fullscreen mode Exit fullscreen mode

So the browser starts once, keeping agent workflows faster. The daemon can also be manually controlled with start, status, and stop commands, which is useful for CI environments.

Using Vibium MCP and SKILLs

Before moving on to the AI integration with Vibium I wanted to clarify the difference between MCP and Skills because there is slight confusion

MCP (Model Context Protocol) is the runtime used by agents to execute tools. It controls the communication between agents and binaries.

  • SKILL.md is definition on how to do things it is a file that describes a tool used by MCP so MCP reads SKILL.md to know how to expose and invoke the skill.

In short: MCP execute using skills, and a skill tells MCP how execute.

To use a skill defined via SKILL.md, you first need to register it:

npx skills add https://github.com/VibiumDev/vibium --skill vibe-check

Enter fullscreen mode Exit fullscreen mode

using skills

Once added, I used the vibe-check skill to automate a simple scenario.
I use this prompt within GitHub Copilot in agent mode

use the vibe-Check skill to open https://opensource-demo.orangehrmlive.com/web/index.php/auth/login
and login using:
Username: Admin
Password: admin123

Enter fullscreen mode Exit fullscreen mode

Reliability vs Speed with AI Agents

Using Vibium with AI is very interesting but this comes with a balance between speed and reliability.

At first glance it seems very fast and smart, it understands what the user wants using simple words and execute actions based on that.
But in practical things can get messy

It true that AI can know the UI elements with a faster setup but as you can seen a simple login flow still struggles, the agent got stuck and couldn't identify the element from the first attempts.
The interesting part is how it behaves using a quickly recover,
it true that it gives more adaptability but also a less deterministic behavior.

Closing

Betting on WebDriver BiDi aligns with a cross-vendor standard for browser automation. Vibium is moving toward a full AI-driven system built on three layers:

  • Sense (Retina): Browser-level observation via a Chrome extension
  • Think (Cortex): Memory, reasoning, and navigation planning
  • Act (Vibium): Execution using BiDi

Vibium is early, maturing these layers could move browser automation from "sometimes works" to production-ready.

Explore the CLI reference, BiDi explainer, and roadmap in the repo to dig deeper.

What’s your biggest bottleneck with browser automation today? Drop your thoughts or check out the repo to start experimenting!