More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    AGS mcp

    1

    Build, script and play-test Adventure Game Studio 3.6 games through the free Pravus AGS MCP server, inside the editor on Windows.

    Free

    Security scanned
    AGS mcp

    AGS mcp

    Example session with this skill installed

    Add a new hotspot to room 1 at 150,120 named 'Golden Key' that gives the player item 5 when interacted with. Render the room first to check the spot.

    • Read your context and instructions
    • Compiled the ags mcp

    Added the Golden Key hotspot to room 1 and confirmed it works in the running game.

    Inspected first. render_room 1 with the hotspot and walkable masks: (150,120) is a clear patch of wall above the walkable floor, and no existing hotspot or object covers it. Hotspots 1 and 2 were taken, so this is hotspot 3. get_properties inventory 5 gave its script name: iGoldenKey.

    Made.

    • draw_room_mask hotspot 3: a 24×16 rectangle centred on (150,120), so it is easy to click.
    • set_room_properties hotspot 3: Name "Golden Key", Description "A small golden key hangs on a nail", WalkToPoint 150,160 (on the floor, beside the key rather than in front of it, so the player sprite does not catch the click).
    • set_room_event hotspot 3 Interact → hGoldenKey_Interact, then filled the stub in room1.asc:
      function hGoldenKey_Interact()
      {
        player.Walk(150, 160, eBlock);
        player.AddInventory(iGoldenKey);
        hGoldenKey.Enabled = false;   // one key; the hotspot goes away with it
        Display("You take the golden key.");
      }
    
    • compile name=room1: 0 errors, 0 warnings.

    Verified in the game (play-test subagent, run_game startRoom=1): hover at (150,120) reads "Golden Key"; Interact click there → the player walks to (150,160), the message shows, game_state.player.inventory now contains 5, and hGoldenKey.Enabled is false. Stopped the game afterwards.

    Saved. Room tools and script edits write to disk at once, so nothing here needed save_project.

    Your call. The hotspot is invisible art-wise; if the key should be seen on the wall, say so and I will draw a sprite and make it a room object instead, which also lets it disappear visually when taken.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building a point-and-click adventure in the AGS editor means constant switching between rooms, scripts and sprites. This skill is the agent's manual for the Pravus AGS MCP server, a free, open-source plugin that runs inside the Adventure Game Studio 3.6 editor and lets your agent build, change and play-test the game you have open.

    Server, source and releases: https://github.com/pravusjif/pravus-ags-mcp (MIT). This skill is written for server 0.2.x and ships with every release.

    What it does

    • Project: game metadata, resolution and settings through project_info; save_project for everything that lives in Game.agf.
    • Rooms: create rooms, set backgrounds, draw walkable, hotspot, walk-behind and region masks, place objects at exact pixel coordinates, bind room events.
    • Entities: characters, inventory items, views and dialogs, with the properties and naming your game already uses.
    • Scripts: read and edit room scripts and global modules through the editor's own copy, compile, and fix errors by file and line.
    • Assets: import sprites and audio clips into the right folders and types; generate crisp pixel art with the included Python helper.
    • Play-testing: run the game with the engine plugin, hover, click, wait and assert on game_state; then check the release build a player gets with the desktop_* driver.

    How it works

    1. Set up: references/setup.md walks through the prerequisites, installing the plugin (download the release zip, copy two DLLs next to AGSEditor.exe, no admin rights) and configuring your MCP client: Claude Code, Codex CLI, Gemini CLI, any Streamable HTTP client, or stdio clients through mcp-remote.
    2. Inspect: project_info, list_rooms, get_room, read_script and get_properties before changing anything, so coordinates, IDs and conventions come from the game.
    3. Change: room tools such as draw_room_mask and set_room_event, entity tools, edit_script.
    4. Compile and save: compile for the scripts you touched, save_project for the project data. The skill spells out which changes persist immediately and which need the save, because getting that wrong loses work.
    5. Verify: run_game, then game_process_click, game_wait_until and game_state in a subagent, so screenshots and state payloads stay out of your main context. Adventure Game Studio 3.6 on Windows, the Pravus AGS MCP server (the ags MCP server, an editor plugin), and Python 3 with Pillow for the pixel-art helper. The skill's scripts make no network calls and the skill fetches nothing at runtime.

    Why this beats prompting it yourself

    The server gives an agent the tools; the skill gives it the knowledge the tools assume: which edits are written at once and which wait for a save, why a script edited on disk gets overwritten, where the player sprite steals clicks, why a room edge two pixels from the walkable area never fires, how to bind handlers before the script has them, and how to assert on game state instead of trusting a screenshot. A complete game, Mansion of Cosmic Horrors, was built by an agent working through this server and skill.

    Use cases

    • Add a puzzle to a room: art, masks, object, hotspot, handlers, and a play-test that proves it.
    • Rewrite a character's speech lines across every dialog, then compile everything.
    • Fix a broken walkable area or baseline from a rendered mask.
    • Build a release and play it with real mouse and keyboard input to check what players get.

    What you should know before installing

    The server listens on loopback only (127.0.0.1) and has no authentication, so any program on your machine can call it while the editor is open. Its tools act with your permissions: they edit and save your project, write files, build and launch games, and the desktop_* tools send real mouse and keyboard input to a game window. Every tool is annotated read-only or destructive for your agent's approval settings, and the skill tells the agent to say so before using the desktop tools.

    Known limitations

    Windows only (the AGS editor is a Windows application). The editor must be running with a game open; no tool works while the editor shows a modal dialog. Play-tests run in a subagent because game_state payloads and screenshots are large. Sound synthesis is not included: the separate chiptune skill does that, and this one imports what it makes.

    Two things to check against the form as you paste: whether it has its own source-link field (put the repo URL there too if so), and whether the description has a length limit, in which case the "Why this beats prompting" and "Use cases" sections are the ones to shorten.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.

    Windows only (the AGS editor is a Windows application). The editor must be running with a game open; no tool works while the editor shows a modal dialog. Play-tests run in a subagent because game_state payloads and screenshots are large. Sound synthesis is not included: the separate chiptune skill does that, and this one imports what it makes.

    Two things to check against the form as you paste: whether it has its own source-link field (put the repo URL there too if so), and whether the description has a length limit, in which case the "Why this beats prompting" and "Use cases" sections are the ones to shorten.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    • Free with an Agensi account

    Windows only

    Software
    Adventure Game Studio 3.6.xPravus AGS MCP plugin 0.2.xAgs Run MCP
    Optional
    Python 3PillowNode.jschiptune skill

    Get the free plugin at github.com/pravusjif/pravus-ags-mcp/releases. Your MCP client needs Streamable HTTP or Node.js with mcp-remote. Python and Pillow are for pixel art; chiptune makes music.

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed13 days ago

    What's inside

    Frequently Asked Questions

    No. The AGS editor is a Windows application and the MCP server is a plugin that runs inside it, so you need a Windows machine with the editor open. Your agent has to run on that same machine, since the server only listens on 127.0.0.1.

    Yes: the free Pravus AGS MCP plugin, two DLLs copied next to AGSEditor.exe (no admin rights, no installer), and your MCP client pointed at http://127.0.0.1:7471/mcp under the name "ags". The skill's references/setup.md walks the agent through both, and the editor's MCP menu shows the client config for your port.

    It works on whatever game you have open. The skill tells the agent to read the rooms, scripts and entities it will touch first and follow your naming, coordinates and conventions, to change only what the task needs, and to ask before anything that cannot be undone, such as deleting entities.

    Both. With the engine plugin enabled for the project, run_game starts a debug build and the game_* tools hover, click, wait and read game state so the agent can assert that a puzzle works instead of guessing from a screenshot. For a release build it uses the desktop_* tools, which drive the real game window with mouse and keyboard input.

    New in Game Development

    Free