TREMOR — Agentic Blast Radius Cockpit (WebMCP)

See what your AI agent is about to break — before it does.

Comment

TREMOR: Agentic Blast Radius & Regression Prevention Cockpit

See what your AI agent is about to break — before it does.

An interactive, browser-native blast-radius cockpit and trust layer built on the official W3C WebMCP standard (@mcp-b/global).

Live Cockpit: https://tremor-cockpit.vercel.app
GitHub Repository: https://github.com/ABHIGH15/TREMOR
(Note: TREMOR is an independent project built for the WebMCP Challenge 2026 and is not affiliated with the @tremor/react UI library or tremor-runtime.)

1. Inspiration: The Emergence of "AI-CFR"

In 2026, engineering organizations are formally tracking "AI-Specific Change Failure Rate" (AI-CFR) as a core engineering KPI. While autonomous coding agents (Claude Code, Cursor, Codex) generate pull requests four times faster, they operate under a fundamental limitation: Architectural Myopia.

When an agent refactors an isolated file (such as auth-service/session.ts), it reads 200 lines of local code, completely blind to the downstream microservices that depend on that token schema. A two-line cache TTL refactor passes local unit tests, but under peak production traffic triggers a catastrophic Redis cache stampede that knocks out the checkout pipeline.

TREMOR was built to solve this problem: forcing autonomous coding agents to simulate systemic blast radius, review regression history, and obtain human sign-off inside an interactive cockpit before any change reaches production.

2. Why WebMCP? (And Why Backend MCP Cannot Solve This)

Multiple backend MCP servers exist to analyze codebase dependencies (e.g., code-impact-mcp, code-review-graph, Port.io). However, every existing implementation suffers from the same architectural limitation: they run silently inside a terminal CLI, returning raw text back to an LLM.

To a supervising staff engineer, terminal text provides zero real-time situational awareness, no shared visual truth, and no enforceable guardrails.

WebMCP transforms this paradigm:

  1. Zero-Install, In-Browser Runtime: Tools are registered directly onto document.modelContext via the official @mcp-b/global standard polyfill. There are no local sockets, daemons, or machine configurations required.
  2. Shared Visual Reality: When an agent queries simulate_change_impact, the browser's 2D canvas dynamically illuminates the blast zone at 60 frames per second. Both the human engineer and the AI agent look at the exact same live visual impact graph in the same tab.
  3. Enforceable Browser Gates: High-risk operations are locked behind real UI event handlers that the agent cannot programmatically bypass.
  4. Ecosystem Extensibility: Platforms like Vercel or Netlify could expose their own deploy-preview dependency graphs through WebMCP built this way, catching systemic breaks before code even reaches staging.

"Backend MCP tools already hand agents blast-radius data as text in a terminal. TREMOR is browser-native — a human and their agent look at the same live impact graph in the same tab, and nothing risky ships without a human clicking Confirm."

3. The Dual-Engine Architecture

TREMOR ships with a dual-engine architecture designed for both deep enterprise scenario modeling and arbitrary real-world codebase ingestion:

Mode 1: Enterprise Demo Scenario (Default)

A curated 18-microservice topology featuring the complex auth-service to redis-session-cluster P1 outage scenario, flaky test suites, dynamic tool lifecycle unregistration, and a human confirmation gate with counterfactual replay.

Mode 2: Live GitHub Repository Ingestion

Allows an evaluator or engineer to input any public GitHub repository (e.g., ABHIGH15/TREMOR).

  • Fetches the repository file tree in a single API call.
  • Retrieves source code via CDN with zero GitHub REST API rate-limit cost.
  • Client-side regex extracts genuine import ... from and require(...) statements to construct real file-to-file dependency edges.
  • Dynamically computes in-degree graph centrality risk scores (e.g., identifying src/types/dataset.ts as highest-risk at 0.95 with 12 dependents).
  • Dynamically re-binds WebMCP tools so connected AI agents immediately inspect the live repository topology.

