Skip to main content
Glama

Set game rule

set_gamerule
Idempotent

Set a boolean or integer Minecraft game rule in the main world and return the server-reported value to verify the update was applied.

Instructions

Set a boolean or integer game rule in the main world and return the value the server now reports (check it: the plugin silently ignores values it cannot parse).

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "rule": "<rule>",
      "value": "<value>"
    },
    "name": "set_gamerule"
  }
}

Input Schema

NameRequiredDescriptionDefault
ruleYesGame rule such as 'keep_inventory' or 'mob_griefing' (legacy names like keepInventory work too).
valueYesNew value: true/false for switches, a number for counts.

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.8/5.0
Behavior4/5

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

Annotations already declare the mutation/safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the description's real contribution is the failure mode: the plugin silently ignores unparseable values, which is non-obvious and directly affects how an agent should verify success. It also discloses that the server-reported value is returned, adding behavior beyond the annotations.

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?

A single front-loaded sentence with the scope in the first clause and the caveat in a tight parenthetical. No filler, and the most important operational warning is placed where it will actually be read.

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

Completeness4/5

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

An output schema exists and annotations cover the safety profile, so the description needn't explain return values; it still adds the essential silent-failure caveat. Only the lack of explicit read-vs-write routing against get_gamerule keeps it below a 5 for a two-parameter mutation tool.

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

Parameters3/5

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

Schema description coverage is 100%, so both 'rule' and 'value' are already documented in the schema, including accepted naming and true/false vs numeric semantics. The description's mention of 'boolean or integer' only restates the anyOf types, so baseline 3 applies.

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

Purpose4/5

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

States a specific verb and resource ('Set a boolean or integer game rule') and scopes it to the main world, which tells the agent the write target. It does not explicitly differentiate from get_gamerule or the other set_* siblings, leaving that inference to the name alone.

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

Usage Guidelines3/5

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

Usage context is implied rather than stated: the main-world scope hints this is for global rule changes, and the parenthetical 'check it' gives operational guidance on verifying results. There is no explicit when-to-use or when-not-to-use versus siblings such as get_gamerule for reads.

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