---
name: testmu-mcp-skill
description: >
  Connects AI coding assistants and IDEs to the TestMu AI (Formerly LambdaTest)
  MCP server so agents can orchestrate HyperExecute test runs, triage and debug
  automation failures, analyze SmartUI visual regressions, and run accessibility
  checks from natural language, without leaving the editor. Use when the user
  asks to set up the TestMu AI or LambdaTest MCP server, connect Claude, Cursor,
  Copilot, Codex, Cline, or Continue to TestMu AI, debug a failed automation
  build, generate a HyperExecute YAML, analyze a SmartUI diff, or run an
  accessibility audit. Triggers on: "TestMu MCP", "LambdaTest MCP", "MCP server",
  "mcp.lambdatest.com", "HyperExecute", "SmartUI", "debug test failure",
  "accessibility check", "connect to TestMu AI".
languages:
  - Any
category: mcp-integration
license: MIT
metadata:
  author: TestMu AI
  version: "1.0"
  updated: "2026-07-08"
---

# TestMu AI MCP Server

The TestMu AI (Formerly LambdaTest) MCP Server is a remote Model Context Protocol server that connects AI clients and IDEs directly to your TestMu AI testing environment. From natural language, an agent can orchestrate test runs, debug failures, and analyze results without leaving the editor.

- **Server URL:** `https://mcp.lambdatest.com/mcp`
- **Server name:** `mcp-lambdatest`
- **Transport:** Streamable HTTP (primary); STDIO via `mcp-remote` (fallback)
- **Auth:** OAuth. On first use the client opens a browser and redirects to testmuai.com to authorize; no keys are pasted into config.
- **Docs:** https://www.testmuai.com/support/docs/testmu-mcp-server.md (raw markdown; append `.md` to any TestMu AI docs page URL)
- **Overview:** https://www.testmuai.com/mcp/

## Prerequisites

Before you start:

- An active TestMu AI account. OAuth consent cannot complete without one. Sign up: https://www.testmuai.com/register/
- Node.js and `npx` on your PATH if the client uses the STDIO `mcp-remote` fallback (Cline and the Universal STDIO Fallback shell out to `npx`).
- Pop-ups allowed for testmuai.com so the OAuth consent window can open.

## Step 1: Detect the AI Client

Pick the row that matches the user's tool, then apply its config in Step 2.

| Client | Where it is configured | Method |
|---|---|---|
| Cursor | `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global) | JSON, `url` |
| Claude Code | Terminal | `claude mcp add` command |
| Claude Desktop | Settings > Connectors | Add remote connector by URL |
| Claude.ai (Web) | claude.ai/settings/connectors | Add remote connector by URL |
| GitHub Copilot (VS Code) | `.vscode/mcp.json` | JSON, `type: http` |
| Antigravity | MCP config | JSON, `serverUrl` |
| OpenAI Codex CLI | Terminal or `~/.codex/config.toml` | CLI command or TOML |
| Cline (VS Code) | Cline MCP settings panel (MCP Servers > Configure) | JSON via `mcp-remote` (STDIO) |
| Continue | `.continue/mcpServers/testmu-ai.yaml` | YAML, `streamable-http` |
| Any MCP-compatible client | Its MCP config | Universal STDIO fallback |

If the client supports remote Streamable HTTP servers, prefer the direct `url` config. Only use the `mcp-remote` STDIO fallback when a client cannot connect to a remote HTTP server directly.

## Step 2: Add the Server

Use the exact block for the detected client. The server name is always `mcp-lambdatest`.

### Cursor

```json
{
  "mcpServers": {
    "mcp-lambdatest": {
      "url": "https://mcp.lambdatest.com/mcp"
    }
  }
}
```

### Claude Code

```bash
claude mcp add --transport http mcp-lambdatest https://mcp.lambdatest.com/mcp
```

### Claude Desktop

Open Settings > Connectors, add a custom connector, and paste the URL `https://mcp.lambdatest.com/mcp`. Custom connectors are available on Pro, Max, Team, and Enterprise plans and are configured through Settings > Connectors, not `claude_desktop_config.json`.

### Claude.ai (Web)

