Skip to main content
Glama

DeadlockMCP

An MCP server for building Deadlock UI mods.

Live-edit Deadlock's Panorama UI (XML/CSS/JS) while the game runs.

Connect it to an MCP client with an agent and ask for things like "find the panel that shows my stat boosts and move it to bottom-center".

The server installs an addon that uses the dev tools to update the UI. The agent inspects the live panel tree, tries CSS and JS in the running game, takes screenshots to check the result, and then compiles the change into a mod VPK.

⚠️ Status: Alpha. Tested only on Bazzite (KDE Wayland) with Proton, Deadlock build #6,861 (Nov 2026). Other Linux setups may work but are untested. Windows and macOS aren't supported yet; help supporting other platforms is welcome.

Getting started

You need Linux with Deadlock installed through Steam (running under Proton) and uv. Steam must be running when the game launches, so the game can log in.

  1. Add the server to your MCP client (stdio). It must run on the same Linux desktop session as the game:

    {
      "mcpServers": {
        "deadlock": {
          "command": "uvx",
          "args": ["deadlock-mcp"]
        }
      }
    }

    With Claude Code: claude mcp add deadlock -- uvx deadlock-mcp. Paths are auto-detected; TECH.md lists the environment variables to override them.

  2. Ask your agent to set it up. It runs setup, which downloads Source 2 Viewer CLI and CSDK 13 (about 1.6 GB) and creates a Wine prefix for the compiler. If the CSDK download fails, it asks you to download the .7z into ~/Downloads yourself. setup also lists any missing system tools (7z, xdotool, ImageMagick, umu-run) with the install command for your distro.

  3. Ask it to start the game: it runs bridge_install, then launch_game(map="new_player_basics"). The game boots straight into a sandbox match with the full HUD, ready for changes.

Related MCP server: Enfusion MCP

Making a mod

  1. Get set up as described above, with the game running in the sandbox.

  2. Tell your agent what you want, for example "move my stat boosts to bottom-center" or "make the ability cooldown numbers bigger". It finds the panels, tries the change live, and takes screenshots to check. Keep giving feedback until it looks right.

  3. Ask it to package the mod, for example "make that permanent and install it as a mod called my_hud". You get ~/.local/share/deadlock-mcp/mods/my_hud/pak01_dir.vpk, and with install it's also copied into game/citadel/addons/ under the next free pakNN_dir.vpk name.

The exported VPK is a normal mod: it doesn't include the bridge and doesn't need this tool to run.

Tools

Most tools take ui='hud' | 'dashboard' | 'overlay' to pick a panel tree; the default auto uses the first one that's ready.

Game

tool

description

status

Reports paths, game and bridge state, and anything that needs fixing, and pings each in-game bridge.

launch_game

Launches Deadlock with the dev addon mounted, optionally straight into the sandbox map with the full HUD.

quit_game

Closes Deadlock.

console_log

Returns recent game console output, optionally regex-filtered.

screenshot

Captures the game window (or the whole screen) as an image, with an optional crop.

Game files

tool

description

ui_files

Lists the Panorama files shipped in the game, with a regex filter.

ui_source

Decompiles a shipped Panorama layout, stylesheet or script to source.

Live editing

tool

description

panel_tree

Dumps the live panel hierarchy (id, type, layout, size, position, text) under a panel.

panel_find

Finds live panels with a CSS-like selector.

js_eval

Runs JavaScript in the game's UI and returns the result.

css_apply

Applies CSS to live panels as inline styles, re-applying it as panels are recreated.

css_clear

Removes one live CSS sheet, or all of them.

xml_load

Compiles Panorama XML (and optional CSS) and loads it into the live UI.

layout_live_edit

Live-edits an existing game layout's stylesheet, applying only the changed declarations.

layout_live_revert

Reloads the original layout into panels changed by layout_live_edit.

panel_delete

Deletes a live panel by id.

Building and exporting

tool

description

compile_source

Compiles a Panorama file into the dev addon as a permanent override (applies after a restart).

list_overrides

Lists the compiled files in the dev addon.

remove_override

Removes a compiled override from the dev addon.

export_mod

Exports the overrides, without the bridge, as a standalone mod VPK, and optionally installs it into the game.

Setup

tool

description

