ChaosBull MCP
Allows AI agents to block or simulate outages of Google Analytics requests during browser tests, verifying that core application functionality remains intact without analytics.
Allows AI agents to block or simulate failures of Hotjar tracking requests to test whether the app remains functional when third-party analytics tools are unavailable.
Allows AI agents to simulate payment gateway outages by intercepting payment API requests and forcing error responses, such as when Stripe is down, to verify fallback UI and resilience.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ChaosBull MCP Force a 503 on the checkout API and verify the fallback banner appears."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ChaosBull MCP 🐂💥
Dynamic browser network chaos engineering & resilience testing for AI agents and developers.
Your tests run on perfect networks. Your users don't. ChaosBull lets AI agents unleash controlled network havoc on web pages to verify they don't break in production.
📖 New to Chaos Engineering or looking for an intuitive explanation? Check out our First Principles Guide for Non-Tech Minds explaining how ChaosBull works using everyday analogies.
⚡ Why ChaosBull?
Continuous Integration (CI) and local dev environments have flawless connectivity:
APIs respond in 15 milliseconds.
CDNs never glitch.
Cellular handoffs and elevator dead zones do not exist.
Then your code ships to real humans — and production breaks when a payment gateway returns a 503, analytics scripts hang and block page hydration, or a mobile user enters an underground tunnel mid-checkout.
AI agents writing tests or performing QA normally have no dynamic control over the network layer inside real browser sessions. They can't ask:
🙈 Does the checkout page display a polite fallback banner if Stripe is down?
🙈 Does the dashboard show skeleton loaders when the API takes 3 seconds?
🙈 Does the application function normally if third-party tracking scripts are blocked?
🙈 What happens if the network drops right after the user taps "Place Order"?
🙈 Does the app automatically retry and recover from transient 503 errors?
ChaosBull gives AI agents and automated workflows the power to charge into your network layer, sabotage connections on demand, and assert whether your app survives.
Related MCP server: AI Web Tester
🛠️ The 8 ChaosBull Superpowers
┌──────────────────────────────────────────────┐
│ ChaosBull Engine │
└──────────────────────┬───────────────────────┘
│
┌──────────────────┬──────────────┴─────┬──────────────────┐
│ │ │ │
▼ ▼ ▼ ▼
API Failures Latency & Jitter Mid-Flight Drops Resource Blocks
(500/502/503/etc) (Slow 3G/Timeouts) (Aborted Streams) (Ads/Analytics)
│ │ │ │
▼ ▼ ▼ ▼
OS Network Drops Transient Retries Corrupted Payloads Resilience Verdict
(DNS/EAI_AGAIN/Abort) (Fail N -> Succeed) (Truncated/Bad JSON) (Pass/Fail Score)1. simulate_api_failure
Intercepts requests matching a URL pattern and forces them to return an error HTTP status code. Verifies if the frontend renders a fallback UI element instead of crashing.
{
"url": "https://example.com/checkout",
"intercept_pattern": "**/api/payment**",
"status_code": 503,
"response_body": "{\"error\":\"Service Unavailable\"}",
"fallback_selector": ".error-boundary",
"wait_ms": 2000
}Output:
{
"url": "https://example.com/checkout",
"intercept_pattern": "**/api/payment**",
"intercepted_count": 1,
"intercepted_requests": [
{ "url": "https://example.com/api/payment", "method": "POST", "status": 503 }
],
"fallback_found": true,
"fallback_selector": ".error-boundary",
"page_state": {
"page_errors": [],
"console_errors": ["Failed to load resource: the server responded with a status of 503"]
},
"wait_time_ms": 2000
}2. inject_latency
Injects deliberate delays and jitter into matching requests to simulate slow mobile connections, saturated links, or overloaded backend services. Checks if loading skeletons appear.
{
"url": "https://example.com/dashboard",
"intercept_pattern": "**/api/stats**",
"latency_ms": 3000,
"jitter_ms": 500,
"loading_selector": ".skeleton-card"
}Output:
{
"url": "https://example.com/dashboard",
"intercept_pattern": "**/api/stats**",
"intercepted_count": 1,
"intercepted_requests": [
{ "url": "https://example.com/api/stats", "method": "GET", "delay_ms": 3218 }
],
"loading_state_found": true,
"page_state": { "page_errors": [], "console_errors": [] },
"load_time_ms": 3410
}3. block_resources
Aborts matching requests outright to simulate third-party outages (e.g., Google Analytics, Tag Manager, Hotjar, external CDN font providers). Asserts whether the core app UI remains functional.
{
"url": "https://example.com",
"block_patterns": ["**/analytics**", "*.doubleclick.net/**", "**/tracker.js"],
"core_content_selector": "#main-app-content",
"wait_ms": 2000
}Output:
{
"url": "https://example.com",
"block_patterns": ["**/analytics**", "*.doubleclick.net/**", "**/tracker.js"],
"blocked_count": 3,
"blocked_urls": ["https://example.com/analytics.js", "https://stats.doubleclick.net/collect"],
"core_content_found": true,
"page_state": { "page_errors": [], "console_errors": [] },
"wait_time_ms": 2000
}4. simulate_network_drop
Simulates sudden connection loss mid-stream (like entering a subway tunnel) by aborting in-flight requests after a defined delay.
{
"url": "https://example.com/cart",
"intercept_pattern": "**/api/order/submit**",
"drop_after_ms": 400,
"fallback_selector": ".offline-alert",
"wait_ms": 2000
}5. trigger_system_network_error
Fails requests with low-level OS/protocol socket errors: addressunreachable (DNS failure), connectionaborted (reset by peer), accessdenied (firewall blocks), or aborted.
{
"url": "https://example.com/feed",
"intercept_pattern": "**/api/**",
"error_code": "addressunreachable",
"fallback_selector": ".dns-fail-banner",
"wait_ms": 1500
}6. simulate_stateful_failure
Fails the first $N$ requests with an error status (e.g., 503), then allows subsequent requests to succeed. Verifies if client-side retry/backoff mechanisms recover automatically without user intervention.
{
"url": "https://example.com/reports",
"intercept_pattern": "**/api/generate**",
"http_status": 503,
"failure_count": 2,
"success_payload": "{\"status\":\"ready\",\"reportId\":\"12345\"}",
"fallback_selector": ".retry-indicator",
"wait_ms": 3000
}7. inject_response_corruption
Feeds damaged payloads to the browser:
malformed_json: Incomplete or broken JSON objects.length_mismatch:Content-Lengthheader advertises 99,999 bytes, but only sends 20 bytes.truncated: Payload severed attruncate_at_byte.
Tests if client JSON parsers crash the JavaScript runtime or fail cleanly.
{
"url": "https://example.com/profile",
"intercept_pattern": "**/api/user**",
"corruption_type": "malformed_json",
"fallback_selector": ".data-error-notice",
"wait_ms": 2000
}8. assert_chaos_handled
The ultimate resilience test. Injects failure into target endpoints and executes an automated inspection:
Did unhandled JavaScript exceptions occur? (
page_errors)Did console errors cascade out of control?
Did the designated fallback/error recovery UI appear?
Calculates
chaos_survived: true | false.
{
"url": "https://example.com/pricing",
"intercept_pattern": "**/api/tiers**",
"http_status": 500,
"expected_fallback_selector": ".error-fallback-container",
"wait_ms": 2000
}Output:
{
"url": "https://example.com/pricing",
"intercept_pattern": "**/api/tiers**",
"http_status": 500,
"unhandled_exceptions": [],
"console_errors": ["Failed to load resource: status 500"],
"fallback_ui_detected": true,
"expected_fallback_selector": ".error-fallback-container",
"chaos_survived": true,
"wait_time_ms": 2000
}🔌 1-Minute Setup
You do not need to manually clone or install anything. Just add ChaosBull to your AI assistant:
Cursor, Claude Desktop, Antigravity & Windsurf
Add this to your MCP configuration (claude_desktop_config.json, .cursor/mcp.json, or IDE MCP settings):
{
"mcpServers": {
"chaosbull": {
"command": "npx",
"args": ["-y", "chaosbull"]
}
}
}Cursor UI Shortcut: Go to Settings ➔ MCP ➔ Add New MCP Server:
Name:
chaosbullType:
commandCommand:
npx -y chaosbull
That's it! Your AI assistant will automatically launch ChaosBull on demand and gain access to all 8 resilience tools.
💻 Development & Testing
# Install dependencies
pnpm install
# Install Playwright browser
pnpm exec playwright install chromium
# Build TypeScript
pnpm run build
# Run automated smoke suite
pnpm test📄 License
MIT © ChaosBull
Available Tools
8 toolsassert_chaos_handledA
Opens the browser, navigates to the application, and injects a chaos HTTP status into all matching requests. Checks: did the app show fallback UI, were there unhandled exceptions, and did it survive? Use to answer: is the app chaos-resilient — does it show a recovery UI without throwing exceptions?
Inputs: url (required), intercept_pattern (required), wait_ms, headless, +6 more.
block_resourcesA
Opens the browser, navigates to the user application, and blocks requests to specified URL patterns. Simulates third-party outages (analytics, CDNs, tracking) and verifies core content integrity. Use to answer: does the app still load and function if Google Analytics or a CDN is down?
Inputs: url (required), block_patterns (required), wait_ms, headless, +5 more.
inject_latencyA
Opens the browser, navigates directly to the user application, and adds artificial delay to requests matching a URL pattern. Observes whether loading indicators or skeleton screens appear. Use to answer: does the app show loading states when the API takes 3 seconds? Does it time out gracefully?
Inputs: url (required), intercept_pattern (required), headless, viewport, +6 more.
inject_response_corruptionA
Opens the browser, navigates to the application, and intercepts requests matching a URL pattern to return a malformed or corrupted response. Simulates protocol/transport level corruption and observes whether the UI crashes. Use to answer: does the app handle malformed JSON, content-length lies, or truncated payloads without crashing?
Inputs: url (required), corruption_type (required), intercept_pattern (required), wait_ms, +7 more.
simulate_api_failureA
Opens the browser, redirects directly to the user application, and intercepts API requests matching a URL pattern to return an error status code. Checks if a fallback UI element appears. Use to answer: does the app show a proper error state when the payment API returns 503?
Inputs: url (required), intercept_pattern (required), wait_ms, headless, +7 more.
simulate_network_dropA
Opens the browser, navigates to the application, and aborts requests matching a pattern after a delay, simulating a mid-flight connection drop. Use to answer: what happens if the network drops after the order request is sent but before the response arrives?
Inputs: url (required), intercept_pattern (required), wait_ms, headless, +6 more.
simulate_stateful_failureA
Opens the browser, navigates to the application, and intercepts requests matching a URL pattern. Fails the first N requests with an error status, then lets subsequent requests succeed. Simulates transient failures and tests retry/recovery logic. Use to answer: does the app retry after a 503 and recover when the service comes back?
Inputs: url (required), intercept_pattern (required), wait_ms, headless, +8 more.
trigger_system_network_errorA
Opens the browser, navigates to the application, and aborts requests matching a URL pattern with a system-level network error code, simulating OS-level failures like unreachable hosts or access denied. Use to answer: does the app recover when the DNS resolution fails or the OS rejects a connection?
Inputs: url (required), error_code (required), intercept_pattern (required), wait_ms, +6 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool maps to a distinct failure mode (latency, blocked resources, connection drop, system-level network error, stateful failure, response corruption), and descriptions clarify use cases. However, simulate_api_failure and assert_chaos_handled both intercept requests, return error statuses, and check fallback UI, creating some overlap; simulate_network_drop and trigger_system_network_error also both abort requests with subtle differences.
All names follow a consistent snake_case verb_noun pattern: simulate_api_failure, inject_latency, block_resources, trigger_system_network_error, assert_chaos_handled. The verb choices differ appropriately by action type while remaining predictable and readable.
Eight tools is well-scoped for a chaos engineering server, with each tool representing a meaningful failure injection or assertion capability. No tool feels redundant enough to remove, and the set is not bloated.
The surface covers a broad range of browser/network chaos scenarios: API errors, latency, resource blocking, connection drops, OS-level errors, stateful failures, corruption, and a resilience assertion. Minor gaps exist, such as no tool for combined/concurrent chaos scenarios or explicit success-path verification, but core chaos workflows are covered.
Maintenance
Related MCP Connectors
Browser-based QA for AI-built software. Test pages with real browsers via agents.
AI agents use your app like your users, in real browsers, and report what is broken or confusing.
Synthetic checks, nightly regression replay and model-drift alerts for AI agents
Agentic AI quality engineering: run, debug and triage tests on real browsers and devices
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI agents to simulate network failures and test application resilience in Playwright browser sessions.850 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI coding agents to autonomously interact with and test web applications in a real browser, providing DOM/Accessibility tree extraction, runtime telemetry, screenshot capture, and Markdown test reports.9 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to perform end-to-end web testing by controlling a real browser through tools for navigation, interaction, state inspection, screenshots, and script evaluation.MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to drive live mobile and desktop browser sessions and receive measured UI findings as text — contrast ratios, touch-target sizes, overflow, and theme drift — rather than screenshot guesses. It also lets the agent navigate, tap, type, switch device/theme, read console errors, and pick up bug notes the human pinned in a shared live panel.87 npmMIT