Enabling Full-stack Automated AI Debugging

Pouring fuel on the AI development fire

Download Now Get Started GitHub

Gasoline MCP: Enabling Full-stack Automated AI Debugging

Your AI Agent Is Blind to the Browser

Your AI writes code. But it can't see if that code actually works in the browser.

Console errors, failed API calls, broken WebSocket connections, slow renders — your AI has no idea any of this is happening. You're the one copying errors from DevTools, describing what you see, taking screenshots. You are the bottleneck.

Gasoline fixes this. One command gives your AI agent direct access to everything happening in your browser:

npx gasoline-mcp

Now your AI can see errors, read network responses, inspect the DOM, check performance, and verify its own fixes — without you in the loop.

Why Not Just Use DevTools MCP?

Other MCP browser tools exist. They share the same fundamental limitations.

Tools like Chrome DevTools MCP need you to launch Chrome with --remote-debugging-port. This disables Chrome's security sandbox, creates a separate browser instance, and can't observe your normal browsing session. They can't capture WebSocket traffic. They can't automate browser actions through the AI agent. They can't record your actions to generate test scripts. They're read-only views into a puppet browser.

BrowserTools MCP avoids the debug port but requires Node.js and runs three separate processes. Still no WebSocket capture, no browser automation, no action recording, no test generation.

Gasoline is different. A standard Chrome extension passively captures your real browser session — including WebSocket traffic, full request/response bodies, and every user action (clicks, form inputs, navigation, scrolls). Your AI can also act: navigate pages, execute JavaScript, inspect the live DOM. And it can turn your recorded session into Playwright tests automatically. No debug port, no separate browser, no Node.js.

This isn't incremental. It's a different architecture. Gasoline gives your AI eyes and hands on your actual browser.

The Closed Loop: Observe, Diagnose, Fix, Verify

Browser observability alone is useful. But what makes Gasoline AI-native is the closed feedback loop — your AI can observe the problem, diagnose the root cause, fix the code, and verify the fix worked, all without human intervention.

Step	What Your AI Does	Gasoline Tool
Observe	Sees a `TypeError` in the console, a 500 from the API, and a failed WebSocket reconnect	`observe` — errors, network_bodies, websocket_status
Diagnose	Correlates: the API 500 returns `{"error": "null reference"}`, the TypeError is in the response handler, the WebSocket dropped because of the same backend crash	`observe` — timeline, error_clusters
Fix	Patches the backend null reference, adds a guard in the frontend handler	Your AI's code editing tools
Verify	Refreshes the page, checks that the error is gone, the API returns 200, the WebSocket reconnects	`interact` — refresh → `observe` — errors, network_bodies

 Without Gasoline, your AI writes a fix and hopes it works. With Gasoline, it knows.

  What This Unlocks
 Autonomous Error Resolution
 Your AI sees a console error, traces it to the failing network request, reads the response body, identifies the root cause, fixes the code, and checks that the error is gone. You don't touch DevTools once.
 Test Generation from Real Sessions
 Gasoline records every user action — clicks, form inputs, navigation, scrolls. Your AI turns these into Playwright tests with network assertions. Tests based on what actually happened, not what you think happened.
 Human-Narrated UAT
 Your product manager walks through a flow and describes what should happen. Gasoline captures every action. Your AI turns it into a Playwright test — no developer required. Mid-flow changes ("oh, also test the discount code") just work because the recording is live. Try doing that with a hand-written Playwright script.
 Regression Detection Across Sessions
 Save performance snapshots. Compare them later. Your AI spots that LCP regressed from 1.2s to 2.8s after your last deploy — and tells you which change caused it.
 Security and Accessibility Audits
 Your AI runs WCAG accessibility checks and security audits (exposed credentials, PII in responses, missing headers) against the live page. Exports results as SARIF for CI integration.
 WebSocket Debugging
 Most tools can't see WebSocket traffic at all. Gasoline captures connection lifecycle and message payloads from the moment the page loads — even connections created before the extension's inject script runs.
 Live DOM Inspection
 Your AI queries the live page with CSS selectors. "Is the modal visible?" "What does the error banner say?" "Is the submit button disabled?" Structured data, not screenshots.
 
  Architecture
 [ Your Browser ] → [ Extension ] → [ localhost:7890 ] → [ Any MCP Agent ]
                                             ↓
                                    Everything stays local
  The extension passively captures your browser activity
 Data flows to a local Go server — single binary, zero dependencies
 Your AI reads it via MCP (stdio transport)
 Nothing leaves your machine
 
 
  Enterprise Safe by Design
    No browser data is ever shared with any AI provider. Gasoline runs entirely on your machine:
  Localhost only — the server binds to 127.0.0.1, unreachable from the network
 No cloud, no accounts, no telemetry — nothing phones home, ever
 Auth headers stripped — tokens and API keys are automatically redacted from captured data
 Single binary — Go. No Node.js, no node_modules, no supply chain risk
 Open source (AGPL-3.0) — audit every line your security team cares about
 
 Safe for regulated environments, proprietary codebases, and enterprise security policies.
 Full Security Details →
 
 
 
  Works With Every MCP Agent
 Gasoline implements the open Model Context Protocol. If your agent speaks MCP, Gasoline fuels it:
  Claude Code — .mcp.json in project root
 Cursor — ~/.cursor/mcp.json
 Windsurf — ~/.codeium/windsurf/mcp_config.json
 Claude Desktop — OS-specific config
 Zed — ~/.config/zed/settings.json
 Gemini CLI — ~/.gemini/settings.json
 OpenCode — ~/.config/opencode/opencode.json
 Antigravity — ~/.gemini/antigravity/mcp_config.json
 VS Code + Continue — ~/.continue/config.json
 
 Not tied to any vendor. Switch AI tools without changing your debugging setup.
 
  Performance
  < 0.1ms overhead — per console intercept. Your browsing stays fast.
 20MB memory cap — the extension never bloats your browser.
 Zero network calls — the binary never connects to the internet.
 4-second cold start — MCP server is ready before your AI's first tool call.
 
 
    Ready to Fire It Up?
 Get Started