Skip to content

Releases

CS2 Map MCP 1.5

Choose a tag to compare

@Rmgs123 Rmgs123 released this 16 Nov 17:36

Update with git pull (or download the release) and restart your AI client; nothing to reinstall. Maps made with 1.4 stay current: no operation writes anything new unless you use the new options, so packages are not replayed.

Housing estates in a few operations. add_block_house builds a block of flats (concrete panel, white silicate brick, brick or plaster) with real window openings, frames and glass, entrances with a stock metal door, canopies and stair windows, balconies and a parapet. add_garage_row puts a row of lock-up garages on flat ground or along a slope, with painted sheet gates and a few open boxes you can walk into. add_yard dresses the yard between them — bushes by the walls, tyre flower beds, benches with bins facing the paths, washing lines, young trees, a playground — only on free ground, keeping the entrances and the garage drives clear. add_district with "style":"blocks" fills the horizon with an estate, and add_fence to_wall takes a fence right up to the real wall of a house. The guide has a recipe for a whole estate; everything uses stock assets, so it looks the same on every PC.

Every stock model measured. A facts index of about 12 000 stock models ships with the tools: how big each one really is, where its collision is at what height (a tree's crown at bus-roof height), where its origin sits and which parts belong to it. asset_search shows it, add_model places a prop by its real footprint (anchor) and can keep a tree's collision to its trunk ("collision":"trunk").

Problems found before the game. route_test(vehicle=...) drives your car or bus along a route offline and says where it would stop: a step, a grade, the nose at a grade break, a wall or a branch at roof height, a turn too tight. visual_check now knows where players can actually go: it reports every way out of the play area and invisible walls only where players walk up to them, and it judges doorways of turned houses with the player's real box.

What costs frames. map_info(about="cost") lists the heaviest models and meshes and what nobody in the play area ever sees; reference_compare proves with a pixel diff that removing something changed no frame.

Whole jobs as prompts. Your AI client now offers ready prompts: a new map, a map from photos, fixing what testers marked with F8, a beauty pass, testing mechanics, optimizing, preparing a release.

Checked: a demo estate built only from the new operations (checks clean, full build, frames), the self-check in CS2 (7 of 7 scenarios), the full test suite (881 tests).

1.4.1 - sounds after the CS2 update, cheaper tool updates

Choose a tag to compare

@Rmgs123 Rmgs123 released this 16 Nov 13:35

A small fix release. Update with git pull (or download the release) and restart your AI client; nothing to reinstall.

Sounds work again after the CS2 update of November 2026. The compiler now writes small constants with new KV3 types, and sound_create failed right after a good compile ("unsupported KV3 sound type 27") and took the new WAV away. They are read now, and when only reading a compiled sound back fails, the sound is kept and the result says so.

Updating the tools no longer rebuilds your maps' packages. Packages and generators used to be keyed on the tools' version, so every update replayed every package of every map (on a 24 500-node town map: about 11 minutes once). They are now keyed on the version of what operations write, which changes only when the output of an operation really changes. Maps made with 1.4.0 stay current: the same town map took 17 seconds and replayed nothing.

Riders in a bus must stand 1–2 units over the floor (floor + 1 is best). Exactly on the floor, a rider stalled the bus where the road dips; the operation now refuses such spots and the guide's example uses floor + 1.

Checked: sounds compiled by today's CS2 (mono loop, stereo, one-shot, a loop event), the pipeline of a big map after the version bump, the full test suite.

CS2 Map MCP 1.4

Choose a tag to compare

@Rmgs123 Rmgs123 released this 12 Nov 23:32

You keep using your PC while the AI builds, photographs and tests, and a small change on a big map shows up in about a minute instead of a quarter of an hour. Checked in CS2 on a 24 500-node, 270 MB town map built from 41 packages: frames, map loads and input tests ran with the game behind other windows; nothing changed — 18 s; a change in one late package — 42 s; one 2400 × 2400 zone cut, built, loaded and photographed — 50 s; after partial updates the map was proved equal to a clean replay. 840 tests and the self-check (7 scenarios with real input) pass.

  • Work in the background. Frames, map loads, script_test, route_test, playtest, probes and marks no longer bring CS2 to the front: the game keeps rendering and taking console input without the focus. game_focus chooses when the window may take it: never, input_only (default — only for a step with real mouse input, then the focus goes back) or always (as before). build_priority: low (default) runs the compiler and Blender below normal priority so the PC stays responsive. setup.ps1 asks once.
  • Status panel. python tools/panel.py (or "panel": true) opens a page on http://127.0.0.1:8717/, this PC only: what the tools do right now, jobs, the latest frames, CPU / memory / GPU load, and switches for permissions. With "heavy_builds": "ask" light bakes and releases wait until you allow each one in the panel (time and memory are shown); a job of another server process can be stopped there.
  • A fast loop on big maps — packages by hash. map_edit(name, packages=[files] | "pipeline.json") replays, in one job with one load and one save, only the packages that changed and those that depend on them; the record lives in the map. A pipeline.json manifest runs only the stale generators and can call tools as steps. dry_run proves the map equals a clean replay, and a release asks for that proof. A CS2 update that changes entity definitions replays what it affects; a map made earlier without packages is refused instead of doubled.
  • Region builds. map_build(region=box | [boxes] | "marks") cuts one zone (or the zones around players' F8 marks) into <name>_region and builds only that; when a region keeps most of the map, the result says so.
  • Offline preview. game_screenshot(window="offline") draws the saved map without CS2, with the game's framing, from above and from the side — for placement before any build.
  • visual_check on big maps keeps its findings until the map or the checks change, takes box for one zone (exactly the full check's findings in that zone), shows shares and the busiest zones. New: visual_paved_gap, visual_paved_patch.
  • add_figures puts stock T and CT agents where players hold, with "the nearest opponent sees this figure" views, to judge sight lines; check_map reminds you to delete them before release.
  • Riders in a low cabin. add_controllable car passengers.crouch: board with Ctrl+E, get off outside a door. The rules come from measurements in CS2 (feet 1 unit over the floor: 0.10° of shake parked, 1.2° at 300 u/s; cabin 60–74 units inside; seats at least 45.3 apart); bus_body takes low. E through an open doorway of a hollow body takes the wheel; a route test that circles a point it cannot turn to ends with route_stuck.
  • add_pipes and add_cables take mesh options; tools/mcp_call.py reads argument files saved with a BOM.
  • New guides and specs: pipeline, background work, panel; updated competitive, vehicles, models, quality and scripting.

Upgrading from 1.3: git pull, run setup.ps1 again (it asks about the window focus), restart the MCP server in your client. After a CS2 update: tools\python-env\Scripts\python.exe tools\selfcheck.py.

Not yet checked live: the panel started automatically by the server ("panel": true; starting it by hand is checked), the "Allow once" button of heavy_builds: ask pressed by a person (covered by tests), and a driver and passengers in a low cabin as different people at once.

CS2 Map MCP 1.3

Choose a tag to compare

@Rmgs123 Rmgs123 released this 04 Nov 09:53

Testers show the AI what they mean with one key, a hung CS2 no longer stops long sessions, and visual_check finds what a big town map needed its own scripts for. Checked in CS2: two F8 marks, one with a two-line note, came back with exact positions and frames, also after an automatic restart of a frozen Workshop Tools (100 s from the freeze to the retried call).

  • Player marks (F8). While you walk your map in CS2 Workshop Tools, press F8 at every spot worth a fix, then Y, a note and Enter (several lines are fine). The AI reads each mark with game_screenshot(views="marks"): the frame you saw, the map, the exact position and view, the time and your note. Nothing holds the game console while you play; the key is bound by game_launch only when it is free (marks_key in settings, "" turns it off); marks keep 14 days, 300 marks or 200 MB.
  • Restart of a hung CS2 (opt-in). setup.ps1 asks once. With restart_hung_cs2 the server restarts a Workshop Tools session it launched after 3 minutes of "Not responding", reloads the map, binds the marks key again and retries the call once (cs2_restart in the result); restart_hung_cs2_user also covers a session you started yourself. A game you play is never touched; unsaved Hammer edits refuse the restart. A frozen thread Windows does not flag is found too.
  • visual_check finds what hangs on, stands on and stops at something: wall units off, sunk into or past the end of their wall (visual_wall_gap), units over windows, cable ends fixed to nothing, doors drawn over windows, paving edges standing over bare ground (visual_paved_slab), invisible walls (visual_bare_clip) and fences players walk through. "Props floating over a slope" now counts mesh tops and carrying props as ground: on a big town map 440 findings became 270 (grass on banks and boxes on tables are fine).
  • Faster looks on big maps: "fullbright": true on game_screenshot views (a fast build hides objects in unbaked shadow), and the guide's batch loop: 3–8 fixes per rebuild, fast + fullbright for placement, full for the look. A frame rejected as unchanged now says whether the CS2 window lost the front or someone uses the PC.
  • add_mesh takes name and tags ("paved" makes the checks treat a mesh as paving). add_decal refuses an own material that is not an overlay (it would flicker against the wall).
  • The size test of docs/TOOLS.md counts LF bytes, so a checkout with CRLF line endings passes.

CS2 Map MCP 1.2

Choose a tag to compare

@Rmgs123 Rmgs123 released this 27 Oct 06:03

Bots on big maps no longer cost hours, and every problem AI models reported since 1.1 is fixed. Checked in CS2 on a copy of an 830 m terrain town: a nav of 69 000 areas is stopped after NAVGEN in 85 s instead of running for hours; limited to its streets it has 4 755 areas, the full build with bots takes 7.8 min and bots of both teams play; its Workshop release takes 20.5 min and uploads 190 MB instead of 871 MB.

  • Bots on big maps. Builds estimate the nav before they start (areas and the time of the one-core bot data step; check_map nav_too_big) and stop right after NAVGEN when the nav is over the limit (20 000 areas, limits.nav_max_areas) instead of running for hours; light builds skip bots beforehand when the estimate is over it. map_build takes bots and vis (null = auto). job_status shows the build stage, the nav area count and the bot data estimate while it runs.
  • set_play_area: the outline players reach; the nav only inside it, along route corridors (nav: "routes") and/or only on paved ground (paved: true), made with Valve's func_nav_markup NONAV volumes. add_nav_markup: own NONAV or seed volumes. Checks treat what lies outside the play area as background for phantom floors. Clips of fences, railings and backdrops get a nav clip twin (player clips do not stop the nav). New guide section nav.
  • Measured with the compiler and documented: the markup key is navProperty_NavGen, and a func_nav_markup counts only its first mesh, as one convex volume.
  • Release on big open maps: no VIS on worlds wider than ~310 m (hours, no gain); the nav is measured before the light bake and the release goes on without bots when it does not fit; the time limit follows the map; the light bake's work files (_vrad3, hundreds of MB) stay out of the upload; PUBLISH.md states the upload size.
  • map_build warns when a light bake will not fit in free RAM (a big map baked at 2048 px took 15 GB while CS2 still held another 16 GB).
  • New model_build template bus_body: a hollow bus or van body (floor, walls with windows and doors, windshield, roof; every piece its own collision hull) with a step well at each door, so players walk in; the bus example of the vehicles guide uses it.
  • visual_check visual_paved_lip: steps of 1–4 units where paved surfaces of different meshes overlap or meet (thin dark lines across roads).
  • add_water_body water_style: "far": an opaque sea for distant bays and water seen from above (stock water is see-through there).
  • Shape terrain absolute: true: heights are world z (by default they are added to maxs.z).
  • add_model takes any stock path, such as player agents in characters/models/... and agents/models/...; a wrong folder lists the real paths. asset_search lists stock materials whose textures are missing in the game apart (broken_stock).
  • Clearer limits: map_edit over 2000 operations says how to split; add_pipes sides 6..32 in the error; the guide names the 2000-operation and 8192-face limits.
  • tools/mcp_call.py splits a map_edit over 2000 operations and waits for a build it started (the MCP SDK client ended the server's process tree, and the build with it, when the script exited).
  • Tests: CS2MAP_OFFLINE=1 runs the suite without starting the compiler or the game.

CS2 Map MCP 1.1

Choose a tag to compare

@Rmgs123 Rmgs123 released this 26 Oct 01:50

Every problem AI models reported through my_notes(kind="feedback") since 1.0 is fixed or documented; new operations for fences, plazas and terrain; big maps are fast. Checked in CS2 on acceptance maps.

  • Fences, railings, banks, bare trees as one operation each, all following the terrain: add_fence (sheet, planks, chainlink, welded mesh, concrete panel, masonry wall with a cap; gates; a player clip for see-through kinds or on request), add_railing (render-only posts and rails with a player clip), add_bank (a steep earth bank players jump down but cannot walk up; reports climbable spots) with the terrain op bank that cuts the ground under it, add_tree (solid trunk, render-only branches). Posts are added where the ground bends, so spans neither float nor sink into a slope.
  • add_fence kinds rubble and gabion, gates closed (two leaves) and wicket with their own posts; add_utility_line: poles with crossarms and sagging wires.
  • reference_compare pairs (a sheet of photo | game rows) and plan (the map from above with photo camera marks, a grid and an aerial picture under it).
  • add_terrain layer: true: big terrains live in their own prefab file, so a map save no longer rewrites them; the build and the checks include them.
  • add_junction: one seamless paved plaza where streets meet, also at different heights — the streets give way inside the outline and every mouth meets its road at the road's own height; with "streets": [] a paved area that follows the ground.
  • Scaled copies: model_build(file="models/mcp/<own>/<own>.vmdl", scale=k) makes an own model k times bigger with its LODs and collision; add_controllable car scale multiplies every body-frame length of the recipe to match.
  • Levels of detail: model_build(lods=[...]) — simplified copies by share of triangles or hand-made levels from own models; a rebuild keeps them. Measured in CS2: the game does not switch them by distance yet (always level 0), the result says so.
  • add_model skin (a material group, checked against the compiled model; a wrong name lists the real ones) and tint.
  • tools/dependencies.py: audit asks OSV about every locked package; bump NAME VERSION --apply updates the lock, the wheel manifest and the wheel together.
  • Material patterns rubble and cobbles (tiling stones with mortar) with a palette, or palette_from a photo region.
  • UV at real size: scale:"auto" also in a face's uv and for measured stock materials; UV mode wall (level courses on a wall at any angle); bigger faces get a proportionally larger planarity tolerance (up to 0.01).
  • check_map warns bank_walkable_around when gentle ground leads round a bank from its foot to its top.
  • check_map no longer calls a bank or its terrain cut a steep_ramp; visual_check no longer reports fence rails and wall caps as floating over the terrain, and probes a sloping see-through panel at its own centre for its clip.
  • Backups 2.0: backups_dir (another disk or a synced folder; status warns when it shares a drive with the project or the addon), compressed map copies (zstd), tiers (newest 3, hourly for a day, daily for 14 days, weekly for 8 weeks, pinned), snapshots of the map's generator sources with deduplication, restore into a separate folder; tools/backups.py. Copy ids are UTC times (a time-zone change had made new copies sort before older ones).
  • add_breakable bulletproof:true: a bullet-blocking layer inside the pane that breaks with it and returns on a round restart (spawnflag 2048 lets every bullet through in CS2).
  • add_controllable refuses a car recipe that does not fit its body model (size, seat, doors, passenger spots outside the model's bounds: a bus recipe on the stock car left riders in the air); the bus example names its own body.
  • script_test step spread: shots paired with their impacts by game tick, angle and miss distance per shot (riders of a moving bus: 0.2° parked, ~0.75° at 330 u/s); use with a held key ("with":"duck"); a failed go says the target, where it stopped and what blocked it.
  • script_write(reload=true) restarts a changed script in the loaded map without a map reload (add_script names its entity mcp_script_<name>); map_edit replace_batch swaps one tagged batch of a map; the console summary at map load.
  • game_screenshot: views straight down without the player's own legs or the gun's shadow; a camera inside geometry is rejected (a flat frame with the fast build's text passed); a rejected view no longer drops the other views; view names explain their rule.
  • Vehicles: eye angles of seated players are relative to the vehicle (a car at a heading turned riders twice); the seat camera stays inside the cabin looking up or sideways.
  • map_build/lighting_build unload the map from CS2 and probe the compiled file before building; status.gpu and a hint for cards without hardware ray tracing (preset nav: bots without baked light).
  • Geometry: shell checks by nesting instead of boxes (both shells' coordinates in the error), holes triangulate in any number, cut_mesh takes a list, map_edit reports every failed operation at once; add_street smoothing, sidewalk:false and the segment in errors; materials count:[a,b], surface asphalt, material_from_reference region and a small-crop warning, material_variant explains bases without a colour texture.
  • visual_check: terrain through slabs and slabs over air (visual_terrain_through_floor, visual_floats_over_terrain; a roof on walls, a landing on a block or a cabinet on legs is carried), rotated models, plants by their trunk, support by triangles, z-fighting measured where faces overlap (20 s instead of 4 min on a 4000-mesh map), box for one zone.
  • map_create on a map open in Hammer says to close it there (it pointed to a parameter it does not have).
  • Source2Viewer-CLI 20.1 (newer KV3 types) with tools/selfcheck.py step vrf; model_build(file=...) copies any own model, also of the vehicle and weapon kits.
  • Big maps are fast: a 4000-mesh town map with a 257×291 terrain rebuilds from its batches in about 1.5 min instead of 4 and visual_check takes 30 s instead of 18 min, with the same results: grid lookups instead of whole-map scans in the phantom-floor check, cheaper z-fighting pairs, hole bridges in triangulation tried nearest first, faster self-intersection checks and DMX encoding.
  • mesh shapes are cached by content; map_edit reuses the map it has just written while the file is unchanged; map backups are trimmed after every save (backups_map_mb, newest three always kept).
  • Buses and other hollow vehicles: cars take door, exits, size, pilot (stand-in size/place), camera.pilot (driver's eyes) and passengers (doors with groups of standing spots, E prompts, riders who keep their weapons and stand upright while the body drives); reach up to 160; parts parented to a vehicle (windows) count for E; hull checks ignore carried or dropped weapons (a C4 blocked entering).
  • Riders can stand up after crouching (no teleport at a still spot; lift on stand-up while moving); prompts are cleared per player on round restart, death and a removed body; hint.blocked; players on the roof of a moving bus are put down.
  • Vehicles with passengers park (physics motion off) without a driver once they stand still on their wheels; riders are never held inside anything solid (another spot or out of a door), extra players are put out instead of standing in a moving body, getting off at speed uses a door with room or is refused, and only weapons hurt the driver and riders; hurt/killed log lines.
  • Riders are standing players held on their spots (accurate fire, crouch); hull traces never ignore entities parented to a vehicle (a driver could be put inside the body and crushed); a failed vehicle tick no longer stops its script; hud.hint/hud.labels translate the car panel; route test command v9_control_<name>_route; script_test releases held keys at the start.
  • visual_check(limit) and summary.by_code; visual_phantom_floor no longer flags narrow turned faces (sills, frames, curtains, cables).
  • Dependencies: security updates for every open advisory in the lock file — Pillow 13.0.0 (41 advisories against 12.3.0), certifi 2026.10.19 (drops the compromised emSign roots), fastmcp and fastmcp-slim 3.4.10 (authorization of transformed components), opentelemetry-api 1.45.1 (unbounded tracestate parsing).

CS2 Map MCP 1.0

Choose a tag to compare

@Rmgs123 Rmgs123 released this 09 Oct 05:56

CS2 Map MCP 1.0 — an MCP server that lets AI agents (Claude Code, Claude Desktop, Codex or any MCP client) build complete Counter-Strike 2 maps, compile them with Valve's tools, play them in CS2 and publish them to the Steam Workshop.

Highlights

  • Maps without Hammer: a lossless VMAP/DMX codec, atomic batch edits with backups, any shape from base primitives and edit_mesh (bevel, inset, extrude, twist, bend, noise...).
  • Quick builders: room layouts, an Inferno-like quarter (paving, house fronts with depth, wear, street life, light, skyline), terrain, streets, water, districts — plus your own styles saved in my/.
  • Mechanics through code: drivable car, physics drone, turrets, mini-games, weapons with your own model in the hands, 17 player abilities, hide and seek, custom HUDs and menus, stories from JSON.
  • Testing in the game: compiles with parsed errors, screenshots, real-input scenarios, walking routes, bot matches, check_map and visual_check.
  • Steam Workshop releases: map_build(name, "release") puts one map and only the files it uses into its own addon with final light, radar and upload steps.
  • After a CS2 update: tools/selfcheck.py builds a small map with every mechanic and plays it.

Install

Windows 10/11, CS2 with Workshop Tools, Python 3.14, Blender (Steam). Clone the repo and run setup.ps1 (see the README).

Feedback

Your AI logs real problems with the MCP in my/feedback.md; send it or open an issue — it is what 1.1 is built from.