setup

Installs Source 2 Viewer CLI, CSDK 13 and the compiler's Wine prefix, and lists missing system tools.

bridge_install

Builds the in-game bridges and packs them into the dev addon; re-run after a game update.

bridge_uninstall

Removes the bridge files from the dev addon.

addons_mount

Adds or removes the dev addon's search path in gameinfo.gi.

Parameters and implementation details: TECH.md.

What it installs

setup puts everything under ~/.local/share/deadlock-mcp/ ($DEADLOCK_MCP_DATA to move it):

  • tools/s2v/: Source 2 Viewer CLI, to decompile game files.

  • tools/Reduced_CSDK_13/: CSDK 13, whose resourcecompiler.exe compiles Panorama files (about 5.4 GB).

  • wine/: a Wine prefix made by Proton, to run the compiler.

  • mods/: exported mods.

It doesn't install system packages.

What it modifies

  • game/citadel/gameinfo.gi: launch_game adds a marked block that mounts the dev addon (and citadel/addons, so installed mods still load), saving the previous file as gameinfo.gi.mcp-bak. The addon is unmounted automatically when that game exits; if the game crashed or the PC rebooted, status warns and addons_mount(False) removes it.

  • game/citadel/mcp_addons/: the dev addon, holding the bridge, your compiled overrides, and the request files the server talks to the game through.

  • game/citadel/console.log: the game writes it (-condebug) and the server deletes it on each launch.

  • game/citadel/addons/: export_mod(install=True) copies the mod there.

  • ~/.local/share/deadlock-mcp/tools/Reduced_CSDK_13/{content,game}/citadel_addons/mcp_bridge/: sources and compiler output.

  • ~/.cache/deadlock-mcp/: decompiled sources, launch and watcher logs.

No shipped game files are changed. Agent-launched games are for building mods: play your matches from a normal Steam launch, which doesn't load the bridge.

License

MIT. Deadlock and its assets belong to Valve.

Available Tools

24 tools
addons_mountA

Add (or remove) the dev addon search path in gameinfo.gi. launch_game mounts it and unmounts it when the game exits; removing it keeps the standard mod folder mounted.

Inputs: enable. Returns: result

bridge_installA

Build and install the in-game bridges (needs CSDK 13 + Source2Viewer-CLI): one per UI root (HUD, dashboard, overlay). Compiles each host layout override + bridge script into the addon VPK. launch_game mounts the addon for its session (mount=True mounts it now). Restart the game afterwards. Re-run it after a game update or an update of this tool (status says when).

Inputs: mount. Returns: result

bridge_uninstallA

Remove the bridge files from the addon VPK (other compiled overrides stay).

Inputs: no named parameters. Returns: result

compile_sourceA

Compile a Panorama source file with CSDK 13 and pack it into the addon VPK as a permanent override (takes effect after a game restart).

path: e.g. 'panorama/layout/citadel_hud_top_bar.xml' or 'panorama/styles/hud.css'. To override a game file, start from ui_source(...) and keep the same path. The bridge host layouts (base_hud, base_dashboard, base_hud_and_db_overlay) can't be overridden: that would remove the bridge from that UI.

Inputs: path (required), source (required), install. Returns: result

console_logC

Recent game console output (from console.log), optionally regex-filtered, e.g. pattern='PanoramaScript|JS Exception|panorama'.

Inputs: lines, pattern. Returns: result

css_applyA

Apply CSS to live panels as inline styles. Replaces earlier CSS with the same sheet name.

persist=True re-applies about once a second so panels the game recreates stay styled. Supports type, #id, .class, descendant and '>' selectors; pseudo-classes and at-rules are skipped (use xml_load's css for those on new panels, or compile_source for permanent game-wide styles).

Inputs: css (required), ui, sheet, persist. Returns: result

css_clearA

Remove live CSS: one sheet by name, or all sheets if omitted. Panels styled by several sheets get the remaining sheets' values re-applied right away.

