Skip to content
Newv0.23 with direct MCP mode, 10x faster, Maestro

End-to-End Testing with AI
for Agents and Engineers

State-of-the-art MCP server, libraries, and a test runner for web and mobile applications testing.

Start Testing

How

How Alumnium Works

Connect Alumnium to a coding agent through MCP, or add its Java, Python, or TypeScript client to the automated tests you already have.

Agents

Engineers

I. Install

Agents

Engineers

Add an MCP Server

Install Alumnium binary using a installation script or a package manager.

Install a Client Library

Install the Alumnium client for Java, Python, or TypeScript.

curl -LsSf https://alumnium.ai/install.sh | sh
v0.23.1127 MB
irm https://alumnium.ai/install.ps1 | iex
v0.23.1127 MB
npm install alumnium
v0.23.1127 MB
pnpm add alumnium
v0.23.1127 MB
yarn add alumnium
v0.23.1127 MB
bun add alumnium
v0.23.1127 MB
pip install alumnium
v0.23.1127 MB
uv tool install alumnium
v0.23.1127 MB
npm install alumnium
v0.23.1
pnpm add alumnium
v0.23.1
yarn add alumnium
v0.23.1
bun add alumnium
v0.23.1
pip install alumnium
v0.23.1
uv add alumnium
v0.23.1
dependencies {
  testImplementation 'ai.alumnium:alumnium:0.23.1'
  testRuntimeOnly    'ai.alumnium:alumnium-cli-darwin-arm64:0.23.1'
  // Add other platforms as needed
}
v0.23.1
<dependencies>
  <dependency>
    <groupId>ai.alumnium</groupId>
    <artifactId>alumnium</artifactId>
    <version>0.23.1</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>ai.alumnium</groupId>
    <artifactId>alumnium-cli-darwin-arm64</artifactId>
    <version>0.23.1</version>
    <scope>test</scope>
  </dependency>
  <!-- Add other platforms as needed -->
</dependencies>
v0.23.1

II. Set Up

Agents

Engineers

Set Up the MCP Server

Choose a supported AI provider, configure its credentials when required, and connect Alumnium to your MCP-compatible coding agent.

Set Up the Client Library

Choose a supported AI provider, then initialize Alumnium with your existing Selenium, Playwright, or Appium driver.

claude mcp add alumnium \
    --env ALUMNIUM_MODEL=anthropic \
    --env ANTHROPIC_API_KEY=... -- \
    alumnium mcp
codex mcp add alumnium \
    --env ALUMNIUM_MODEL=codex -- \
    alumnium mcp
grok mcp add alumnium \
    --env ALUMNIUM_MODEL=xai \
    --env XAI_API_KEY=... -- \
    alumnium mcp
import { strict as assert } from "assert";
import { Alumni } from "alumnium";
import { Builder, type WebDriver } from "selenium-webdriver";

process.env.OPENAI_API_KEY = "...";

describe("YouTube Search", () => {
  let al: Alumni;
  let driver: WebDriver;

  before(async () => {
    driver = await new Builder().forBrowser("chrome").build();
    al = new Alumni(driver);
  });

  after(async () => {
    await driver.quit();
    await al.quit();
  });
});
import { Alumni } from "alumnium";
import { test, expect } from "@playwright/test";

process.env.OPENAI_API_KEY = "...";

test.describe("YouTube Search", async () => {
  let al: Alumni;

  test.beforeEach(async ({ page }) => {
    al = new Alumni(page);
  });

  test.afterEach(async () => {
    await al.quit();
  });
});
import { Alumni } from "alumnium";
import { browser, expect } from "@wdio/globals";

process.env.OPENAI_API_KEY = "...";

describe("YouTube Search", () => {
  let al: Alumni;

  before(async () => {
    al = new Alumni(browser);
  });

  after(async () => {
    await al.quit();
  });
});
from alumnium import Alumni
from selenium.webdriver import Chrome
from pytest import fixture

@fixture
def driver():
    driver = Chrome()
    yield driver
    driver.quit()

@fixture
def al(driver):
    al = Alumni(driver)
    yield al
    al.quit()
from alumnium import Alumni
from pytest import fixture

@fixture
def al(page):
    al = Alumni(page)
    yield al
    al.quit()
from alumnium import Alumni
from appium.webdriver.webdriver import WebDriver
from pytest import fixture

@fixture
def driver():
    driver = WebDriver()
    yield driver
    driver.quit()

@fixture
def al(driver):
    al = Alumni(driver)
    yield al
    al.quit()
