Two protocols, one browser, the same AI. Pick the one your stack already knows.

Before we dive into differences, the things that are not a tradeoff:

• The same LLM selector fallback. Natural-language element resolution (ai-description in Selenium, Lumabyte.find / Lumabyte.click in Puppeteer) routes through one shared orchestrator: deterministic accessibility match → LLM attempt → validation → background shadow-template regeneration. Improvements to the pipeline ship to both drivers at once.
• The same LLM slot. Both drivers call the core selector-resolver slot. Configure a fast, low-latency model once and every description-based call from either client benefits.
• The same DOM-snapshot shortcut. Both expose a single-round-trip page-capture endpoint: POST /lumabyte/dom/snapshot in Selenium, Lumabyte.domSnapshot in Puppeteer. Useful for agent loops that want a full page state without three separate commands.
• The same MCP control surface. Start, stop, and inspect either driver from Claude or any MCP client using the selenium_driver_* or puppeteer_driver_* tools.
• The same host process. Both drivers live in-process with the browser — no ChromeDriver binary, no external Chromium launch, no version drift.

Same browser, same LumaBrowser instance, two different handshakes:

// npm install puppeteer-core
const puppeteer = require('puppeteer-core');

const browser = await puppeteer.connect({
  browserURL: 'http://127.0.0.1:9222',
});

// newPage spawns a purple PUP tab inside
// LumaBrowser — the automation never touches
// the user's regular tabs.
const page = await browser.newPage();
await page.goto('https://example.com');

const title = await page.title();
console.log(title);

await browser.disconnect();

# pip install selenium
from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Remote(
    "http://127.0.0.1:9515",
    options=webdriver.ChromeOptions(),
)

# Operates on whichever tab is active in
# LumaBrowser — the same tabs the user sees.
driver.get("https://example.com")

title = driver.find_element(By.CSS_SELECTOR, "h1").text
print(title)

driver.quit()

Both connections take the same wall time. The Selenium session negotiates capabilities over HTTP; the Puppeteer session negotiates via Browser.getVersion, Target.setDiscoverTargets, and Target.setAutoAttach over the WebSocket.

The LumaByte differentiator. Neither vanilla Puppeteer nor vanilla Selenium ships natural-language element resolution with a deterministic-first fallback. Both drivers expose it; the syntax shape is the one thing that differs.

const cdp = await page.target().createCDPSession();

// Opt in per-session. CDP has no first-class
// capability slot, so it's a method call.
await cdp.send('Lumabyte.configureFallback', {
  enabled: true,
});

// Tries selector first, LLM only on miss.
const r = await cdp.send('Lumabyte.find', {
  description: 'the more information link',
  selector:    'a.cta-deprecated',
});
// { selector: 'a[href*="iana.org"]',
//   strategy: 'description' }

await cdp.send('Lumabyte.click', {
  description: 'the add to cart button',
});

opts = webdriver.ChromeOptions()

# Opt in at session creation.
opts.set_capability("lumabyte:llmFallback", {
    "enabled": True,
})

driver = webdriver.Remote(
    "http://127.0.0.1:9515", options=opts,
)

# Skip CSS entirely.
link = driver.find_element(
    "ai-description",
    "the more information link",
)

# Or add an AI hint to a regular find — the
# LLM only runs if the CSS path misses.
btn = driver.find_element(
    "ai-description",
    "the add to cart button",
)
btn.click()

Both drivers collapse “DOM + accessibility + screenshot” into a single call. Different surfaces, equivalent payload.

const cdp = await page.target().createCDPSession();

const { snapshot, axTree, screenshot } =
  await cdp.send('Lumabyte.domSnapshot', {
    includeAxTree:     true,
    includeScreenshot: true,
  });

// snapshot   — DOMSnapshot.captureSnapshot
// axTree     — Accessibility.getFullAXTree
// screenshot — base64 PNG of the viewport

import requests

snap = requests.post(
    f"http://127.0.0.1:9515/session/"
    f"{driver.session_id}/lumabyte/dom/snapshot",
    json={"includeScreenshot": True},
).json()["value"]

# snap["url"], snap["title"], snap["source"],
# snap["screenshot"] (base64 PNG, optional)

The capabilities are equivalent. The decision is about ergonomics and the ecosystem you already live in.

Still unsure? Both drivers are off by default. Enable both in LumaBrowser's settings and try the same flow against each — they run concurrently on different ports without interfering with each other.

1. Settings. Open Settings → Selenium or Settings → Puppeteer, check “Start automatically when LumaBrowser launches”, then click Save & Start.

2. REST.

# Start the Selenium WebDriver server (port 9515)
curl -X POST http://localhost:3000/api/selenium/start

# Start the Puppeteer CDP server (port 9222)
curl -X POST http://localhost:3000/api/puppeteer/start

# Check both
curl http://localhost:3000/api/selenium/status
curl http://localhost:3000/api/puppeteer/status

Full references:

• Selenium Driver documentation
• Puppeteer Driver documentation
• LumaBrowser vs Selenium (drop-in WebDriver story)

Install LumaBrowser, enable either driver (or both), and point your existing client at the local port. The natural-language resolver is waiting.