Caveat: once an inline visibility: collapse has been applied, clearing it does NOT make the panel visible again (Panorama keeps the panel's visible flag false). To hide things you may want back, prefer toggling visibility explicitly (set 'visible' again) via js_eval.

Inputs: ui, sheet. Returns: result

export_modA

Export compiled overrides as a standalone mod VPK (no bridge files) at /mods//pak01_dir.vpk.

include: regex selecting which addon files to export (default: every non-bridge override; see list_overrides). install=True also copies it into game/citadel/addons/ as the next free pakNN_dir.vpk (re-installing the same name replaces its earlier copy); the game loads it on its next start.

Inputs: name (required), include, install. Returns: result

js_evalA

Run JavaScript inside Deadlock's Panorama UI and return the result (JSON-serialised; panels are described as {panel: {...}}).

A single expression is returned automatically; multi-statement code must return a value. In scope: $ (Panorama API), $panel (target panel; default the bridge panel), $root (top-level panel), $find(id), $query(structuredSelector), $children(p), $describe(p). target: panel id ('#Foo' or 'Foo'), 'root', or 'bridge'. keep_context=True keeps the script's context alive so event handlers / $.Schedule callbacks it registers keep working (otherwise contexts are recycled after ~64 requests).

Inputs: code (required), ui, target, timeout, +1 more. Returns: result

launch_gameA

Launch Deadlock, optionally straight into a local map with the full match HUD.

map: 'new_player_basics' (sandbox / practice range — verified), 'dl_hideout', 'dl_midtown'. ('hero_testing' crashes the game even unmodded.)

Default: run deadlock.exe directly through umu-run with the game's own Proton prefix (no Steam launch prompt, no shader pre-caching; Steam must be running for login). Always adds -console -condebug -dev -novid (-condebug writes console.log, which the bridge replies through). extra_args is split like a shell command line. Mounts the dev addon for this session (if that fails, the game is not launched); it is unmounted automatically when the game exits. via_steam=True uses steam -applaunch (Steam asks the user to confirm custom arguments).

Inputs: map, via_steam, extra_args. Returns: result

layout_live_editA

Live-edit the styling of an existing game layout (e.g. layout='citadel_hud_top_bar').

css: an edited copy of one of the layout's stylesheets. stylesheet: which one, in any form ('hud/foo', 'styles/hud/foo.css', 's2r://panorama/styles/hud/foo.vcss'); default: the layout's include with the layout's own name, else its only include (an error lists the choices). Get the original with ui_source. Declarations you added or changed are applied live as a persistent inline-style sheet named 'live:<path under styles/ without extension>', e.g. 'live:hud/foo' (@define values are substituted; pseudo-classes/animations and removed declarations can't be applied live — use compile_source for those). Undo with css_clear('live:hud/foo').

unsafe_reload=True instead compiles an edited copy of the layout (xml and/or css) and re-loads it into the live panels. This CRASHES the game for layouts whose root is a C++ panel type (most HUD/dashboard layouts, e.g. CitadelHudTopBar); the bridge skips panels it knows are unsafe and lists them under 'skipped'. Only use it for plain Panel-rooted layouts.

Inputs: layout (required), ui, css, xml, +2 more. Returns: result

layout_live_revertA

Re-load the game's original layout into panels changed by layout_live_edit(unsafe_reload=True). (For CSS edits made the safe way, use css_clear('live:').)

Inputs: layout (required), ui. Returns: result

list_overridesB

List the compiled files currently packed into the addon VPK (bridge files + compile_source overrides).

Inputs: no named parameters. Returns: result

panel_deleteB

Delete a live panel by id (e.g. one created with xml_load). The UI root, the bridge panel and its ancestors are refused.

Inputs: target (required), ui. Returns: result

panel_findB

Find live panels with a CSS-like selector, e.g. 'Label.HeroName', '#HudRoot > Panel'. ui='all' (default) searches every loaded UI tree.

Inputs: selector (required), ui, target, max_results. Returns: result

panel_treeC

Dump the live panel hierarchy (id, type, layout file, size, position, text) under a panel.

Inputs: ui, depth, target, max_nodes. Returns: result

quit_gameA

Close Deadlock (terminates the process).

Inputs: no named parameters. Returns: result

remove_overrideA

Remove a compile_source override from the addon VPK (e.g. 'panorama/styles/hud.css'). Takes effect after a game restart.

Inputs: path (required). Returns: result

screenshotA

Capture the game and return it as an image.

By default grabs the Deadlock window itself via X11 (works even when other windows cover it, no focus change). If the window can't be captured (minimised, not found) this is an error, not a picture of the desktop. full_screen=True captures the whole screen instead, other windows included. crop: 'WxH+X+Y' in captured-image pixels (the game window's, e.g. '800x800+0+1100' for the bottom-left HUD), applied before resizing — use it to inspect small HUD details. A crop that fails is an error, not an uncropped image.