4. The 6-Tool Canonical WebMCP Suite

TREMOR registers six standardized tools directly on document.modelContext:

  1. get_system_snapshot: Returns full topology snapshot (18 nodes, 28 edges), top risk bottlenecks (auth-service 0.88, jwt-security-core 0.82), incident index, and test suite health summary.
  2. get_blast_radius: Multi-root transitive BFS graph traversal mapping downstream callers and flaky tests.
  3. check_regression_history: Incident pattern matcher surfacing past outage root causes and post-mortem precedents.
  4. get_change_provenance: Live GitHub API commit telemetry combined with AI vs. Human authorship auditing.
  5. simulate_change_impact: Centerpiece simulator computing composite predicted risk (0.0 to 1.0) and driving real-time canvas particle acceleration.
  6. flag_for_review: Non-self-approving Trust Layer gate generating pending review cards in the UI.

5. The Trust Layer: Why AI Cannot Self-Approve

When an agent simulates a change resulting in Critical Risk (score ≥ 0.70):

  1. Dynamic Tool Lifecycle: The runtime dynamically unregisters simulate_change_impact via AbortController, dropping active tools from 6 to 5. The agent's simulation capability is revoked.
  2. Non-Self-Approving Gate: flag_for_review sets can_tool_self_approve: false. The agent has no programmatic tool to approve its own flag.
  3. Human Sign-Off: An authorized engineer inspects the risk justification in the cockpit and clicks Confirm / Approve.
  4. Counterfactual Replay: The human approval restores tools back to 6, permanent audit logs are written, and an animated banner replays the exact historical outage that the human review just averted.

6. Live Native ChatGPT Verification

Verified live inside the official native ChatGPT desktop and mobile applications:

  • ChatGPT connected to https://tremor-cockpit.vercel.app via its in-app browser.
  • Discovered all six WebMCP tools on document.modelContext.
  • Autonomously analyzed src/types/dataset.ts in our open-source repository, accurately identifying the 0.95 Risk Score, 0.72 Critical Composite Blast Risk, and the exact 11 downstream dependent files.

7. Implementation & Technology Stack

  • WebMCP Standard: Built on official @mcp-b/[email protected] polyfill by Alex Nahas (W3C contributor).
  • Frontend & Physics: React 18, TypeScript, Tailwind CSS, and react-force-graph-2d for 60fps HTML5 canvas physics.
  • Accessibility: Fully compliant with WCAG 2.1 AA standards (high-contrast focus rings, keyboard shortcuts: H for Hero, S for Simulate, R for Reset, ? for Help).
  • Deployment: Vercel Global Edge CDN with zero backend server dependencies.

8. Challenges We Faced & Solutions

  1. Strict Read-Only Properties in ChatGPT Host Context: In ChatGPT's native in-app browser, document.modelContext is defined with writable: false. Direct property assignments threw runtime TypeErrors. We resolved this by keeping all tool registrations strictly compliant with W3C registerTool({...}) protocols.
  2. Multi-Root Transitive BFS Traversal: Simulating changes touching multiple services simultaneously required deduplicating cyclic dependencies and aggregating risk metrics without blocking the 60fps canvas thread. Built an asynchronous BFS graph engine in TypeScript that computes downstream reach in sub-millisecond time.

9. Known Limitations & Roadmap

  1. Static Analysis Depth: Current live repository ingestion uses client-side regex-based import extraction for zero-install execution. The roadmap includes compiling Tree-sitter to WebAssembly in the browser thread for compiler-grade AST parsing.
  2. Runtime Telemetry: Dependency maps currently reflect static source code imports; integrating OpenTelemetry distributed trace spans will enable weighting edges by real-time production RPC traffic volume.
  3. GitHub PR Webhook Integration: Automatically triggering TREMOR blast simulations on incoming agent-created pull requests.

Built With

Share this project:

Updates

Submission history