Go to claude.ai/settings/connectors, add a custom connector with Name `TestMu AI` and URL `https://mcp.lambdatest.com/mcp`.

### GitHub Copilot (VS Code)

```json
{
  "servers": {
    "mcp-lambdatest": {
      "type": "http",
      "url": "https://mcp.lambdatest.com/mcp"
    }
  }
}
```

### Antigravity

```json
{
  "mcpServers": {
    "mcp-lambdatest": {
      "serverUrl": "https://mcp.lambdatest.com/mcp"
    }
  }
}
```

### OpenAI Codex CLI

```bash
codex mcp add mcp-lambdatest --url https://mcp.lambdatest.com/mcp
codex mcp login mcp-lambdatest
codex mcp list
```

The `login` command starts the OAuth flow; verify the server appears with `codex mcp list`.

Or in `~/.codex/config.toml`:

```toml
[mcp_servers.mcp-lambdatest]
url = "https://mcp.lambdatest.com/mcp"
```

### Cline (VS Code)

```json
{
  "mcpServers": {
    "mcp-lambdatest": {
      "disabled": false,
      "timeout": 60,
      "command": "npx",
      "args": ["mcp-remote@latest", "https://mcp.lambdatest.com/mcp"],
      "alwaysAllow": []
    }
  }
}
```

### Continue

Create `.continue/mcpServers/testmu-ai.yaml` (Agent Mode required):

```yaml
name: TestMu AI mcpServer
version: 0.0.1
schema: v1
mcpServers:
  - name: TestMu AI
    type: streamable-http
    url: https://mcp.lambdatest.com/mcp
```

### Universal STDIO Fallback

For any MCP client that cannot connect to a remote HTTP server directly, bridge through `mcp-remote`:

```json
{
  "mcpServers": {
    "mcp-lambdatest": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.lambdatest.com/mcp"]
    }
  }
}
```

## Step 3: Authenticate