Inputs: crop, max_width, full_screen.

setupA

Install the toolchain: Source 2 Viewer CLI, CSDK 13 and the compiler's Wine prefix. Downloads run in the background, so call again to see progress; a step it can't do itself says what the user has to do.

Inputs: no named parameters. Returns: result

statusA

Report paths, game/bridge state and anything that needs fixing ("warnings"), and ping each in-game bridge.

Inputs: no named parameters. Returns: result

ui_filesA

List Panorama files shipped in the game VPK (regex filter), e.g. pattern='hud'.

Inputs: limit, pattern. Returns: result

ui_sourceB

Decompile a shipped Panorama file to source, e.g. 'layout/base_hud' or 'styles/hud.css'.

Inputs: path (required), refresh. Returns: result

xml_loadA

Compile Panorama XML (and optional CSS) with CSDK and load it into the live UI (~2s).

mode='append': create a child panel (id replaces any existing child with that id) under target. mode='replace': load the layout into target itself, replacing its contents. Refused for the UI root, the bridge panel (and its ancestors), and any panel whose type isn't plain Panel (loading into a C++ panel crashes the game). xml: a full ... layout or a bare fragment (wrapped automatically). Referenced scripts/styles must exist in the game or the addon. css: real Panorama CSS (pseudo-classes, animations, @define all work) compiled as this layout's stylesheet, included after the layout's own so it wins ties.

Inputs: xml (required), id, ui, css, +2 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 24 tools

    Disambiguation3/5

    Several tools converge on the same job of styling live panels: css_apply (inline sheets), layout_live_edit (persistent inline-style sheets via an edited stylesheet), xml_load's css parameter, and compile_source (permanent overrides), while css_clear and layout_live_revert both undo. The descriptions do explain the differences, and inspection tools (panel_find, panel_tree, js_eval) are distinct, but choosing the right styling path requires reading carefully. bridge_uninstall, remove_override and panel_delete are also easy to mix up at a glance despite targeting different things (bridge files, compiled overrides, panels).

    Naming Consistency3/5

    Everything is snake_case, but the verb/noun ordering is mixed: verb_noun (launch_game, compile_source, list_overrides, remove_override) alongside noun_verb (bridge_install, css_apply, css_clear, panel_find, layout_live_edit) and bare nouns (status, setup, screenshot, console_log, ui_files). The prefix grouping (panel_*, css_*, bridge_*, *_override) gives some structure, but the set is not a single predictable pattern.

    Tool Count4/5

    24 tools is heavy, but the domain — UI inspection, live CSS manipulation, compilation, bridge management, and mod packaging — genuinely spans that surface, and nearly every tool has a distinct role. A few (layout_live_revert, css_clear overlaps) could arguably be folded together to trim the set.

    Completeness5/5

    The lifecycle is well covered end to end: setup and status, launching/quitting, decompiling and inspecting shipped UI, live panel discovery/manipulation, CSS application and clearing, compilation into permanent overrides with listing/removal, and exporting/mounting mods. Given the description indicates input simulation or log tailing beyond a fixed console.log read, there are no obvious dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI coding agents to work inside a live Unreal Editor for Fortnite session: write and compile Verse, place and wire Creative devices, edit Scene Graph entities, manipulate actors and assets, take screenshots, run playtests, and read editor logs via MCP.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients to research game mods by searching documentation and definitions, inspecting dependencies and playsets, validating saved files with structural and Tiger checks, and preparing or editing mod content with preview and write controls. It also supports starting or previewing the game through a local stdio connection.
      5 npm
      GPL 3.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables any MCP client to drive the Fortnite map editor through typed, safety-validated tools — placing and tagging props, renaming assets with Verse-reference pre-flight, authoring prefabs, exporting textures for visual identification, and searching the project's Verse API digests. An in-editor listener executes the operations on the editor's main thread over HTTP.
      MIT