import static org.junit.jupiter.api.Assertions.assertEquals;

import ai.alumnium.Alumni;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.chrome.ChromeDriver;

class SearchTest {
  private Alumni al;
  private ChromeDriver driver;

  @BeforeEach
  void setUp() {
    driver = new ChromeDriver();
    al = new Alumni(driver);
  }

  @AfterEach
  void tearDown() {
    driver.quit();
    al.quit();
  }
}
import static org.junit.jupiter.api.Assertions.assertEquals;

import ai.alumnium.Alumni;
import com.microsoft.playwright.Page;
import com.microsoft.playwright.junit.UsePlaywright;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

@UsePlaywright
class SearchTest {
  private Alumni al;

  @BeforeEach
  void setUp(Page page) {
    al = new Alumni(page);
  }

  @AfterEach
  void tearDown() {
    al.quit();
  }
}
import static org.junit.jupiter.api.Assertions.assertEquals;

import ai.alumnium.Alumni;
import io.appium.java_client.ios.IOSDriver;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class SearchTest {
  private Alumni al;
  private IOSDriver driver;

  @BeforeEach
  void setUp() throws Exception {
    driver = new IOSDriver(/* pass options as needed */);
    al = new Alumni(driver);
  }

  @AfterEach
  void tearDown() {
    driver.quit();
    al.quit();
  }
}

III. Test

Agents

Engineers

Prompt to Test

Describe the user flow and expected result in plain language. Your coding agent uses Alumnium to drive and verify the application.

Write Test Steps

Add natural-language actions, checks, and data retrievals alongside the framework code already in your tests.