1. Restart or reload the client so it picks up the new server.
2. Trigger any TestMu AI tool (or open the client's MCP panel). The client opens a browser and redirects to testmuai.com for OAuth consent.
3. Approve access. The session is stored by the client; you do not paste a username or access key into the MCP config.

If you do not have an account yet, sign up at https://www.testmuai.com/register/.

## Step 4: Choose the Right Tool

The server exposes five tool groups. Route the user's request to the matching one.

| User intent | Tool | Example prompt |
|---|---|---|
| Run or scale tests, generate a run command or YAML | HyperExecute | "Generate a HyperExecute YAML to run my Playwright suite on Chrome and Edge in parallel, then start it and share the session link." |
| A build or test failed, find the root cause | Automation | "My last automation build failed. Pull the command, network, and console logs and tell me the likely cause." |
| A visual/screenshot comparison changed | SmartUI | "Summarize the differences in my latest SmartUI comparison run and flag the real regressions." |
| Check a page or app for a11y issues | Accessibility | "Run an accessibility check on https://example.com and list the WCAG issues with fixes." |
| Manage test cases, runs, results, milestones | Test Manager | "Generate test cases from this requirement into my Regression folder and build a test run." |

## Tools

All five tool groups read and act on data in your authenticated TestMu AI account. On a fresh account with no automation builds or SmartUI comparisons, the Automation, SmartUI, and HyperExecute tools return nothing, which is not an error; generate data first (run a Kane CLI objective, a framework skill, or a HyperExecute job). To scope a tool to a specific item, pass a build or session ID or its dashboard link rather than relying on phrases like "my last build".

### HyperExecute
AI-native test orchestration. Auto-generates test runner commands and HyperExecute YAML, monitors jobs, and surfaces session details. Use it to stand up or scale a run and get back a live job link.

### Automation
Triage and debug automation test failures. Pulls execution data plus command, network, and console logs and helps identify root cause directly inside your IDE. Use it after a failed build to explain what broke and where.

### SmartUI
Debug visual regressions. Returns natural-language summaries of pixel, layout, DOM, and perceptual differences from any SmartUI comparison run, so you can separate real regressions from noise. This tool triages an existing comparison; to create one first, use the SmartUI CLI (`npm install -g @lambdatest/smartui-cli`, then `npx smartui config:create .smartui.json` and `npx smartui exec -- <your test command>` or `npx smartui capture urls.json`).

### Accessibility
Run accessibility checks on hosted URLs or local React apps and get detailed remediation guidance mapped to WCAG.

### Test Manager
Run the complete test management lifecycle. Generate test cases with AI, organise them into projects and folders, build configured test runs, record results in bulk, and track milestones and coverage.

## Example Workflows

```
"Set up the TestMu AI MCP server in Cursor, then list the tools it exposes."
"Debug my last failed automation run and show the failing step with the console error."
"Create a HyperExecute config for my Cypress tests across 3 browsers and start the job."
"Analyze the newest SmartUI build and tell me which visual diffs are intentional."
"Audit https://staging.myapp.com for accessibility and give me prioritized fixes."
```

## Verify the Connection

- Ask the client to list available MCP tools; you should see the HyperExecute, Automation, SmartUI, and Accessibility tools under `mcp-lambdatest`.
- Run a low-risk prompt such as "List my recent automation builds" to confirm auth succeeded.

## Troubleshooting

| Symptom | Likely cause | Fix |
|---|---|---|
| Server does not appear after adding config | Client not reloaded | Fully restart the client; re-open the MCP panel |
| "No tools found" under `mcp-lambdatest` | OAuth not completed | Trigger a tool once and finish the browser consent on testmuai.com |
| Browser consent never opens | Client blocks remote HTTP servers | Use the Universal STDIO Fallback with `npx mcp-remote@latest` |
| `npx` / `mcp-remote` errors | Node.js or npm missing or outdated | Install the latest stable Node.js and npm, then retry |
| Connection refused or 4xx on the URL | Wrong URL or transport | Confirm the URL is exactly `https://mcp.lambdatest.com/mcp` and the transport matches the client (HTTP vs STDIO) |
| Tools run but return no account data | Signed into the wrong account | Re-run OAuth and approve with the account that owns the tests |
| Copilot ignores the server | Wrong config shape | Copilot uses `servers` with `type: http`, not `mcpServers` |
| Continue shows no tools | Not in Agent Mode | Enable Agent Mode; MCP tools are Agent-Mode only |
| Antigravity cannot connect | Wrong key | Antigravity uses `serverUrl`, not `url` |
| Codex does not load the server | Config not picked up | Use `codex mcp add` or add the `[mcp_servers.mcp-lambdatest]` block to `~/.codex/config.toml` |
| Antigravity shows no tools with correct config | Antigravity caps active MCP tools at roughly 100 across all servers | Disable unused MCP servers so the four TestMu AI tools fit under the cap, then reload |
| OAuth consent window never opens (pop-up) | Pop-ups blocked in the browser | Allow pop-ups for testmuai.com, then trigger a tool again |

## Quick Reference

| Item | Value |
|---|---|
| Server URL | `https://mcp.lambdatest.com/mcp` |
| Server name | `mcp-lambdatest` |
| Primary transport | Streamable HTTP |
| Fallback transport | STDIO via `npx -y mcp-remote@latest https://mcp.lambdatest.com/mcp` |
| Auth | OAuth (browser consent on testmuai.com) |
| Tools | HyperExecute, Automation, SmartUI, Accessibility, Test Manager |
| Setup docs | https://www.testmuai.com/support/docs/testmu-mcp-server.md |

## Related TestMu AI Resources

- Framework agent skills (Selenium, Playwright, Cypress, Appium, and more): https://github.com/LambdaTest/agent-skills
- Agent instructions and surface routing (Kane CLI vs MCP vs framework skills vs cloud grid): https://www.testmuai.com/agents.md
- Kane CLI, natural-language browser automation (driving it from a coding agent: https://www.testmuai.com/kane-cli/agents.md): https://www.testmuai.com/kane-cli/
- KaneAI, the GenAI-native testing agent: https://www.testmuai.com/kane-ai/
- Product documentation: https://www.testmuai.com/support/docs/
- Site and page index for LLMs: https://www.testmuai.com/llms.txt