AI Extension

The AltTester® AI extension enables you to use AI-powered tools like Claude and VS Code with enhanced context about your Unity game testing projects. This extension provides intelligent assistance for writing automated tests, understanding game object hierarchies, and streamlining your test automation workflow.

Note

AltTester® AI extension is available only starting with AltTester® Desktop 2.2.6.

What You Can Do with the AI Extension

The AI extension allows you to:

Generate test scripts: Get AI assistance to create automated tests based on your game’s UI elements
Understand object hierarchies: Ask AI to explain complex game object structures and relationships
Debug tests: Get intelligent suggestions for fixing test failures and improving test reliability
Code completion: Receive smart suggestions while writing AltTester® test code
Documentation assistance: Get contextual help about AltTester® methods and best practices

Note

The AI extension requires a license that supports this functionality. For the moment, all Pro licenses support this, but we reserve the right to change this in the future.

Note

At this stage, the AI extension provides limited support when working with Unreal Engine applications. We welcome user feedback as these insights are essential for guiding future improvements and expanding compatibility.

Getting Started

When you first start AltTester® Desktop with a compatible license, you’ll be prompted to set up the AI extension. Simply click Download to automatically install and configure the extension for your system.

If you prefer not to set it up immediately, you can:

Click Not Now to skip for this session
Check Don’t show this again to permanently disable the prompt

Set up later from Settings page

You can also set up the AI extension later on from the Settings page:

Open AltTester® Desktop Settings
Look for the Configure AltTester® AI Extension section
Click on Open Configuration Setup to download the AI Extension

Using the AI Extension

Understanding MCP (Model Context Protocol)

The AltTester® AI extension works as an MCP server. MCP (Model Context Protocol) is a standardized way for AI applications to access external tools and data sources securely and efficiently. You can learn more about MCP at the official documentation.

What this means for you:

Contextual Intelligence: The AI extension acts as a bridge between your AltTester® projects and AI tools, providing real-time context about your game objects, test scripts, and project structure
Secure Communication: MCP ensures that your project data is shared safely with AI tools without exposing sensitive information
Standardized Integration: Because it uses MCP, the extension works consistently across different AI platforms like Claude Desktop and VS Code
Live Data Access: Unlike static documentation, the MCP server provides current information about your actual game state and test configurations

How it works:

Server Setup: The AI extension runs as a local MCP server on your machine
AI Client Connection: AI tools like Claude Desktop connect to this server using MCP protocols
Context Sharing: When you ask the AI a question, it can query the MCP server for relevant information about your AltTester® projects as well as the live state of a connected game.
Live Game Querying: The AI extension can directly connect to and query your instrumented game in real-time, accessing all game objects, their properties, hierarchies, and current state
Intelligent Responses: The AI uses this live context to provide more accurate and project-specific assistance

This architecture means the AI has access to your current game hierarchy, recorded test steps, object properties, AltTester® configuration, and can directly inspect your running game—enabling much more relevant and useful assistance than general AI responses.

Real-time Game Context:

When your instrumented game is running and connected to AltTester® Desktop, the AI extension can:

Query live object hierarchies: Get current game state and all active UI elements
Access object properties: Retrieve real-time values of components, transforms, and custom scripts
Understand game flow: See how scenes transition and objects change during gameplay
Inspect element attributes: Get exact locators, tags, layers, and other identifying information
Analyze interactions: Understand how UI elements respond to user input

This means when you ask “How do I click the inventory button?”, the AI can look at your actual running game, find the specific button object, and provide the exact code with the correct locator—not just generic examples.

With VS Code

VS Code integration provides enhanced tools for interacting with your and code completion for AltTester® projects.

Setup Steps:

Install Required Extensions: Ensure you have both GitHub Copilot and GitHub Copilot Chat extensions installed in VS Code
Open MCP Configuration: Go to View → Command Palette → type “MCP: Open User configuration” and select it
Add AltTester® Configuration: Add the following MCP server configuration:
```
{
  "servers": {
    "alttester": {
      "command": "/path/to/AltTesterMcp",
      "args": []
    }
  }
}
```
- Replace /path/to/AltTesterMcp with the actual path to the executable in your AltTester® Data Path
- On Windows: Use "C:\path\to\AltTesterMcp.exe"
- On macOS: Use "/path/to/AltTesterMcp"
Start Using AI Extension: Open Copilot Chat in Agent mode and you can start using the AI extension

With Claude Desktop