describe("YouTube Search", () => {
  it("queries videos", async () => {
    await driver.get("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
test.describe("YouTube Search", async () => {
  test("queries videos", async ({ page }) => {
    await page.goto("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
describe("YouTube Search", () => {
  it("queries videos", async () => {
    await browser.url("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
def test_search(al, driver):
    driver.get("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
def test_search(al, page):
    page.goto("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
def test_search(al, driver):
    driver.get("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    driver.get("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    page.navigate("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    driver.get("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}

IV. Run

Agents

Engineers

Run Markdown Tests

Ask your coding agent to save a successful scenario as Markdown. Run it again locally or in CI with Alumnium test runner.

Run Test Suite

Run your test suite as usual, with Alumnium handling natural-language steps and checks.

Why

Why Alumnium

Alumnium combines high-level AI tools with the automation frameworks you already use, so you can adopt AI without replacing your test stack.

Benchmark

State-of-the-Art Performance

Claude Code with Alumnium MCP achieved a 98.5% pass rate across 610 tasks.

Claude Code with Alumnium MCP successfully completed 98.5% out of 610 tasks in the WebVoyager browser-agent benchmark. The result shows how high-level Alumnium tools can keep a general-purpose agent focused while Alumnium handles browser interaction details.

Read more about the WebVoyager benchmark results.

#1 Alumnium
Alumnium
98.5%
#6 Browser Use
Browser Use
89.1%
#7 GLM-5V-Turbo
Z.ai
88.5%
#8 Operator
OpenAI
87%
#12 Project Mariner
Google
83.5%
#17 Computer Use 3.5
Anthropic
56.0%

Efficient

Free Up Your Agent's Context

Keep browser/mobile details out of the agent's context and reuse AI work across repeated test runs.

5×
Fewer tokens: 45K vs. 240K
1/4
of Playwright's cost

Works with Smaller Models

Alumnium is designed for smaller, lower-cost models. Choose from the supported models based on the speed, cost, and capability your tests require.

Long-Horizon Tasks

High-level tools keep low-level interactions inside Alumnium, helping the coding agent stay focused through workflows with many steps.

Reduces Context Growth

Alumnium MCP performs the detailed UI work and returns concise change summaries, so the coding agent receives only the context it needs to proceed.

Web & Mobile

Web, iOS and Android

Apply the same high-level test intent to web, iOS, and Android apps.

Alumnium works with web applications through Selenium or Playwright and with iOS and Android applications through Appium or Maestro.

Reuse plain-language instructions across supported platforms, with platform-specific adjustments when the applications behave differently.

Multi-session support lets you run configured platform sessions at the same time.

Fits Your Stack

Meets You Where You Are

Adopt Alumnium incrementally without replacing your test framework.

Add Alumnium to the supported AI providers, automation frameworks, and languages you already use. Client libraries let you introduce AI one step at a time alongside existing framework code.

Choose from supported hosted models from Anthropic, OpenAI, Google, xAI, Meta, DeepSeek, and Mistral, or run a supported local model with Ollama.

Change supported models without changing the test intent, and keep using Selenium, Playwright, Appium, or Maestro as the underlying automation layer.

Ship Faster

Why AI Tests

Traditional end-to-end tests often require selectors, waits, and ongoing maintenance as the UI changes. Alumnium lets tests express more of their intent in natural language while retaining framework-level control.

Natural

Use English Programming Language

Describe actions and expected outcomes in readable language.

Whether you use a coding agent through MCP, a client library in an existing suite, or the test runner, the same natural-language commands describe what the application should do.

Use natural-language actions and checks where you would otherwise need detailed selectors and explicit waits, while retaining direct access to the underlying framework when you need it.

Alumnium interprets these commands against the current UI, which makes tests more resilient to changes in element identifiers and structure.

# YouTube Search

Test the https://www.youtube.com search feature.

Search for "lofi beats" and check that:

1. The screen title contains the query.
2. The displayed search results are relevant
   to the query.
describe("YouTube Search", () => {
  it("queries videos", async () => {
    await driver.get("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
def test_search(al, driver):
    driver.get("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    driver.get("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}

Express Intent, Not Implementation

Keep implementation details out of the test.

Alumnium resolves natural-language descriptions against the current UI, reducing the number of selectors tied to a specific implementation.

Its element cache can match previously selected elements after minor UI changes, reducing repeated LLM work. Larger changes can still require a new model request or an update to the test.

Reuse Tests Across Platforms

Describe equivalent web and mobile flows in the same language.

Web and mobile applications often implement the same user journey with different controls and layouts.

Alumnium lets you reuse high-level instructions across web, iOS, and Android while configuring an appropriate driver for each platform.

Platform-specific behavior may still need separate instructions, but the shared intent remains readable and consistent.

Features

What's in Alumnium

Three entry points for agents, existing testing suites and brand new Markdown testing workflows.

MCP Server

High-level testing tools for agents.

Let coding agents drive and verify web or mobile applications without filling their context with low-level UI details. Or, if you are tokenmaxxing, use the MCP server direct mode to make coding agents faster.

Connect an MCP-compatible coding agent, or build your own agent on top of Alumnium's MCP tools. The server uses local stdio transport.

Music License

Client Libraries

Add AI gradually to an existing test suite.

Mix Alumnium's natural-language actions and checks with existing Selenium, Playwright, and Appium code.

Client libraries are available for Java, Python, and TypeScript, so you can adopt AI one test step at a time.

describe("YouTube Search", () => {
  it("queries videos", async () => {
    await driver.get("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
test.describe("YouTube Search", async () => {
  test("queries videos", async ({ page }) => {
    await page.goto("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
describe("YouTube Search", () => {
  it("queries videos", async () => {
    await browser.url("https://youtube.com");
    await al.do("search for 'lofi beats' and press Enter");
    await al.check("page title contains 'lofi beats'");
    await al.check("search results contain lofi videos");
  });
});
def test_search(al, driver):
    driver.get("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
def test_search(al, page):
    page.goto("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
def test_search(al, driver):
    driver.get("https://youtube.com")
    al.do("search for 'lofi beats' and press Enter")
    al.check("page title contains 'lofi beats'")
    al.check("search results contain lofi videos")
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    driver.get("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    page.navigate("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}
class YouTubeSearchTest {
  @Test
  void queriesVideos() {
    driver.get("https://youtube.com");
    al.act("search for 'lofi beats' and press Enter");
    al.check("page title contains 'lofi beats'");
    al.check("search results contain lofi videos");
  }
}

Single Binary

Alumnium is distributed as a single binary with an approximately 100 MB footprint.

Major Operating Systems

Alumnium works on macOS, Windows, and Linux.

HTTP API

Alumnium Server allows controlling programmatically using HTTP API.

Agentic Toolbox

High-level tools for common testing tasks.

Whether you use MCP or integrate the Alumnium client into your existing test suite, the same tools can act, verify state, retrieve data, and resolve elements from natural-language instructions.

They keep detailed UI work inside Alumnium, reducing the amount of context exposed to a calling agent.

Do Tool

Plans actions and executes them in the app based on the natural language goal.

Check Tool

Checks whether the app is in the expected state and explains the result.

Get Tool

Retrieves requested data or state from the application for validation or further processing.

Wait Tool

Waits until the app reaches a desired condition expressed with natural language.

Change Analyzer

Summarizes UI changes after an action so an agent receives feedback just in time.

Vision

Uses screenshots when visual information is needed to complete a check or retrieval.

Element Finder

Finds elements from the natural language descriptions for use in automation frameworks.

Area Focus

Focuses on a specific area of the page for more precise interactions.

Deep Browser Integration

Support for advanced browser workflows.

Alumnium supports browser workflows such as tabs navigation, pages with frames, shadow DOM, file uploads, persistent profiles, and others.

Exact capabilities vary by automation framework and platform - see the documentation for the current support matrix.

  • Tab handling
  • Automatic waits & retries
  • Persistent profiles
  • Frames support
  • Shadow DOM
  • Screenshots and videos
  • File uploads
  • PDF export
  • Execute JavaScript
  • History navigation
  • Sliders manipulation
  • Headless browsers
  • Cookies assignment
  • Browser permissions
  • Proxy support
  • Playwright traces
  • Custom HTTP headers
  • Custom User-Agent

UI Tree

Structured UI context instead of screenshot-only control.

Alumnium primarily uses a text-based representation to understand the application's structure and state, adding vision when a task requires visual information.

It turns platform accessibility trees into focused XML, giving the model structured context about relevant controls and content.

Multi-Level Cache

Reuse model responses and element decisions.

Alumnium caches model responses and element decisions to reduce repeated LLM requests on subsequent test runs.

The element cache can remain useful when dynamic identifiers or minor UI details change. Broader changes can trigger a new request.

Prompt Cache

Alumnium prompts are structured in a way that takes advantage of provider-side caching.

Response Cache

Model responses are stored and reused when the request context has not changed.

Element Cache

Element decisions are matched against the current UI so changes do not always require another model request.

Multi-Model

Choose a supported model for your workload.

Select from the supported provider and model matrix based on the capability, latency, cost, and deployment model your tests need.

Multi-Cloud

Use supported hosted model providers.

Connect through supported cloud platforms or directly to a model provider.

Local Models

Keep model inference on your infrastructure.

Run a supported open-weight model through Ollama when application data must stay within infrastructure you control.

Runner

Markdown Test Runner*

Run agent-written or manually written Markdown tests locally or in CI.

Alumnium includes a preview test runner for repeatable execution of Markdown scenarios:

  1. Write a Markdown scenario manually, or create one with a coding agent and Alumnium MCP.
  2. Review and save the scenario in your repository.
  3. Run the test alumnium test <filename>.md.
* The test runner is currently in preview.

Record and Replay

The runner records tool calls for reuse. With a warm cache and an unchanged flow, a replay may need no new LLM requests.

Self-Healing

When cached steps no longer match the UI, Alumnium can resolve them again before reporting a failure.

Cross-Platform Tests

Reuse high-level Markdown scenarios across configured web, iOS, and Android sessions.

Agent SDKs

Native agent SDKs let the runner use a compatible agent configuration during local and CI execution. Claude Agent SDK is currently supported.

Scale

Scale with Alumnium

Alumnium has all you need from running few tests to thousands.

Central Server

Manage model requests and caching for multiple agents and test runners.

Alumnium Server is a single binary that runs on your infrastructure and handles model requests, caching, and test execution for multiple agents and test runners.

Local and Remote Cache

Designed to make AI tests fast and affordable on a scale.

Alumnium cache can be stored locally on the filesystem or remotely* so team members and CI jobs don't need to repeat the same model requests independently.

* Remote cache is currently in preview.

CI/CD

Run the same test workflows locally and in CI.

Run tests using client libraries or Markdown scenarios in your existing CI/CD workflows. Restore a cache between jobs, or evaluate the preview remote cache for shared execution environments.

Parallelism and Sharding

Run multiple tests in parallel across multiple machines.

Test runner supports parallel execution of tests within a single machine, and can be configured to split tests to run across multiple machines for large test suites.

Browser and Device Clouds

Access real devices and browsers in the cloud you use.

Alumnium works with cloud providers that offer real devices and browsers for testing. Whether you use Selenium Grid, Sauce Labs, TestMu, or another provider, Alumnium can connect to the cloud through the supported automation frameworks.

Telemetry

Get insights into your tests and agents.

When tracing is enabled, Alumnium exports telemetry data to the endpoint you configure. Any OpenTelemetry-compatible collector is supported.

Head to head

Alumnium Stands Out

See how we line up with other projects.

Single-Task Comparison

We asked Claude Code with Opus 4.8 to test all YouTube search filters end-to-end as a user on web and Android.

AlumniumBrowser UseMobile NextPlaywright
Main-agent tokens
Tokens consumed in the coding agent's context during the task.
45,000
92,000143,000240,000
Duration
Elapsed time to complete the task.
20 mins
20 mins16 mins15 mins
Cost
Agent usage cost in USD for the task.
$3.73
$6.57$12.79$15.05

Raw transcripts are available here.

Features Comparison

See how Alumnium compares to other projects in terms of features and capabilities.

AlumniumBrowser UseMobile NextPlaywright
Built-in test runner
CLI capable of running Markdown scenarios locally or in CI.
*~
TypeScript
Native JS/TS client package.
Python
Native Python client package.
Java
Native Java client package.
Web
Test web applications.
iOS
Test iOS applications.
Android
Test Android applications.
License
Project source code license.
MITMITApache 2.0Apache 2.0

* The Alumnium test runner is currently in preview.

Project

Built in the Open

Inspect the source, follow development, and contribute.

Open Source and Extensible

MIT-licensed and open to extension.

Alumnium's source is available under the MIT license for personal and commercial use. Development, issues, and pull requests happen in public.

You can inspect, customize, and extend the project for your own testing workflows.

Based on Decades of Experience

Built by product and quality engineering veterans.

Alumnium draws on hands-on experience in QA, browser automation, and application development.

Team members led established open-source projects, including Selenium and date-fns.

Active Community

Questions, bug reports, and pull requests are welcome.

Join the Discord community to ask questions, share feedback, or discuss a contribution before opening a pull request.

@p0deje avatar@kossnocorp avatar@dependabot[bot] avatar@sh3pik avatar@Balaji028 avatar@reachsridhard avatar@ursmurli avatar@rookieInTraining avatar@endlessloop2 avatar@shbenzer avatar@martijnhjk avatar@TweedBeetle avatar@VinayakaMayura avatar@sai-meyyappan avatar@hriday-13th avatar@devimano2011 avatar@sudoCommit avatar@cgoldberg avatar@Copilot avatar@WilliamK112 avatar@claude avatar@ioachim-hub avatar@papai0709 avatar@radanskoric avatar

In a Good Company

Programs and infrastructure that support project development.

Alumnium participates in programs that provide resources to open-source maintainers.

FAQ

Frequently Asked Questions

Practical answers about setup, cost, compatibility, and project maturity.

Alumnium is a suite of libraries and tools for natural-language end-to-end testing of web and mobile applications. It consists of:

  • MCP server for agentic testing;
  • client libraries for writing tests in Java, Python, and TypeScript;
  • test runner for executing Markdown scenarios locally or in CI; and
  • server for central model communication and caching.

Alumnium works with:

  1. Selenium or Playwright for web automation.
  2. Appium or WebdriverIO for iOS and Android mobile testing.
  3. Maestro for iOS and Android mobile testing through the MCP server.

Client libraries let you add Alumnium incrementally alongside existing framework code. Exact capabilities vary by framework and platform, so check the documentation for current support.

Alumnium makes its own requests to the model provider, so you generally need a valid API key or other credentials for the provider you choose. You can also run a supported model locally through Ollama, which does not require an API key. If you have ChatGPT subscriptions, you can use the Codex support to reuse your ChatGPT subscription in Alumnium

See the configuration guide for the current provider matrix and setup instructions.

When you use a hosted model, Alumnium sends the relevant natural-language instruction and UI context to that provider. Screenshots may also be sent when a vision-enabled operation needs them.

Use a supported local model through Ollama when model inference must stay on infrastructure you control. OpenTelemetry tracing is optional and exports only to the endpoint you configure.

Alumnium has no license fee and is available under the MIT license for personal and commercial use. You are only responsible for model provider, infrastructure, and automation service costs associated with your setup.

Choose the entry point that matches your workflow:

  1. Agent: add the Alumnium MCP server.
  2. Existing test suite: install the Java, Python, or TypeScript client and initialize it with Selenium, Playwright, or Appium.
  3. Markdown tests: use the test runner.

See our Getting Started guide and MCP guide for detailed instructions.

Yes. Alumnium provides a Model Context Protocol (MCP) server for compatible clients including Claude Code, Codex, and Cursor. An agent can use it to drive and verify browser or mobile applications, and engineers can build custom agents on the same high-level MCP tools.

Alumnium is under active development and is currently used to power thousands of tests in production by early adopters. Start with non-critical test flows, review AI-generated scenarios, and expand usage as you validate it in your environment. Join the Discord community to share feedback and follow new releases.