Cheat Engine MCP Bridge
Let AI clients inspect, debug, and manipulate program memory through natural-language requests.
The README thoroughly diagrams the path among the AI client, Python MCP server, named pipe or TCP relay, Cheat Engine, and the target process, earning strong data-flow transparency. Leaving arbitrary shell execution disabled and recommending trusted relay interfaces show limited least-privilege awareness, but the product still exposes process control, memory modification, protection changes, DLL injection, code execution, input automation, and DBVM kernel capabilities without demonstrated per-tool scoping or isolation. No confirmation gate for high-impact actions is documented. There is no policy for retention, logging, model exposure, or disposal of sensitive process memory. Dependencies are installed as unpinned mcp and pywin32 packages, with no hashes, audit evidence, or vulnerability process. External effects and several risks are described, but not comprehensively classified. Some inverse operations exist, such as free_memory and pause/unpause, while no systematic rollback is given for injection, memory changes, or crashes. The MIT copyright holder and contributors are attributed, but publisher identity is unverified and maintenance or security ownership remains unclear.
Version 12.0.0, the startup message, and connection-check example are broadly consistent, and the README covers installation checks, timeout configuration, connectivity troubleshooting, and a Lua loading limitation. A deduction applies because “36/37 PASSED (100% success)” uses an ambiguous denominator, while the supplied evidence contains neither implementation nor test files with which to check the roughly 180 tools. Dependencies, Python 3.10+, the Windows-only native transport, and a TCP alternative are documented, but versions and compatibility are not pinned. Failure guidance is useful for setup problems, although structured errors, partial-failure behavior, and recovery semantics for high-risk tools are not shown.
The intended audience and scenarios are concrete, including reverse engineering, scanning, structure analysis, debugging, and trainer workflows. Deployment guidance covers ordinary Windows use plus WSL, VMs, containers, and remote TCP arrangements. Boundaries include the Windows named-pipe restriction, optional DBVM use, shell opt-in, and several safety constraints, but per-tool prerequisites, privileges, and supported ranges are absent. Natural-language examples and explicit tool names provide some trigger guidance; parameter schemas, dangerous-action routing, ambiguity handling, and confirmation rules are not evidenced, limiting trigger precision.
The README is well organized around architecture, installation, quick start, capability groups, troubleshooting, environment variables, examples, project layout, and testing. Windows paths, TOML escaping, and TCP setup are particularly actionable. Names are mostly consistent, though product version 12.0.0 and pipe suffix v99 coexist without explanation. Examples and FAQ-style troubleshooting are strong. Windows, Lua, network-exposure, and BSOD constraints are documented, but there is no comprehensive known-issues or compatibility list. The complete MIT license is present. Versioning evidence is limited to a badge and a reference to a v12 overhaul; no changelog, release history, or upgrade guide is supplied. Copyright and contributors are named, but maintainer duties, security reporting, and support policy are unspecified.
The ping response, named tools, and task workflows suggest outputs that can support connection diagnosis and follow-on memory analysis, but response schemas, error fields, and handling of large results are absent for most tools. Connecting a natural-language agent to Cheat Engine plausibly adds value to repetitive scanning, pointer traversal, and analysis. However, claims of reducing days to minutes, instant reads, and automatic identification are not supported by the supplied implementation or results. Setup appears short, yet practical use entails Cheat Engine, Windows bridging, possible DBVM and anti-cheat conflicts, BSOD risk, and extensive target-process authority; the documentation does not systematically weigh those costs against benefits.
Some claims are traceable to named settings, architecture components, tools, commands, and an expected ping response. Core capability, approximately 180 tools, performance gains, and test success remain README assertions because the referenced code, command guide, and test suite are not part of the supplied evidence. The LICENSE independently corroborates MIT metadata and copyright attribution only, not functionality, safety, or tests. Warnings, limitations, and the educational disclaimer are explicitly labeled, but marketing timelines, performance language, and the test percentage are not cleanly separated from demonstrated facts, so fact-inference separation is weak.
- The bridge can read and modify process memory, change protections, inject DLLs, execute code, and invoke DBVM kernel capabilities; use it only against explicitly authorized targets in an isolated environment.
- Do not expose the TCP relay to an untrusted network. The README states that anyone who can reach it can control the Cheat Engine bridge.
- Leave CE_MCP_ALLOW_SHELL unset unless arbitrary command execution is specifically required and protected by additional isolation and human confirmation.
- Follow the documented BSOD-prevention setting before DBVM use or protected-page scanning, and prepare for target or host instability; no complete rollback procedure is documented.
- Dependencies are unpinned, and the supplied evidence excludes implementation and test files. Review and lock dependencies, audit tool privileges, and independently verify the README's capability and test claims before deployment.
What does this agent do, and when should you use it?
Cheat Engine MCP Bridge connects MCP clients such as Cursor, Copilot, Claude AI, and Codex to Cheat Engine for reverse engineering, memory analysis, and debugging automation. Its main components are the Python FastMCP server mcp_cheatengine.py, the Cheat Engine Lua bridge ce_mcp_bridge.lua, and the optional ce_tcp_relay.py transport. Clients send MCP JSON-RPC calls over stdio; the Python server forwards them to Cheat Engine through a Windows named pipe or TCP relay. Roughly 180 tools cover memory access and scanning, pointer resolution, disassembly, structure analysis, breakpoints, process control, allocation, injection, symbols, and window or input automation. Cheat Engine and the Lua bridge remain on Windows, while TCP transport allows the MCP server to run in a VM, container, Linux host, WSL, or remote environment. The project is positioned for authorized research, modding, trainer development, and security audits—not malicious hacking, multiplayer cheating, or Terms-of-Service violations.
An AI client invokes tools exposed by mcp_cheatengine.py, which sends requests to ce_mcp_bridge.lua over \\.\pipe\CE_MCP_Bridge_v99 or a configured TCP socket; the Lua bridge then calls Cheat Engine APIs against the target process. read_memory, read_integer, read_string, and read_pointer_chain retrieve typed values and resolve nested pointers, while scan_all and aob_scan search for values or byte patterns. disassemble, analyze_function, dissect_structure, get_rtti_classname, find_references, and find_call_references inspect code, objects, and cross-references. Debugging operations include hardware or data breakpoints and DBVM tracing through start_dbvm_watch; lifecycle tools enumerate, create, attach to, pause, and resume processes. Additional commands allocate and protect memory, inject DLLs, execute code or methods, manage symbols, assemble x86/x64 instructions, compile C into injected shellcode, generate API-hook templates, automate windows and keyboard input, and load or save .CT tables. Results return as MCP tool responses, with ping providing a basic connection and version check.
- A mod or trainer developer needs to locate health, currency, or coordinate values and generate a distinctive AOB signature that can survive game updates.
- A reverse engineer is navigating a large process and wants to trace writes, disassemble the responsible function, and document an inferred object structure.
- An authorized security researcher needs to inspect process memory, follow call references, or observe protected pages with hardware breakpoints and DBVM.
- A CTF participant wants to scan a live target, resolve pointer chains, inspect byte patterns, and identify possible C++ types through RTTI.
- A game-research or automation developer needs to sample pixels, simulate keyboard input, or send WM_* messages to a target window.
- A team running its MCP client in WSL, Linux, a container, or a remote environment needs a TCP relay to reach Cheat Engine on a Windows host.
What are this agent's strengths and limitations?
- It exposes roughly 180 Cheat Engine operations, spanning scans and pointer chains through disassembly, breakpoints, process control, and code injection.
- Two transports are documented: direct Windows named pipes and a TCP relay that lets the Python MCP server run in WSL, Linux, containers, VMs, or remote environments.
- The repository supplies both a Codex TOML example and a generic MCP JSON configuration, plus a ping tool for end-to-end verification.
- RTTI identification, structure dissection, cross-reference lookup, and AOB scanning can be combined into one conversational reverse-engineering workflow.
- Cheat Engine and its Lua bridge still require a Windows host, and native pipe mode additionally depends on pywin32.
- DBVM access, kernel-oriented memory operations, injection, and memory-protection changes are privileged capabilities with meaningful stability and security risks.
- The documented setup requires disabling Query memory region routines to avoid CLOCK_WATCHDOG_TIMEOUT crashes when DBVM or anti-cheat interactions involve protected pages.
- No relay authentication is documented in the supplied material; the README warns that anyone able to reach the TCP relay can control the bridge.
- run_command and shell_execute require CE_MCP_ALLOW_SHELL=1 and introduce an explicit arbitrary-code-execution risk.
How do you install or deploy this agent?
Use Python 3.10+ and run Cheat Engine on Windows. For native named-pipe mode, install the dependencies with:
pip install -r MCP_Server/requirements.txtOr install them manually:
pip install mcp pywin32In Cheat Engine, choose File -> Execute Script and execute MCP_Server/ce_mcp_bridge.lua. If that menu is unavailable, open Table -> Show Cheat Table Lua Script and run:
dofile([[C:\path\to\cheatengine-mcp-bridge\MCP_Server\ce_mcp_bridge.lua]])The bridge is ready when Cheat Engine prints “[MCP v12.0.0] MCP Server Listening on: CE_MCP_Bridge_v99”. For Codex, add this to ~/.codex/config.toml:
[mcp_servers.cheatengine]
command = "python"
args = ['C:\path\to\cheatengine-mcp-bridge\MCP_Server\mcp_cheatengine.py']For another MCP client, configure command as python and args as ["C:/path/to/MCP_Server/mcp_cheatengine.py"]. Restart the client after changing its configuration.
How do you use this agent?
Attach Cheat Engine to the intended process, load ce_mcp_bridge.lua, and start or restart the configured MCP client. Invoke ping first; a working connection returns an object such as {"success": true, "version": "12.0.0", "message": "CE MCP Bridge Active"}. You can then ask questions such as “What process is attached?”, “Read 16 bytes at the base address”, or “Disassemble the entry point”; the client maps these requests to the available MCP tools. For a server outside Windows, start the relay on the Windows host:
python C:\path\to\cheatengine-mcp-bridge\MCP_Server\ce_tcp_relay.py --host 127.0.0.1 --port 9876Install the TCP-only requirements where the MCP server runs:
python3 -m pip install -r MCP_Server/requirements-tcp.txtThen launch mcp_cheatengine.py with CE_MCP_TRANSPORT=tcp, CE_MCP_HOST=127.0.0.1, and CE_MCP_PORT=9876. Bind the relay only to trusted interfaces. Enable DBVM in Cheat Engine before using DBVM tools, and disable Settings -> Extra -> Query memory region routines as required by the documented BSOD warning.
How does this agent compare with similar options?
Compared with manually browsing hex dumps, tracing writers one step at a time, and relocating addresses after each update, the bridge lets an MCP client compose scans, breakpoints, disassembly, structure inspection, and AOB-signature generation. It reduces repetitive interaction and tool switching, but still depends on Cheat Engine, live target state, the client's tool selection, and human validation of the findings.