Configuring Manus AI as a Playwright Test Runner

While 89% of quality engineering teams are actively piloting or deploying generative AI in their testing workflows, only 15% have scaled these systems across the enterprise, according to the Capgemini 2025-26 World Quality Report [Capgemini 2025-26]. This execution gap highlights the challenge of transitioning from basic test script generation to fully autonomous test execution loops. In standard development pipelines, developers run Playwright browser test suites inside ephemeral continuous integration containers such as GitHub Actions or GitLab CI/CD. The runner downloads browser binaries, executes the test scripts, generates reports, and immediately shuts down the virtual machine. If a selector is broken, the pipeline fails, the log file is locked, and a human developer must manually inspect the errors and write a patch.

Autonomous AI agents like Manus AI present a different model. Operating as an action engine running within an isolated Ubuntu virtual machine sandbox, Manus AI can control web browsers, interact with terminals, and execute shell scripts [Manus AI]. When running Playwright test automation, Manus AI acts not just as a static executor, but as an active coordinator. The agent can monitor test failures, inspect live browser viewports, adapt browser interactions, and update the test scripts in real time.

However, because the agent VM is ephemeral and recycled after the task completes, saving the output artifacts becomes a major challenge. The raw HTML report files, interactive trace ZIP archives, and video recordings must be persisted outside the agent's workspace. While cloud object storage like AWS S3 or consumer tools like Google Drive are common alternatives, they are not optimized for agent workflows. AWS S3 requires writing complex AWS SDK upload scripts and managing IAM policies within the sandbox. Google Drive presents strict OAuth API rate limiting that frequently blocks high-frequency agent actions. Fastio provides persistent shared workspaces designed for human-agent collaboration. The platform indexes files automatically, exposes direct Model Context Protocol endpoints, and preserves detailed version histories, keeping test runs secure and auditable.

Because Manus AI operates as an action engine running within an Ubuntu VM sandbox, developers can run Playwright and other browser automation tools natively. The sandbox environment has Node.js and npm pre-installed, allowing developers to set up a test environment by instructing Manus AI to run shell commands in its local terminal [Manus AI].

To configure the runner, you first instruct Manus AI to initialize a new testing directory and install the necessary dependencies. The command to install the Playwright test package and its system-level browser dependencies is:

npm init playwright@latest -- --yes --quiet
npx playwright install --with-deps

This ensures that Chromium, Firefox, and WebKit browser binaries are installed with all the required Linux libraries. Once the workspace is ready, the agent needs a configuration file to direct the test runner. The following TypeScript code block demonstrates a standard playwright.config.ts configuration, saving JSON and HTML reports locally before they are uploaded to Fastio:

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: [
    ['html', { outputFolder: 'playwright-report', open: 'never' }],
    ['json', { outputFile: 'playwright-report/test-results.json' }]
  ],
  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
  ],
});

A sample test file can then be written to verify that the target application loads correctly. For example, a basic login verification script (tests/auth.spec.ts) checks the page title and page elements:

import { test, expect } from '@playwright/test';

test('has title and performs login', async ({ page }) => {
  await page.goto('http://localhost:3000/login');
  await expect(page).toHaveTitle(/Login/);
  
  await page.fill('#username', 'test_user');
  await page.fill('#password', 'secure_password');
  await page.click('#submit-btn');
  
  await expect(page.locator('#dashboard')).toBeVisible();
});

Manus AI runs this test suite inside its sandbox by executing npx playwright test. The command generates an HTML dashboard and trace files within the local directory. If left in the VM sandbox, these artifacts are deleted when the session terminates. Sending them to a persistent shared workspace is necessary to prevent data loss.

Exporting reports to cloud storage is critical for tracking software builds over time. Before writing files to a persistent location, developers often review traditional alternatives like AWS S3 or Google Drive. Storing reports on AWS S3 requires writing custom upload scripts with AWS SDK libraries and managing access keys within the agent's VM, which increases security risks. Google Drive offers a visual interface for humans but lacks developer-friendly API endpoints, often triggering rate limits during continuous integration cycles.

Fastio provides a simpler alternative by exposing a persistent workspace that supports both human and agent operations. Point Manus at Streamable HTTP on https://mcp.fast.io/mcp, or https://mcp.fast.io/mcp/key when the client sends a Bearer token. Legacy SSE is available at https://mcp.fast.io/sse. Developers can review the integration steps in the developer storage documentation.

After npx playwright test finishes, instruct Manus to persist the HTML report and JSON log through Fastio's MCP upload tool. For a report already on the sandbox disk, use action stream-upload with profile_type set to workspace and the 19-digit workspace profile_id. When the report is available at a URL, this tools/call imports it into the workspace:

import os
import requests

MCP_URL = "https://mcp.fast.io/mcp/key"
HEADERS = {
    "Authorization": f"Bearer {os.environ['FASTIO_API_KEY']}",
    "Content-Type": "application/json",
}

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
        "name": "upload",
        "arguments": {
            "action": "web-import",
            "url": "https://example.com/playwright-report/test-results.json",
            "profile_type": "workspace",
            "profile_id": os.environ["FASTIO_WORKSPACE_ID"],
        },
    },
}
response = requests.post(MCP_URL, headers=HEADERS, json=payload)

When you upload files to Fastio, the platform auto-indexes the contents. Once you enable Intelligence Mode on a workspace, it indexes all test reports and execution logs for semantic retrieval. Developers can search their logs using natural language query interfaces rather than scanning lines of code.

Fastio also includes Metadata Views (available at /product/document-data-extraction/), which convert unstructured files into a queryable database. Developers define the fields they want to extract, such as test execution status, error messages, or runtime durations. Fastio automatically scans incoming Playwright JSON files, extracts the structured data, and populates a spreadsheet. This structured layer allows teams to analyze pass/fail patterns without writing custom log parsers. The workspace is also helpful for human-agent collaboration. Human developers can co-edit checklists or document bug fixes directly in Collaborative Notes while the agent writes real-time execution summaries.

Persist Playwright reports in shared workspaces

Establish a central repository for your automated test runs with versioning, structured schema extraction, and semantic search queries. Starts with a 14-day free trial.

Start 14-Day Trial

Traditional continuous integration pipelines fail immediately when a test script breaks due to a shifted UI selector or a revised component class. This creates bottlenecks in the development process. According to GitLab's 2026 DevSecOps research, testing bottlenecks remain the primary blocker for organizations aiming to achieve continuous delivery [GitLab DevSecOps Report].

By deploying Manus AI as an autonomous Playwright runner, developers can create a self-healing testing loop. Because Manus AI operates as an action engine running within an Ubuntu VM sandbox, it does not just run scripts; it can respond to test failures dynamically [Manus AI].

When a Playwright test fails, the self-healing loop operates through the following steps:

1. Executing the test run: Manus AI runs npx playwright test inside the sandbox terminal.

2. Detecting the failure: The agent parses the generated test-results.json log file to locate the exact line and file where the test failed.

3. Diagnosing the UI change: If the failure is caused by a missing element, Manus AI opens the browser in the VM sandbox to inspect the current state of the application.

4. Identifying the correct selector: The agent queries the DOM tree, locates the updated button or input field, and identifies the new CSS class or ID.

5. Patching the script: Manus AI uses its file system access to edit the spec file (tests/auth.spec.ts), replacing the broken selector with the updated one.

6. Verifying the patch: The agent re-runs npx playwright test to confirm that the test now passes.

7. Saving the resolution: Once verified, the agent writes the updated test script and the successful execution report to the shared Fastio workspace.

This self-healing loop reduces pipeline noise. Human developers do not need to spend time fixing minor CSS selector changes. Instead, they receive an updated test script in their Fastio workspace, accompanied by a detailed version history that tracks the agent's modifications. If the agent makes a mistake, developers can review the version history and restore the previous spec file instantly.

Setting up autonomous test environments requires clear security controls and workspace management. When using agents like Manus AI, developers must ensure that the agent has write access to the workspace without exposing administrative configurations. Fastio supports this workflow with granular permissions, allowing owners to restrict access at the organization, workspace, folder, or file level.

This setup supports a clean handoff process between developers and clients. An agent can set up the testing workspaces, upload reports, and configure Metadata Views. Once the configuration is validated, the developer can transfer ownership of the organization to the client. The agent creates the organization and builds the workspaces, and then hands off the account to a human using a claim link. The agent retains admin access while the human assumes full ownership of the billing organization.

To build these persistent test environments, teams can register an organization account on Fastio. Doing active work requires an organization subscription, which begins with a 14-day free trial requiring a credit card to activate. When the trial completes, organizations can choose from three paid subscription plans:

• Solo Plan: $29 per month, designed for individual developers running personal agent workflows.

• Business Plan: $99 per month, designed for small teams collaborating on shared folders and documents.

• Growth Plan: $299 per month, designed for larger organizations that need more usage headroom and team scale.

Selecting the right plan ensures that your agent runners have the necessary credits and API limits to sync logs, track trace files, and manage testing artifacts across your development lifecycle.