Claude Bridge for s&box (The most comprehensive and complete bridge tool set available for S&box.)
 

⚡ Start here: the one-command plugin (recommended)

1. /plugin marketplace add LouSputthole/Sbox-Claude — registers the repo as a plugin source
   
   
2. /plugin install sbox-claude — installs the plugin
   
   
3. Restart Claude Code (or run /reload-plugins)
   
   

• The brain — sbox-cookbook, a code-grounded recipe library of how real s&box games are built (the #1 reason to use this — see below). Along with Live S&box API look up.
  
  
• A specialist agent tuned to build games with the bridge — it knows the workflow, the gotchas, and when to reach for the cookbook.
  
  
• The screenshot workflow skill — codifies the build → screenshot → verify → fix loop so Claude isn't building blind.
  
  
• Onboarding — on first connect it checks the bridge, detects your libraries, and suggests a first move.
  
  

🧠 The brain: build like a real s&box game, not a guess

• Genre playbooks — tycoon / idle, shopkeeper / management, deathmatch / arena, platformer / obstacle course, survival / horror, card-battler, gacha / dungeon-crawler, social-hub, document / inspection sim, puzzle, sandbox / voxel, vehicles, roleplay. Each gives you the system stack to compose, a build order, and how real games did it.
  
  
• Game systems — inventory, economy / currency, shop / vendor / trading, save / persistence, progression / upgrades / prestige, gacha / loot tables, leaderboards, idle / offline earnings, building & placement, crafting, dialogue, round / match flow, spawning & waves, anti-cheat.
  
  
• Engine fundamentals — networking & authority, architecture, player controller, Razor UI, weapons / combat, input, physics & traces, component lifecycle, world-gen & rendering, performance & threading, data assets.
  
  

How it works

You: "Make a player controller with WASD, mouse look, double-jump, and a flashlight." Claude: writes the script, adds the component, wires the input, sets up the spotlight — then aims a camera, screenshots it, and checks its own work.


You: "Build me an inventory system with a hotbar." Claude: opens the cookbook's inventory recipe, builds it the way real games do (host-authoritative items, networked, drag-and-drop UI) — then runs networking_lint and inspect_networked_object to confirm it actually replicates.

What it can do (205+ tools · 197 handlers)

sbox-claude — Claude Code Plugin

What's new?  (Frequently updated and improved)

[1.18.0] -- 2026-07-02

• add_lipsync -- wire up Sandbox.LipSync, the component Facepunch shipped 2026-07-01 (the lipsync/viseme Sound Editor update): drives a SkinnedModelRenderer's facial morphs from a playing sound. One call adds LipSync, wires the renderer (same GameObject or rendererId), and optionally binds audio -- an existing sound component, or a new SoundPointComponent loaded from a .sound path -- plus morphScale / morphSmoothTime tuning. Morphs animate at runtime while the sound plays (verify in play mode via capture_view). New LipSyncHandlers.cs; tool lives in characters.ts.
  
  

• create_round_state_machine (5x demand -- the top ask) -- the full state-machine beyond create_round_phase_machine: a sealed manager singleton ([Sync(SyncFlags.FromHost)] StateIndex, index-wrap advancing, CanEnter() skip) driving an abstract RoundState base (Begin/Tick/OnTimeUp/Finish lifecycle, per-state [Sync] TimeUntil) plus N sealed named-state stubs that auto-attach on start. Transitions announce via a static event + [Rpc.Broadcast] mirror with per-index dedupe (never double-fires; [Sync] index is the late-joiner reconcile). New RoundStateMachineHandlers.cs + roundstate.ts.
  
  
• add_interaction_station -- a one-occupant IPressable station (crafting bench / shop till / arcade cabinet): occupancy held as a [Sync(FromHost)] Guid (GameObjects aren't [Sync]-able), client Press() routed host-side via [Rpc.Host], a reservation grace window (TimeUntil) for the last user, an optional unlock-level gate via a static ResolveUserLevel hook, and a static OnStationOpened event to open your overlay UI. New InteractionStationHandlers.cs + stations.ts.
  
  
• create_event_director -- a generalized L4D-style pacing director: interval roll (host-only), cumulative-weight pick over EventPrefabs + parallel Weights, active-set dedupe, MaxActive cap, and a generated *TimedEvent companion so every spawned event self-destructs after EventLifetime. RollInterval() is the documented adaptive-pacing extension point. New EventDirectorHandlers.cs + director.ts.
  
  
• create_save_slots -- the multi-slot companion to create_save_system: a saveslots.json manifest (per-slot Used/Name/SavedAtUnix/PlaytimeSeconds -- the slot-picker read) + per-slot payload files over FileSystem.Data, versioned POCO with delete-on-version-mismatch, and optional GUID scene reconciliation (sceneReconciliation: true -- tombstone destroyed objects, reposition survivors). New SaveSlotsHandlers.cs + saveslots.ts.
  
  

• debug_draw_line / debug_draw_ray / debug_draw_box / debug_draw_sphere / debug_clear — world-space debug primitives on a NotSaved ClaudeDebugDraw holder; render via Gizmo.Draw in the editor viewport and Scene.DebugOverlay in play (the latter capturable via capture_view). Visualize raycast hits / overlap volumes / trigger bounds / NPC sight ranges / patrol paths. Live-verified both render paths.
  
  
• Limitation: edit-mode gizmos show in the live editor but NOT in take_screenshot/screenshot_from (the gizmo pass isn't in that camera render) — use capture_view in play mode to see them through the bridge.
  
  

• set_time_scale — play-mode time control (Scene.TimeScale): 0 pause, 0.1 slow-mo, 2+ fast-forward. Errors outside play mode. Returns applied + previous.
  
  
• get_profiler_stats — read-only Sandbox.Diagnostics.PerformanceStats dump: FPS, frame/GPU ms, allocations, memory, exceptions, per-category timings averaged over frames.
  
  
• Partial Unity carry-over wave; debug_draw_* and run_tests (plan: docs/plans/2026-06-17-unity-carryover-meta-tools.md) still pending.
  
  

• create_leaderboard_panel -- scaffold a Razor PanelComponent leaderboard bound to Sandbox.Services.Leaderboards (Get/Refresh(CancellationToken) -- CancellationToken required, verified live): fetch cooldown, BuildHash override, long->int rank cast. The first scaffold that emits both a .razor and a .razor.scss; passes razor_lint by construction. Compile-verified live.
  
  
• create_inventory -- slot-based inventory: parallel ItemIds/Counts lists, stack-first TryAdd with rollback, TryRemove/CountOf/Move/Clear, static OnChanged. The largest SYSTEMS table in the 51-game corpus (8 games) now has a scaffold. Compile-verified live.
  
  
• create_stat_modifier_system -- Set->Add->Mult stat engine: generated {name}Stat enum, modifiers keyed by source for clean removal, priority resolution, OnStatChanged. The substrate for the entire progression-upgrades corpus (8 games). Compile-verified live.
  
  
• create_placement_mode -- two-phase ghost->commit builder: client-local ghost (NetworkMode.Never, tinted), camera.ScreenPixelToRay mouse ray (API verified -- GetMouseRay does not exist on this SDK), grid snap, host-side re-validation + NetworkSpawn commit. Compile-verified live.
  
  
• Review hardening (Opus deep sweep): create_networked_player moveSpeed param now actually used (was silently ignored); atomic temp+rename IPC response writes (poller can never read a half-written response); get_all_properties unused includeInherited param removed from schema; stale MathX-only comments corrected in scaffold generators.
  The verify-gate works: four real API/codegen bugs caught before shipping -- Board.Refresh needs CancellationToken, GetMouseRay does not exist (ScreenPixelToRay is real), inventory empty-string escaping, leaderboard rank cast. All caught by generate->hotload->compile-check, not by review.
  
  

• create_interactable -- Component.IPressable scaffold: Press/Look/Hover/Blur/CanPress/GetTooltip + IsProxy guard. The interaction primitive every genre recipe depends on. Compile-verified live.
  
  
• create_weighted_loot_table -- parallel Names/Weights lists, cumulative-weight Roll(), optional pity via PityAfter. The canonical weighted-pick that 7 corpus games hand-rolled independently. Compile-verified live.
  
  
• sandbox_lint -- pre-compile whitelist scan of Code/*.cs: flags Array.Clone() (still blocked), System.Net.*, other known-blocked BCL members with file+line + fix suggestion. Catches whitelist errors before hotload, with a line number.
  
  
• create_save_system -- versioned POCO + FileSystem.Data.WriteJson/ReadJsonOrDefault, dirty-flag autosave, clamp-on-load Sanitize(), delete-on-version-mismatch, IsProxy guard. The #1 corpus demand (7x). Compile-verified live.
  
  
• razor_lint -- static scan of .razor/.razor.scss for Razor transpiler footguns: switch-expressions in @code, non-ASCII in @code, PanelComponent missing BuildHash, root type-selector SCSS. The "valid code, opaque crash" bug class.
  
  
• copy_asset_with_dependencies -- copies an asset + full dependency closure (Editor.Asset.GetReferences(deep:true)), shadow-guards both dependency paths and destination against core trees (models/citizen, models/dev, materials/dev, materials/default). Kills gotchas #4 and #5 (ERROR mesh + endless recompile from shadowing).
  
  
• CI gate: scripts/audit-parity.mjs (TS<->C# parity + 4-way version lock) + .github/workflows/ci.yml (runs on push/PR to main).
  
  
• Syntax gate: scripts/check-csharp-syntax.py (tree-sitter pre-sync parse of all .cs addon files; known FP on CreateSaveSystemHandler $@-template region -- treat advisory).
  
  
• Whitelist correction: System.Math and System.MathF NOW COMPILE in s&box game code on the current SDK -- the old "MathX only" rule was stale. Array.Clone() is still blocked. CLAUDE.md and docs/BRIDGE_GOTCHAS.md corrected; sandbox_lint tuned accordingly.
  
  
• Bridge map: full semantic rebuild without an API key (3548 nodes / 4473 edges / 257 communities, 50 human-named). Previous graph was code/AST only.
  
  

• create_round_phase_machine — scaffold a host-authoritative [Sync(SyncFlags.FromHost)] phase machine: a CurrentPhase enum cycled on a per-phase TimeUntil timer (host-only), per-phase duration [Property]s, a Loop toggle, a StartPhase(Phase) host-jump, and a static OnPhaseChanged event that fires uniformly on host + proxies. Round/match flow, day-night gates, match phases. Generated code compile-verified live.
  
  
• create_day_night_clock — scaffold a host-authoritative time-of-day clock: [Sync(SyncFlags.FromHost)] TimeOfDay (0–24) + Day advancing by Time.Delta, IsDay/IsNight from sunrise/sunset hours, and static OnNewDay / OnDayNightChanged events. Generated code compile-verified live.
  
  
• With v1.10.0's create_economy_wallet, these form a "game director" trio (currency + round-flow + time). The remaining ~180 mined tool ideas stay queued in docs/TOOL_BACKLOG.md.
  
  
• Cookbook fully re-mined: the v1.10.0 release corpus-refreshed 18 references; v1.11.0 finishes the job — all 41 existing references (engine + systems + genres) now carry a "Corpus refresh (2026)" section grounded in the 51-game findings, alongside the 8 new references + CORPUS-INDEX.md.
  
  

• invoke_method — call a component method by name with arguments (reflection + coercion, matched by name + arg-count); the args-capable companion to invoke_button.
  
  
• ensure_input_action — add a custom input action to the project .sbproj (Metadata.InputSettings.Actions[]) so Input.Pressed("X") resolves (restart to take effect in play mode).
  
  
• drive_player / drive_player_status (EXPERIMENTAL) — drive the active PlayerController directly across play-mode frames (sets EyeAngles + analog wish state by reflection + holds a named action down so Input.Pressed catches an edge). A partial answer to "the bridge can't synthesize gameplay input" — still no substitute for a human playtest (see docs/BRIDGE_GOTCHAS.md #1).
  
  
• create_economy_wallet — scaffold a host-authoritative [Sync(SyncFlags.FromHost)] currency component (AddMoney/TrySpend/SetMoney/CanAfford + OnMoneyChanged). The first of the mining-surfaced scaffolds; generated code compile-verified live. The v1.11.0 queue of ~180 more mined tool ideas is in docs/TOOL_BACKLOG.md.
  
  
• 8 fixes: set_transform flexible scale (number / "x,y,z" / object); create_gameobject parentId; duplicate_gameobject + grid_duplicate in edit mode; place_along_path deterministic yaw; execute_csharp stale-file sweep + multi-line bodies; spawn_model bad-path → warning (not false success); widened vector/color coercion; get_compile_errors cascade filter.
  
  
• 2 auto-detected gotchas: "Default Surface not found" on raycast/raycast_terrain → a clear {recoverable, recovery:"restart_editor"} hint; install_asset/trigger_hotload warn on a new PackageReference. New docs/BRIDGE_GOTCHAS.md documents the engine limits that aren't code-fixable.
  
  
• Cookbook expansion: the sbox-cookbook brain was re-mined across 51 open-source games (was 47) — +6 genres (social-deduction, survivor-roguelite, coop-kitchen, board-game, casino-gambling, physics-sports) + 2 systems (ai-director, services-backend), high-traffic references enriched with a "Corpus refresh" pass, and a new references/CORPUS-INDEX.md cross-reference so recipes compose across games. Per-game mining lives in the local sbox-lessons/mining-v2/.
  
  

• A brain that knows real games — the companion plugin now bundles sbox-cookbook, a code-grounded recipe library mined from real, shipped, open-source s&box games + the modern engine source. Genre playbooks, system how-tos, and engine references mean the AI builds inventories, economies, saves, shops, gacha, progression, and netcode the way shipped games do — not from a guess. See The brain above.
  
  
• Inspection & validation (+6 tools) — the AI can now verify what it builds:
  
  
  • inspect_networked_object — dump one object's Network.* state plus every component's [Sync] fields (flags + live values) — see exactly what replicates.
    
    
  • networking_lint — static scan for multiplayer footguns: unguarded [Sync] mutators, money/health/score as plain [Sync], collections as [Sync], [Rpc.Host] methods that never re-check the caller.
    
    
  • scene_validate — flags scene-setup footguns: no camera, stray root Rigidbodys, IsTrigger-vs-trace mismatches.
    
    
  • save_inspect — list / read / diff the project's FileSystem.Data save files.
    
    
  • services_query — read Sandbox.Services stats + leaderboards.
    
    
  • simulate_input — drive named input actions in play mode.
    
    
  • All six are confirmed live against the SDK. Additive — no existing tool contract changed.
    
    

• See the running game — capture_view captures the live game in play mode (player POV + HUD), not just the edit scene. The bridge's first real play-mode eyes.
  
  
• NPCs that hunt — create_npc_brain generates a full behavior state machine (patrol → chase → search, with FOV cone + line-of-sight + hearing and 5 presets) that animates as it moves; plus patrol routes, wave spawners, and an edit-mode perception checker.
  
  
• From scene to game — gameplay scaffolds (create_health_system, create_pickup, create_objective_system, spawners) + wiring tools (set_component_reference, add_component_to_new_object) turn placed objects into a playable loop. A bundled sbox-scaffold-game skill assembles a first-person starter in one ask.
  
  
• Trust & correctness — a run_self_test health check, plus fixes under the hood: set_property now sets model/asset/object references reliably, create_material / load_scene / stop_play repaired, and an upgraded create_player_controller (first-person / third-person / top-down + auto scene placement).
  
  

• Bring characters to life — set_animgraph_param drives a Citizen's AnimationGraph (walk, crouch, aim, gestures); play_animation plays a named sequence; list_animations shows every animation a model has (a Citizen has 500+).
  
  
• See it from every side — screenshot_orbit captures an object from several angles in one call, so Claude can verify 3D work from the front, back, and sides instead of guessing from a single view.
  
  
• Know how big things are — get_bounds returns an object's world-space size, center, and extents for precise placement and framing.
  
  

• Claude reads its own errors — read_log + get_compile_errors surface compile failures and logs, even when the editor has stalled. No more guessing.
  
  
• Aimed screenshots — screenshot_from points the camera at any object/point so Claude can actually see what it built (and fix the angle).
  
  
• Builds on what you already have — list_libraries detects installed addons (like the Shrimple Character Controller) so Claude drives them instead of reinventing.
  
  
• Compile-from-the-bridge — recompile_asset compiles a material/asset Claude writes or edits.
  
  
• Nav + spatial — bake navmesh, query paths, sphere/box overlap.
  
  
• Auto-restart — the bridge can restart the s&box editor itself (restart_editor) to recompile and apply changes, so new code and bridge updates take effect without you manually restarting. Claude closes its own edit → compile → verify loop.
  
  
• In-session docs search — query the official s&box docs without leaving the conversation.
  
  
• Security & correctness pass — handler errors now report failure (previously masked as success), path-traversal protection on all file ops, atomic IPC, and honest tool schemas.
  
  

• Honest connection status — a real heartbeat replaced the old "always connected" false positive; a closed/crashed editor now shows as disconnected within seconds.
  
  
• Frame loop runs without the dock — the request queue + heartbeat moved to a static frame handler, so tool calls process whether or not the Claude Bridge dock is open on-screen.
  
  
• Clearer timeouts — they now tell you which side failed (editor not running, wrong temp dir, stalled handler, IPC mismatch). Realign with SBOX_BRIDGE_IPC_DIR.
  
  
• Editor bootstrap crash fixed.
  
  

Under the hood

• File-based IPC — no network, no open ports. The MCP server writes request files to a temp dir; the addon polls them inside the editor, runs them on the main editor thread, and writes responses back. Everything stays on your machine.
  
  
• Two pieces — a Node.js MCP server (talks to Claude Code) + a C# editor addon (does the work in s&box).
  
  
• Self-verifying — Claude screenshots its work, reads its own logs/compile errors, and can lint networking + inspect what replicates, so it can close the build-and-check loop instead of hoping.
  
  
• Fault-tolerant — a single broken tool is isolated; it can't take the whole bridge offline.
  
  
• Path-safe & play-mode-safe — file ops are confined to your project; scene edits are refused during play mode with a clear error.
  
  
• Library-aware — detects the addons already in your project and builds on them.
  
  

Install

1. Install Node.js 18+ → https://nodejs.org/
   
   
2. Install Claude Code, if you don't have it → https://docs.anthropic.com/en/docs/claude-code
   
   
3. Register the server in a terminal:
   
   

4.  claude mcp add sbox -- npx sbox-mcp-server@latest

5.  (Works with any MCP client, not just Claude Code — you just don't get the bundled brain/agent/skill.)
   
   

"Create a cube at 0, 0, 100 with a box model."
 "Write a player controller with WASD and mouse look."
 "Build me a host-authoritative currency system." (watch it reach for the cookbook)

Architecture

Claude Code  ──stdio──>  MCP Server (Node.js)  ──file IPC──>  Editor Addon (C#)  ──>  s&box Editor
                                                  %TEMP%/sbox-bridge-ipc/

Full tool list

Troubleshooting

Updating

• Addon: reinstall from the Asset Library when a new version drops.
  
  
• MCP server: npx sbox-mcp-server@latest pulls the newest version on the next Claude session (the plugin does this automatically).
  
  

Compatibility

Tips

• Use the plugin. The cookbook brain + specialist agent + screenshot skill is most of the value, and it's one command.
  
  
• Save before a big batch. Hit Ctrl+S, then turn Claude loose.
  
  
• Use Git for your project — keep .scene files under version control for anything non-trivial.
  
  
• Ask for systems by name. "Build me an inventory / a save system / a host-authoritative economy" lets the brain route you to a proven recipe.
  
  
• Don't mutate the scene during play mode — the bridge will refuse with a clear message.
  
  

License

Links

•  Docs: https://sboxskins.gg/claudebridge — overview · plugin · changelog · troubleshooting · FAQ 
  
  
• GitHub: https://github.com/LouSputthole/Sbox-Claude
  
  
• Issues / bugs: https://github.com/LouSputthole/Sbox-Claude/issues
  
  
• npm: https://www.npmjs.com/package/sbox-mcp-server
  
  
• Feedback: [email protected]
  
  
• Community S&box Skin Marketplace:
  
  sboxskins.gg

  sboxskins.gg — S&box Skin Market Tracker

  Live S&box cosmetics market data — prices, order books, supply, and trends from the Steam Community Market. The go-to tracker for every sbox skin.

A note on the thumbs down