Claude Desktop can use the AltTester® AI extension to provide intelligent assistance with your test automation projects.

Setup Steps:

Ensure the AI extension is installed in AltTester® Desktop
Open Claude Desktop and access MCP settings by going to Settings -> Developer -> Edit Config

Add the AltTester® MCP server configuration:

{
  "mcpServers": {
    "alttester": {
      "command": "/path/to/AltTesterMcp",
      "args": []
    }
  }
}

Replace /path/to/AltTesterMcp with the actual path to the executable in your AltTester® Data Path
- On Windows: Use "C:\path\to\AltTesterMcp.exe"
- On macOS/Linux: Use "/path/to/AltTesterMcp"
Restart Claude Desktop and you can start using the AI extension

With JetBrains IDEs (PyCharm, Rider, IntelliJ IDEA)

JetBrains IDEs can integrate with the AltTester® AI extension through MCP-compatible plugins to provide intelligent code assistance for your test automation projects.

Setup Steps:

Install AI Assistant Plugin: Ensure you have JetBrains AI Assistant or a compatible MCP plugin installed in your IDE
Configure MCP Server: Access AI settings in your JetBrains IDE:
- Go to File → Settings (or Preferences on macOS)
- Navigate to Tools → AI Assistant or MCP Configuration
- Add a new MCP server configuration and choose “As JSON”
Add AltTester® Configuration: Configure the server with the following details:
```
{
     "mcpServers": 
     {
         "alttester": {
             "command": "path/to/AltTesterMcp",
             "args": [""]
         }
     }
}
```
- Replace /path/to/AltTesterMcp with the actual path to the executable in your AltTester® Data Path
- On Windows: Use "C:\path\to\\AltTesterMcp.exe"
- On macOS/Linux: Use "/path/to/AltTesterMcp"
Enable Integration: Apply the settings and restart the IDE if prompted
Start Using: Access AI features through the AI Assistant panel or inline suggestions

Benefits:

Intelligent code completion for AltTester® driver methods
Context-aware test generation based on your game objects
Real-time suggestions while writing test automation code
Integration with your existing JetBrains workflow and debugging tools

Note

MCP support in JetBrains IDEs may require specific plugins or newer versions of the AI Assistant. Check JetBrains documentation for the latest MCP integration capabilities.

What You Can Ask Any AI Tool

Once connected to the AltTester® AI extension, you can ask any compatible AI tool:

“Help me write a test to click the Play button”
“Explain this game object hierarchy”
“Why is my test failing to find this element?”
“Generate a test script for this UI flow”
“What’s the best locator strategy for this button?”
“How should I structure tests for this game scene?”
“What assertions should I add to verify this interaction?”
“Find all clickable elements in the current scene”

Common Use Cases

Setting Up a New Test Automation Project

The AI extension includes powerful tools to help you get started with test automation for your game. Ask the AI: “I’m new to test automation for my Unity game. Can you set up a starter project for me?”

The AI extension can help you:

Example AI Response:

I will help you set up a new AltTester® automation project. Let me create a starter project structure for you.

First, let me check what language you'd prefer:
- C# (.NET)
- Python  
- Java
- Robot Framework

For this example, I will set up a C# project and use the setup_starter_project tool to create the foundation.

What the AI will do for you:

Create Project Structure: Generate a complete project folder with all necessary files
Add Dependencies: Include the correct AltTester® driver packages for your chosen language
Generate Sample Tests: Create example test files that demonstrate:
- Basic connection to your game
- Common UI interactions (clicks, text input, assertions)
- Best practices for test organization
Configuration Files: Set up build configurations, test runners, and IDE settings
Documentation: Include README files with instructions specific to your project
Run the tests: The extension will also help you understand how to run the tests and how to add more tests for your game.

This automatically creates a ready-to-use test automation project that you can immediately start customizing for your specific game.

Writing Your First Test

Ask the AI: “I want to test the main menu. How do I write a test that clicks the Start Game button?”

The AI will help you:

Identify the correct locator for the button
Generate the test code
Suggest assertions to verify the action worked

Debugging Failed Tests

When a test fails, describe the issue to the AI: “My test can’t find the health bar element anymore. What should I check?”

The AI can suggest:

Alternative locators to try
Common reasons elements become unfindable
Debugging strategies specific to your game

Understanding Complex Hierarchies

For complex UI structures: “Explain how this inventory system is organized and how I should navigate it in tests.”

The AI helps by:

Breaking down the object hierarchy
Suggesting navigation patterns
Recommending test organization strategies