Skip to main content
Glama

game_manage

Inspect the live scene tree, node properties, and UI elements of a running Godot game, and simulate keyboard, mouse, gamepad, and action inputs to interact with it.

Instructions

Runtime game inspection and input simulation.

These ops target the running game process through Godot's EngineDebugger bridge. Start the project first with project_run and poll editor_state until game_capture_ready=true.

Ops:

  • get_scene_tree(depth=10, root_path="") Inspect the running scene tree. root_path accepts an absolute runtime path or a scene-relative path rooted at the current scene.

  • get_node_info(path, include_properties=True) Inspect one running node's metadata and optional property snapshot.

  • get_ui_elements(root_path="", include_hidden=False, include_disabled=True, max_depth=10) Inspect visible runtime Control nodes for UI testing. Includes path, type, text where present, disabled state, and rect metadata.

  • input_key(key, pressed=True, echo=False) Send a key press/release to the running game.

  • input_mouse(event, position=None, button="left", pressed=True) Send a mouse motion or button event. event: "motion" | "button". position is a {x, y} object or [x, y] array; omit it to use the game's current cursor position. A present but malformed position is rejected rather than silently falling back to the cursor.

  • input_gamepad(device=0, control="button", index=0, pressed=True, value=0.0) Send a joypad button or axis event. control: "button" | "axis".

  • input_action(action, pressed=True, strength=1.0) Set a project action's pressed state directly in the running game.

  • input_sequence(steps, settle_frames=0) Apply a frame-timed action timeline in one call — the frame-accurate, multi-step form of input_action. Each step is {at_frame, action, pressed=True, strength=1.0}; the game applies each step's action on its scheduled frame, awaits settle_frames more, then replies once. Use this instead of separate input_action calls whenever timing matters (jump arcs, combos, walk-into-trigger): per-call network latency makes hitting a target frame impossible otherwise. Steps must be ordered by non-decreasing at_frame; frames (not ms) are the timing basis. Action-based input is focus-independent, so it works on a backgrounded game window. Cannot run inside batch_execute.

  • input_state(actions=None) Read current action pressed states. Empty actions = all project actions.

Canonical call shape: {"op": "<verb>", "params": {...}}. Flat op parameters are accepted as a compatibility alias when the client transmits them; op and session_id remain top-level.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
opYes
paramsNo
session_idNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations present, the description carries the full burden of behavioral disclosure. It reveals important traits: 'A present but malformed position is rejected rather than silently falling back to the cursor,' 'Action-based input is focus-independent, so it works on a backgrounded game window,' and 'Cannot run inside batch_execute.' It also describes replies, state reads, and the effect of each op on the running game.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but appropriately structured: a one-line summary, a prerequisite note, then a consistent bulleted list of ops with syntax and parameter details. The canonical call shape paragraph adds useful invocation context without redundancy. Every sentence provides valuable information; nothing is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with nine sub-operations, a minimal schema, and no annotations, this description is remarkably complete. It covers prerequisites, parameter semantics, timing and ordering constraints, return metadata (e.g., 'Includes path, type, text where present'), and usage exclusions. An agent can confidently select the right op and invoke it correctly without additional information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only defines an `op` enum and a generic `params` object with additionalProperties true, offering zero parameter descriptions. The description compensates fully by detailing every parameter for each operation, including types, defaults, and constraints such as get_scene_tree's root_path behavior, input_mouse's position format and malformed-value handling, and input_sequence's step ordering requirement.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Runtime game inspection and input simulation,' which is a specific verb+resource statement that clearly distinguishes this tool from sibling tools like editor_manage or scene_manage. It then enumerates nine distinct operations with clear names and one-line purposes, leaving no ambiguity about what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly states the prerequisite: 'Start the project first with project_run and poll editor_state until game_capture_ready=true.' It also provides usage guidance within the tool, e.g., 'Use this instead of separate input_action calls whenever timing matters' and 'Cannot run inside batch_execute,' which tells the agent when to use this tool and when not to.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/hi-godot/godot-ai'

If you have feedback or need assistance with the MCP directory API, please join our Discord server