blender-research-mcp

by Haiyang-Bian

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.9.0
Disambiguation4/5
The hierarchical domain prefixes make most tools easy to distinguish, and inspect vs. action tools are generally clear. However, object.set overlaps with object.transform and object.visibility.set, while application.status and connection.ping have ambiguous boundaries.
Naming Consistency4/5
Most tools follow a predictable lowercase dotted prefix.action or prefix.subdomain.action pattern. Minor inconsistencies exist: object.visibility.set places the verb last, while modifier.set_state, shape_key.set_value, and material.set_input use compound verb_noun actions.
Tool Count2/5
42 tools far exceeds the 25+ threshold and feels heavy for even a broad Blender domain. Several status and inspection tools could be consolidated without losing capability.
Completeness4/5
The tool surface covers project, object, material, texture, image, lookdev, render, and transaction workflows with few dead ends. Obvious gaps include material/image deletion, collection management, and explicit object selection mutation.
Average 3.6/5 across 42 of 42 tools scored. Lowest: 2.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 41 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=true, so the description only needs to add context. It does add that changes are absolute and transaction-scoped, which reinforces mutation semantics. However, it does not clarify what 'destructive' means in practice, such as which existing values are overwritten or how expected_scene_generation participates in safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence with no filler or redundant statements. It is front-loaded with the main action. The brevity is a strength, though it sacrifices important coverage of the tool's full behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity — 8 parameters, 4 required fields, nested patch objects, and multiple transform aspects — the description is incomplete. It omits location and rotation entirely and does not explain the required transaction/idempotency/generation semantics. An output schema exists, so return-value details are less critical, but the tool still needs more context to be called correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It only hints at the scale patch fields and says nothing about location, rotation_euler_degrees, transaction_id, idempotency_key, expected_scene_generation, or expected_object_identity. This leaves most parameter semantics undefined for an agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete action and resource ('Set one or more local object scale axes'), but it only mentions scale, while the schema also supports location and rotation_euler_degrees. This makes the description misleading for an agent trying to understand the actual scope of object.transform, and it does not clearly distinguish the tool from sibling setters like object.set.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus alternatives such as object.set or object.visibility.set. The phrase 'inside the active transaction' provides context, but it does not explain prerequisites, exclusions, or why an agent would choose object.transform over another tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already disclose destructiveHint=true and idempotentHint=true, so the safety profile is known. The description adds that both property deltas and the captured user context are restored, which is useful behavioral context. However, it doesn't explain what happens to the transaction lifecycle, whether a rollback can be reversed, or failure behavior in an open-world scene.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence with no filler and is easy to parse. It could be slightly more informative, but as far as structure and economy of language, it earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though an output schema exists and annotations carry some safety signals, the description leaves out important contextual information: when to roll back, what the three required parameters mean, and how this relates to transaction.begin/commit/context.restore. For a destructive transaction operation, this is not complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate. It never explains transaction_id, expected_scene_generation, or idempotency_key, nor how they relate to the restoration process. This is a critical gap for correct invocation.
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?
The description uses a specific verb, 'Restore', and names the resource: transaction property deltas and the captured user context. This distinguishes it from transaction.begin and transaction.commit at a basic level, but it doesn't explicitly contrast it with context.restore or transaction.commit, so it's clear but not fully differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance about when to use this tool as opposed to transaction.commit or context.restore. The phrase 'restore transaction property deltas' implies a rollback operation, but no prerequisites, conditions, or alternative tool mentions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says 'Store the current user context in Blender', which describes a state-changing write operation, while the annotations declare readOnlyHint=true. This is a direct contradiction comparable to the create_record example. The description does not add useful behavioral context beyond the annotations and instead misleads about the side effects.
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 a single concise sentence that front-loads the core action and result. There is no wasted wording, and the syntactic structure is clean.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and output schema, the description still leaves important context unexplained: the role of viewport_id, when to snapshot versus get/restore, and the lifecycle or scope of the returned token. The annotation contradiction also makes the description incomplete and unreliable as a guide.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention the viewport_id parameter at all, and schema description coverage is 0%. The schema only provides the title 'Viewport Id' and a null default, which gives no real semantic meaning about what viewport_id selects or how it affects the snapshot.
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 clearly states the action ('Store'), the target ('current user context in Blender'), and the result ('return a session-local token'). It is easy to distinguish from siblings like context.get and context.restore because it frames the tool as creating a snapshot for later use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool instead of context.get or context.restore. The description implies a snapshot/restore workflow but does not explicitly state when to snapshot versus when to retrieve or restore context, leaving the selection decision to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some behavioral context beyond annotations by mentioning 'before/after context' and 'consistent semantic views,' but it does not explain what 'object evidence' means or what the captured output contains.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It conveys the core action and key qualifiers efficiently, though the phrase 'semantic views' and 'object evidence' are somewhat abstract and could be clearer.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should explain what the tool returns, but it does not. It also omits important behavioral details around the six parameters, the meaning of 'before/after context,' and how this bundle differs from a simple viewport capture. The presence of read-only and idempotent annotations helps, but the missing output and parameter semantics leave notable gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the burden of explaining parameters. It adds partial meaning: 'one to three' maps to the views array constraints and 'object evidence' hints at object_name, but it provides no guidance on max_size, overlays, viewport_id, or display_mode, which remain unexplained.
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?
The description uses a specific verb ('Capture') and names a defined resource ('one to three consistent semantic views') along with meaningful qualifiers ('before/after context and object evidence'). It gives a clear idea of what the tool produces, though it does not explicitly name sibling tools to differentiate itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus siblings like viewport.capture, context.snapshot, or object.inspect. There are no stated conditions, exclusions, or references to alternative tools, leaving the agent to infer when observation.bundle is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and idempotentHint=true. The description adds that the transaction is 'single', 'reversible', and 'preview'-oriented, which gives useful context beyond the annotations. However, it does not explain what happens if a transaction is already active or how idempotency is enforced; no contradiction with annotations exists.
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 a single, front-loaded sentence with no filler words. Every term contributes to the core action and scope, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having annotations and an output schema, the description omits critical operational context: the meaning of expected_scene_generation, the role of idempotency_key, and how this transaction relates to commit/rollback. For a mutating tool with required parameters and a destructive hint, this is a significant completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description says nothing about the four parameters: label, viewport_id, idempotency_key, and expected_scene_generation. An agent cannot infer the meaning of expected_scene_generation or how to generate a correct idempotency key from the description alone, so the description fails to compensate for missing schema docs.
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?
The description uses a specific verb ('Begin') with a clear resource ('reversible preview transaction') and scope ('for this Blender instance'). It distinguishes itself from transaction.commit and transaction.rollback by naming the action as beginning, though it does not explicitly reference those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to begin the transaction versus when to use commit/rollback, nor any mention of prerequisites such as matching expected_scene_generation or ensuring no existing transaction. The only usage signal is the verb 'Begin', which is insufficient for an agent to sequence actions correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already supply readOnlyHint=false, idempotentHint=true, and destructiveHint=true, so the safety profile is mostly structured. The description adds context about uniqueness and transaction-scoped creation, but it does not explain why destructiveHint=true applies or what effect creating inside a transaction has on existing scene state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler or redundant restatement of the tool name. It front-loads the core action and scoping constraint. The main issue is not length but clarity of the specialized terminology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has four required parameters, no schema descriptions, and important sibling context around transactions and material workflows. The description does not connect create to transaction lifecycle concepts, idempotency, or scene generation expectations, so an agent lacks enough context to invoke it correctly in a real workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It does not clarify transaction_id, expected_scene_generation, idempotency_key, or how the MaterialDefinition should be structured beyond the vague phrase 'bounded semantic surface values'. This is insufficient for an agent to confidently construct the required arguments.
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?
The description clearly states a specific verb and resource: 'Create a uniquely named canonical Principled PBR material'. It also hints at a distinguishing constraint, uniqueness and being inside an 'active structural transaction', which helps separate it from material.set_input or material.assign. However, phrases like 'canonical' and 'bounded semantic surface values' are jargon-heavy and less operational than they could be.
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?
The description implies a prerequisite: the creation must happen 'inside the active structural transaction'. This gives some context about when the tool is appropriate, but it does not explicitly say when to prefer this over siblings such as material.set_input, material.assign, or transaction.begin, nor does it state any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation as destructive and idempotent, so the description's added value is the rollback-restore behavior and the scoping to an 'exact inspected' link set rather than broad channel clearing. This provides meaningful context beyond the structured annotation fields. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence with no redundant wording, and the main action is front-loaded. Its terseness is a minor weakness because important behavioral and parameter context is omitted, but as a concise sentence it is well-formed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive, transactional, 11-parameter operation with optimistic-concurrency expected values, the description is far too incomplete. It does not explain how to obtain the expected identities, that the tool must run within an active transaction, or what 'exact inspected' requires in practice. The presence of an output schema does not compensate for missing invocation guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description carries the full burden of explaining 11 parameters, but it only hints at 'channel' and 'incoming link set' (expected_link_identities). It does not explain transaction_id, expected_material_identity, expected_node_identity, expected_material_users, expected_scene_generation, idempotency_key, or allow_shared, which are all essential to calling the tool correctly.
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?
The description names a concrete action ('clear') on a specific resource ('incoming link set' on a 'Principled semantic channel'), and the sibling tool list includes material.texture.bind, making the intended operation distinguishable. It is clear enough despite depending on domain jargon like 'Principled semantic channel' and 'structural transaction.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit guidance on when to use this tool versus alternatives such as material.set_input or material.texture.bind. The rollback mention implies a transactional context, but it never states 'use inside a transaction' or identifies when this tool should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as non-read-only, idempotent, and destructive, and the description does not contradict them. The description adds useful transaction-scoping behavior, but does not explain destructive consequences, concurrency expectations, or failure modes beyond the schema's expected_* fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It efficiently communicates the core action, target resources, and transaction requirement, though it is slightly compressed given the complexity of the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 12 parameters, zero schema descriptions, and a transaction-based API, the description is incomplete. It omits how expected_* fields work, what 'exact local environment image' means, and how the transaction lifecycle constrains invocation. The presence of an output schema helps with return values but not with input semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description had to compensate for explaining 12 parameters. It only gestures at 'World background' and 'environment image', while required fields like transaction_id, expected_scene_generation, idempotency_key, and the expected_* optimistic concurrency fields remain unexplained.
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?
The description states a clear action ('Create or modify') on a distinguishable resource ('current World background' and 'optional exact local environment image'). This is enough to set the tool apart from generic object/scene tools like object.set or scene.camera.set. However, 'exact local environment image' is domain-specific and not fully explained.
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?
The phrase 'inside the active structural transaction' gives an explicit context constraint: this must be called within a transaction lifecycle, likely between begin and commit/rollback. It does not state exclusions, when not to use it, or which sibling tools would be better for related but different operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructive and idempotent behavior, so the description mainly adds context beyond them. The statement that 'existing links require an exact replacement guard' warns about replacement behavior and implies that pre-existing connections are affected. It does not fully explain what gets destroyed, but combined with destructiveHint=true this is reasonably transparent.
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?
Two short sentences, no filler, key action front-loaded. The first sentence states the operation and target, and the second adds an important constraint. Every word earns its place despite some jargon.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex 17-parameter, 12-required-parameter tool with concurrency guards and identity expectations, this description is far too thin. It gives no guidance on how expected_* identities work, what transaction_id/idempotency_key are for, what mapping or coordinates mean, or when allow_shared/replace_existing should be true. The output schema exists, but the description still leaves an agent guessing about most required inputs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for 17 parameters and 12 required fields. It provides only broad hints: 'exact local image' maps to image identity parameters, 'Principled PBR channel' maps to channel, and 'replacement guard' hints at expected_link_identities/replace_existing. Most parameters—transaction_id, all expected_* fields, idempotency_key, mapping, coordinates, allow_shared—remain unexplained.
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?
The description uses a specific verb ('Bind') and identifies the resource and destination: 'one exact local image' through 'semantic mapping nodes' to a 'Principled PBR channel.' This makes the tool's core function understandable and distinguishes it from generic material setters. However, the phrase 'generated semantic mapping nodes' is jargon and does not clearly separate it from sibling tools like material.set_input or material.texture.clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit statement about when to use this tool versus alternatives, and no named sibling or exclusion condition. The line 'Existing links require an exact replacement guard' hints at a precondition but does not tell an agent when this tool is appropriate or when to choose material.texture.clear or material.set_input instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate readOnly=false, destructive=false, idempotent=true, and the description adds only 'session-local' and 'previously captured' context. It does not explain whether restoring overwrites the current context or what happens with an invalid snapshot_id, though it does not contradict 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?
The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the verb, the object, and the scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter restore operation with an output schema and annotations, the description is minimally adequate. However, it lacks explicit context about how restoration affects the current session state and how this tool relates to context.snapshot and context.get.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description never mentions snapshot_id or how it is obtained. The parameter name is self-explanatory to a degree, but the description does not compensate for the missing schema documentation or connect snapshot_id to context.snapshot.
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?
The description clearly identifies the action ('Restore'), the resource ('previously captured session-local Blender context snapshot'), and the scope ('session-local'). It does not explicitly differentiate from sibling tools like context.snapshot or context.get, so it relies on semantic inference rather than explicit contrast.
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?
The phrase 'previously captured' implies that a snapshot must already exist and suggests a prerequisite relationship with context.snapshot. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or warnings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation as write, destructive, and idempotent. The description adds meaningful context beyond those annotations: unlinking happens immediately, rollback restores it, and commit removes the data-block. It also suggests an unselected-object precondition, and it does not contradict any annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence and front-loads the core verb (`Unlink`). There is no wasted wording, though the three-way temporal clause (`now`, `rollback`, `when the structural transaction commits`) is slightly hard to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The high parameter count, guard fields, and transaction semantics require more context than the description provides. It does not explain how identity and scene-generation checks work, what idempotency means here, or how `transaction_id` relates to `transaction.begin`/`transaction.commit`, so it is incomplete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and five required parameters, the description should carry parameter meaning. It only gestures at `object` and transaction timing; `expected_object_identity`, `expected_scene_generation`, and `idempotency_key` are left undocumented, so an agent cannot reliably know how to fill them correctly.
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?
The description identifies a concrete action (`unlink` / `remove the object data-block`) on a specific resource (`one exact unselected object`). It reads as a deletion/unlink tool and is distinguishable from siblings like `object.duplicate`, `object.set`, or `object.transform`, though the `unselected` requirement is somewhat opaque.
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?
The transactional wording (`restore it on rollback`, `when the structural transaction commits`) implies the intended context is inside a transaction, but there is no explicit direction about when to choose this over alternatives or how transaction lifecycle functions relate. Usage guidance is present only by implication.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey read-only, idempotent, non-destructive behavior, so the description only needs to add extra behavioral context. It adds 'bounded', 'summaries', and 'session-local identities', which clarify that results are constrained, summarized, and use ephemeral session-scoped identifiers. No contradiction with 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?
One tightly packed sentence with no filler. It front-loads the verb and resource, and every qualifier ('bounded', 'summaries', 'session-local identities') adds semantic value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and annotations covering safety, the description is mostly complete for basic invocation. However, it leaves parameter semantics and sibling-tool routing unaddressed, so an agent may not know how filtering or limits shape the result or when a per-kind inspector is more appropriate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It enumerates the kinds values, but does not explain `limit` or `name_filter` semantics, how they interact, or what defaults apply. The schema provides constraints, but the description adds little beyond restating the enum categories.
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?
Description names a concrete verb and resource: returns scene objects, collections, materials, images, world, camera, and render summaries. It adds 'bounded' and 'session-local identities' to characterize the result. It does not explicitly distinguish itself from sibling inspectors like object.inspect or material.inspect, though the breadth is implied.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use scene.inspect versus object.inspect, material.inspect, image.inspect, or other scene-level tools. The word 'summaries' weakly implies a listing/inspection role, but no explicit when-to-use or alternative routing is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds genuinely useful behavior beyond the annotations: candidates are applied transiently and rolled back before returning evidence, which explains why readOnlyHint=false yet destructiveHint=false and idempotentHint=true all hold simultaneously. This is meaningful context, and it does not contradict any annotation.
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 20-word sentence that front-loads the core action and packs baseline, candidate count, scope, and side-effect behavior with no filler. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with a huge discriminated-union schema, three required parameters, and no output schema, one sentence is insufficient: what 'evidence' is returned (captured images? data?) is never stated, 'absolute candidates' is never defined, and the prior-inspection prerequisite is only implied. The agent is left to reverse-engineer the full comparison workflow from the schema alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate, but it barely does: it hints that candidates number 1–3 (matching minItems/maxItems) and are 'absolute', yet it says nothing about how to construct the heavily constrained target union (six variants discriminated by type, each requiring expected_identity fields) or the capture settings. The most complex parameter, target, is covered only by the vague phrase 'one inspected LookDev property'.
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?
The description names a specific operation — capturing a baseline plus one to three candidates for a LookDev property — and the rollback clause distinguishes it from persistent mutation tools like object.set or material.set_input. However, 'absolute candidates' is unexplained jargon, and no sibling is named, so the differentiation is implicit rather than explicit.
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?
The wording 'for one inspected LookDev property' implies a prerequisite (prior inspection) and the rollback behavior implies this is for evaluating alternatives rather than committing values. But no explicit when-to-use/when-not-to-use guidance or alternative tool is named; an agent must infer the decision boundary between this and the persistent setters in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already assert this is mutating (readOnlyHint=false), destructive, and idempotent; the description adds useful context that creation is scoped to an active structural transaction and that names must be unique. It does not, however, explain the destructiveHint — e.g., whether a name collision overwrites an existing object or fails — nor the meaning of the idempotency key.
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 20-word sentence with every phrase earning its place: the verb, the enumerated object types, the uniqueness constraint, the collection scope, and the transaction requirement are all packed in without redundancy. Given the enormous schema behind this tool, the description is remarkably efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the output schema and annotations covering some ground, the tool is complex: 10 discriminator-driven object definitions and 4 required parameters including an opaque expected_scene_generation (presumably an optimistic-concurrency guard) and idempotency_key. The description covers object-type and transaction basics but leaves an agent unable to correctly populate expected_scene_generation or understand the destructive-collision semantics, which are the highest-risk aspects of calling this 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?
With 0% schema coverage, the description carries the burden, and it does explain the most important parameters: the definition/type choices ('primitive, empty, camera, or light'), the unique name constraint, the collection ('exact collection'), and the transaction context. But two required parameters — idempotency_key and expected_scene_generation — receive no semantic explanation anywhere, so the description only partially compensates for the schema's silence.
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?
The description uses a specific verb ('Create') with a clearly enumerated resource scope (bounded primitive, empty, camera, or light) and adds scoping constraints: a unique name, an exact collection, and an active structural transaction. This inherently separates it from siblings like object.duplicate, object.delete, and object.set, which perform different operations. However, it never explicitly names an alternative tool, so differentiation is implicit rather than stated.
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?
The phrase 'inside the active structural transaction' implies a prerequisite workflow: a transaction must already be open, and creation presumably must be followed by commit or rollback. This is useful context, but the description never explicitly says when to choose object.create over object.duplicate, material.create, or scene.camera.set, nor what happens if no transaction is active.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=false, destructiveHint=true, openWorldHint=false, and idempotentHint=true, so the safety profile is mostly in structured data. The description adds the 'reuse' behavior and the 'bounded color-space policy' nuance, which is useful, but it doesn't clarify the destructive/transactional behavior beyond what annotations imply. No contradiction exists.
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 a single, well-structured sentence that front-loads the primary action and then packs the key constraints efficiently. Every phrase adds meaning—'load or reuse' clarifies idempotency, 'arbitrary absolute local path' sets path expectations, and 'bounded color-space policy' and 'active structural transaction' define the operating context. There is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 5 parameters including an idempotency key and an expected generation counter, plus a destructive annotation and an output schema. The description explains the action and the transaction/color-space context, but does not mention the return value, the failure semantics of expected_scene_generation, or how idempotency_key affects call behavior. For an agent to correctly invoke this among many transaction-managed tools, more would be welcome, though the output schema likely covers return shape.
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 0%, so the schema carries almost no explanatory weight for the parameters. The description mentions 'local path' (path), 'color-space policy' (colorspace), and 'active structural transaction' (transaction_id-related state), which maps to some parameters. However, it does not add meaning for idempotency_key or expected_scene_generation, so with zero schema coverage the description only partially compensates.
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?
The description names a specific verb ('load or reuse'), a resource ('image from an arbitrary absolute local path'), and a key constraint ('bounded color-space policy inside the active structural transaction'). It distinguishes itself from image.inspect and material.texture.bind by covering image acquisition rather than inspection or binding, though it does not explicitly name a sibling.
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?
The description implies the tool is for loading/reusing images from local paths inside a transaction, but it does not explicitly state when to prefer this over image.inspect or material.texture.bind, nor does it mention the idempotency key and transaction prerequisites. The context and transaction language are present, but exclusions and alternatives are left to the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already signal destructive and idempotent behavior. The description adds useful context about linked vs independent object data and the unique-name requirement, but it does not clarify what destructive means here, whether the source is left unchanged, or how identity expectations are enforced.
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 a single sentence with no filler. The key action is front-loaded, and the qualifiers about data linking, naming, and transaction scope all earn their place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters, 6 required, and 0% schema coverage, this description is too sparse for reliable invocation. While an output schema exists, the complicated expected_* identity semantics and idempotency contract remain undocumented, leaving the agent to guess at important constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden for parameter meaning. It meaningfully explains linked_data and name, and implies source_name/transaction_id, but it leaves the expected_* fields, collection_name, transform, and idempotency_key unexplained.
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 uses a specific verb and resource: "Duplicate one exact object" with a unique new name. It clearly conveys the core operation and distinguishes duplication from sibling tools like object.create or object.delete.
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?
It states the operation must happen "inside the active structural transaction," which implies an important prerequisite. However, it does not explicitly describe when to choose this tool over alternatives such as object.create or object.set, nor does it mention when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, idempotentHint=true, readOnly=false, and openWorld=false, so the description does not need to restate those. It adds value by disclosing atomicity, the active-transaction requirement, and that the operation targets exactly one object rather than a selection or scene-wide scope.
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 a single sentence with the core action front-loaded: 'Atomically apply'. Every phrase earns its place by adding scope, target, transaction context, or the kinds of settings involved.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with six required parameters and a complex nested patch schema, the description is quite terse. It conveys atomicity and transaction context but leaves expected_* and idempotency semantics to be inferred from parameter names, which may be insufficient for reliable invocation. An output schema exists, so return values are not the issue, but preconditions and concurrency-failure behavior are not disclosed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the six required parameters. It mentions 'one exact object' and 'inside the active transaction', which loosely maps to object_name and transaction_id, but it does not explain the roles of expected_object_identity, expected_scene_generation, or idempotency_key, all of which carry important concurrency and retry semantics.
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?
The description states a specific verb ('apply'), a clear resource ('one exact object'), and enumerates the setting categories involved: transform, visibility, Light, and Camera. It does not explicitly contrast itself with sibling tools like object.transform, object.visibility.set, or scene.camera.set, but its combined atomic scope makes its purpose reasonably distinct.
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?
The phrase 'inside the active transaction' conveys that this tool operates on transaction state, which is a useful context cue. However, it does not say when to prefer object.set over more specialized siblings like object.transform or object.visibility.set, nor does it mention exclusions or prerequisites such as requiring transaction.begin to have been called.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructive and read-only false. The description adds useful behavioral details beyond those annotations: the tool commits any active transaction, saving is conditional, and the quit happens on the next main-thread tick rather than immediately. No contradiction with 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?
The description is one efficient, well-ordered sentence. Each action is clearly separated and there is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The core destructive behavior and timing are described, and an output schema exists so return-value documentation is unnecessary. However, the description does not provide parameter semantics for save_current_as or usage guidance relative to transaction/project tools, so it is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameter meanings. It loosely covers 'save_current' via 'optionally save the current project', but gives no explanation of 'save_current_as' or how it relates to save_current. An agent cannot reliably infer what value to pass for save_current_as.
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 states the exact action sequence: commit an active transaction, optionally save the project, then quit Blender on the next main-thread tick. This clearly identifies the tool as the application exit action and is distinguishable from similar siblings like application.launch, transaction.commit, and project.save.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is given about when to choose this tool instead of transaction.commit, transaction.rollback, or project.save. The agent must infer from the action list that this is the quit flow, but there is no mention of alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare mutating, destructive, and idempotent behavior. The description adds meaningful context beyond those flags: shared data has an explicit user-count and permission requirement. It does not contradict 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded, with no filler wording. However, the second sentence is compact to the point of being cryptic; it could preserve its length while being clearer about which parameters the permission requirement refers to.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a 14-parameter mutation tool with 8 required parameters, including multiple identity and expected-state fields, yet the description only covers slot operations and the shared-data permission condition. An agent would not know how to correctly populate expected_object_identity, expected_data_identity, expected_scene_generation, idempotency_key, and related fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry the parameter burden. It only hints at mode ('append, replace, or clear'), slot_index ('one exact material slot'), and expected_data_users/allow_shared_data ('exact user count and explicit permission'). The many required identity, transaction, and idempotency parameters are left unexplained.
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 names a specific set of operations ('Append, replace, or clear') on a specific resource ('one exact material slot on inspected object data'). This clearly distinguishes material.assign from nearby siblings like material.create or material.set_input.
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?
The description gives a concrete precondition for shared data ('requires its exact user count and explicit permission'), which is useful usage guidance. However, it does not name alternatives or state when to use this tool over material.set_input, object.set, or material.texture.bind.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=true. The description adds useful behavioral context about transaction scope and shared-material confirmation, but it does not explain the optimistic-concurrency expected_* parameters or what destructive actually means in this context. It partially complements the annotations without fully disclosing mutation implications.
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?
Two tightly written sentences with no filler. The core operation is front-loaded, and the shared-material caution is placed at the end. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a high-complexity tool with 15 parameters, including identity checks, transaction scoping, and idempotency. The description is far too minimal to cover prerequisites, failure semantics, or the purpose of the expected_* fields. An output schema exists, but it does not help explain the required parameters or behavioral constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and 14 parameters are required, so the description must compensate. It only hints at value types (scalar/vector/color) and shared-material confirmation (allow_shared). The many expected_* identity, generation, transaction_id, idempotency_key, node_name, socket_identifier, and material_slot_index parameters are entirely unexplained, leaving an agent unable to populate them correctly from the description alone.
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 uses a specific verb ('Set') and a precise resource ('one exact unlinked, undriven scalar/vector/color material input'), making the tool's function immediately clear. It also scopes the operation to 'inside the active transaction,' which helps distinguish it from related material tools like material.assign or material.texture.bind.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys clear context: this is for raw, unlinked, undriven inputs and must be used within an active transaction. It also notes that shared materials require explicit confirmation. It does not explicitly name alternatives or give when-not-to-use guidance, but the constraints are reasonably inferable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey destructive and idempotent behavior. The description adds the 'absolute' set semantics and transaction scope, but it does not explain failure conditions around expected identity/generation, null flag behavior, or interaction with the active transaction.
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 a single, front-loaded sentence with no filler or repetition. Every word adds meaning, naming the operation, target, flag type, and required transaction context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though an output schema exists and covers return values, this is a complex 9-parameter mutation with 7 required fields and identity/idempotency concepts. The description leaves most parameter semantics and behavioral constraints unexplained, so it is not complete enough for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for all 9 parameters. It only hints at show_viewport and show_render through 'viewport/render' and at identity checks through 'one exact modifier'; the required transaction_id, object_name, modifier_name, expected_* fields, and idempotency_key are left unexplained.
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 uses a specific verb ('Set') and clearly identifies the resource: absolute viewport and/or render enable flags for one exact modifier within the active transaction. This distinguishes it from related visibility, material, and transform tools in the sibling list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'inside the active transaction' conveys a key usage context, and 'one exact modifier' implies the tool operates on a single, precisely identified modifier. It does not name alternatives, but no direct modifier-state sibling exists, so explicit exclusions are not essential here.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey destructive/read-only/idempotent hints, so the description only needs to add extra behavioral context. It does so by disclosing the next-tick execution, default transaction commit, and dirty-project saving behavior. There is no contradiction with 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?
The description is two tight sentences with no filler. It front-loads the primary action and then states the important default side effects, which is an efficient structure for an agent-facing tool definition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool has five parameters and zero schema description coverage. The description fails to explain key optional parameters such as load_ui, use_scripts, and save_current_as, and it does not guide the agent toward or away from sibling project tools. This is not fully complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry the parameter-meaning burden. It only explains path ('absolute .blend path') and partially touches save_current via the default-save behavior. load_ui, use_scripts, and save_current_as are left undocumented in both the schema and the description.
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 states a specific verb ('Open'), a specific resource ('existing absolute .blend path'), and a concrete scheduling detail ('on the next main-thread tick'). This clearly distinguishes project.open from siblings like project.reload or project.save and is not a tautology.
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?
The description implies when to use the tool: to open an existing .blend file while committing the current transaction and saving the dirty project. However, it does not explicitly name alternatives, exclusions, or conditions under which another sibling tool such as project.reload should be used instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint and destructiveHint, and the description reinforces the destructive nature with 'overwrite'. It adds genuinely new behavioral details: engine ('Eevee Next'), exact-camera guarantee, output formats (PNG or EXR), absolute path requirement, and the parent-directory prerequisite. No contradiction with annotations exists.
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 dense sentence conveys the tool's purpose, scope, constraints, and output side effects without any filler. Each clause adds distinct information: the camera selection, bounded settings, write mode, path form, formats, and prerequisite. This is efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema mitigates return-value concerns, but the input side is incomplete. With 9 parameters and no schema descriptions, a render/save tool that is destructive and guarded by expected_* fields needs more explanation for idempotency_key, expected_camera_identity, and expected_scene_generation. The description covers the general output behavior but not the safety/versioning semantics required to use the tool correctly.
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 0%, so the description must compensate. It clarifies the meaning of path (absolute, parent exists, PNG/EXR), camera_name (exact camera), and the bounded settings (width/height/samples). However, it does not explain the required parameters expected_camera_identity, expected_scene_generation, or idempotency_key, leaving a meaningful gap.
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?
The description is specific and action-oriented: 'Render one exact Camera' names the verb and resource, and the rest clarifies the output behavior ('overwrite an absolute PNG or EXR output path'). This implicitly distinguishes it from siblings like render.preview and viewport.capture, which target previews or viewports rather than a file write, though it never references an alternative by name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: it renders a specific camera, uses bounded Eevee Next settings, and requires an absolute path whose parent already exists. This effectively tells the agent when the tool is appropriate and what must hold before calling it. It does not explicitly discuss exclusions or alternatives, hence not a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnly, idempotent, and non-destructive hints. The description adds valuable behavioral context beyond those: viewport framing is temporary and user context is restored after capture. It does not detail the exact output or possible side effects on viewport_id, so it's not a full disclosure.
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?
One concise, front-loaded sentence with zero waste. It captures the core sequence of actions without redundant elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main purpose and context restauration but is silent on return semantics of the capture, the meaning of viewport_id and other parameters, and how 'semantic view' relates to the view enum. No output schema exists, so the description would need to explain capture output; it does not.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is expected to compensate with parameter meaning. It does not mention any parameter, though the schema names and enums are mostly self-descriptive.
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?
States a specific multi-step action: temporarily frame an object, capture the 3D editor, then restore context. The verb and resource are clear and it distinguishes itself from viewport siblings like viewport.raycast by describing capture rather than raycast.
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?
The description implies usage for non-disruptive viewport capture by highlighting the temporary framing and context restauration. However, it does not explicitly name alternatives or state when-not-to-use, leaving sibling differentiation to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is read-only and idempotent, so the description does not need to cover safety. It does add context about normalized image coordinates and evaluated geometry, but it does not disclose behavior for invalid capture_id, missing geometry, or raycast misses. That is a meaningful but incomplete behavioral picture.
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 one tightly worded sentence with no filler. The key operational idea is front-loaded, and every phrase earns its place.
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?
Given the tool's simple input set, existing annotations, and presence of an output schema, the description is mostly complete. The main missing piece is an explicit statement that a viewport.capture must be performed first and its id reused here; 'prior viewport capture' only implies this.
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 0%, so the description must compensate for the schema's lack of per-parameter text. It does clarify that x and y form a normalized image coordinate and that capture_id refers to a prior viewport capture, but it leaves out details like coordinate origin and how to obtain a valid capture_id.
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 names a specific verb ('Resolve') and a specific resource ('a normalized image coordinate against evaluated Blender geometry represented by a prior viewport capture'). This clearly separates it from capture and inspection tools that do not raycast against a previously captured viewport.
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?
The phrase 'prior viewport capture' implies the tool should be used after viewport.capture, but the description never explicitly states that dependency or mentions when to prefer this tool over alternatives like object.geometry.inspect or scene.inspect. The usage context is clear but the when/when-not guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide idempotentHint=true, readOnlyHint=false, and destructiveHint=false. The description adds useful context beyond those annotations: it never opens a project and it requires a 'version-matched session add-on,' which communicates an important compatibility behavior. No annotation contradiction is present.
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 two sentences with no filler. The first sentence communicates the core behavior; the second sentence adds a critical disambiguation. Every clause earns its place.
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?
For a zero-parameter, low-complexity tool with an output schema and supporting annotations, the description adequately covers the essential behavior. It does not detail launch failure modes or what 'configured Blender' means, but those details are not necessary for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and schema description coverage is 100%, so the description is not required to explain parameter semantics. The baseline of 4 applies and the description introduces no conflicting or confusing parameter claims.
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?
The description states a clear verb-resource pair: 'launch the configured Blender' and 'reuse a compatible Blender MCP session.' It adds scope with 'This tool never opens a project,' which helps distinguish it from project.open, though it does not explicitly name sibling tools.
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?
The description implies that this tool is used to establish or reuse a Blender session before working, but it never explicitly states 'use this when you need a live Blender session' or contrasts itself with application.status, connection.ping, or project.open. The negative boundary ('never opens a project') gives some guidance, but leaves the main usage decision to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds that the tool verifies the authenticated connection, versions, and UI heartbeat, which names what is checked but does not describe failure behavior, prerequisites beyond being authenticated, or additional operational traits.
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, active-voice sentence with no redundant words. The verb and target are front-loaded, and every word contributes meaning.
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?
The tool is low-complexity: no parameters, an output schema exists, and annotations cover read-only/idempotent behavior. The description states what the ping checks, which is sufficient for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool accepts zero parameters and the schema describes everything needed (an empty object), so there is nothing for the description to add. This falls under the 0-parameter baseline of 4.
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 a specific verb ('Check') and identifies a distinct resource: the authenticated Blender connection, versions, and UI heartbeat. This clearly differentiates it from application.status and project.status siblings by focusing on connection/authentication state rather than application or project state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives like application.status or project.status. The word 'check' implies a health-check use case, but the agent must infer timing and conditions on its own.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a meaningful behavioral boundary beyond those annotations: this tool inspects without changing user context. It does not contradict the annotations and provides useful side-effect clarity.
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 one short sentence that front-loads the core action, resource, and the key contextual guarantee. Every word contributes meaning and there is no redundancy or filler.
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 single-parameter, read-only, idempotent inspection tool with an output schema and rich annotations, this description is sufficiently complete. It covers the essential behavior, the exactness of the target object, and the non-mutating nature without needing to restate schema or annotation details.
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 0%, so the description must compensate. It adds that the tool operates on 'one exact Blender object', implying object_name is an exact, context-independent identifier rather than a fuzzy or selected target. This adds some meaning beyond the schema title 'Object Name', but it does not document format, naming conventions, or edge cases.
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?
The description uses a specific verb ('Inspect'), a clear resource ('one exact Blender object'), and an important scoping condition ('without changing user context'). It does not explicitly name sibling tools like object.geometry.inspect or object.lookdev.inspect, but the phrase 'one exact object' helps distinguish it from broader or more specialized inspection tools.
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?
The description implies a read-only inspection use case and emphasizes that user context is not changed, which is useful guidance. However, it does not explicitly state when to prefer this tool over alternatives such as object.geometry.inspect, scene.inspect, or context.get, and it gives no exclusions or routing advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful scoping context: 'bounded object-local' and 'session identities for safe preview writes'. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, dense, front-loaded sentence with no filler. Some terms like 'bounded' and 'session identities' are compact and slightly jargon-heavy, but the description stays efficient.
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?
For a one-parameter, read-only tool with output schema and annotations, this is mostly complete: it identifies the target object, the categories inspected, and the preview-write use case. Missing details are the meaning of 'bounded' and 'session identities', and alternative-tool routing.
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 0%, so the description must compensate. The single object_name parameter is self-explanatory and the word 'object-local' ties it to the target object, but the description does not explain what constitutes a valid object or how the name should be supplied.
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 uses a specific verb ('List') and names concrete target categories: visibility, modifier, shape-key, and material-slot targets. 'Object-local' and 'bounded' clarify scope, distinguishing it from generic sibling tools like object.inspect and scene.inspect.
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?
The phrase 'for safe preview writes' implies when to use it, but there is no explicit guidance about alternatives or when not to use this tool. Given siblings like object.inspect, material.inspect, and lookdev.compare, more explicit routing would be helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnly, idempotent, and destructive hints. The description adds meaningful behavior by specifying 'absolute' flag setting and restricting changes to the active transaction, which implies changes are not final until commit. There is no contradiction with 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?
The description is a single, front-loaded sentence with no filler. It packs the action, scope, and transactional context efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with seven parameters and five required, the description omits important context: what null means for each visibility flag, why expected_object_identity and expected_scene_generation are required, and how the idempotency key should be used. The output schema does not fill these semantic gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the seven parameters. It mentions viewport/render visibility flags, roughly mapping to hide_viewport and hide_render, but it fails to explain null semantics, the meaning of true/false, or the roles of expected_object_identity, expected_scene_generation, and idempotency_key.
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 uses a specific verb ('Set') plus a clear resource ('object viewport and/or render visibility flags'), and 'absolute' clarifies that this is a direct assignment rather than a toggle. This distinguishes it from broader siblings like object.set and object.delete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'inside the active transaction' clearly tells the agent this tool must be used within an open transaction, after transaction.begin and before commit. However, it does not name alternatives or explicitly state when not to use it, so it stops short of full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond the annotations by disclosing that settings are temporary, that all camera and render settings are restored afterward, and that the return value is PNG evidence. This makes the mutation/side-effect profile clear despite readOnlyHint being false.
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 sentence that front-loads the primary action, states the output, and closes with the restoration guarantee. There is no filler or repetition; every clause adds useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with severe complexity—8 parameters, no schema descriptions, no output schema, and no parameter-level guidance—the description is not complete enough. The agent cannot determine how to obtain expected_camera_identity or expected_scene_generation, what idempotency_key is for, or what happens on mismatch or failure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and 8 parameters, the description would need to compensate, but it does not explain critical parameters like expected_camera_identity, expected_scene_generation, or idempotencyekey. It only vaguely covers rendering parameters as 'temporary bounded Settings'; the guard/verification parameters remain unexplained
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 uses a specific verb ('Render'), a clear resource ('one exact Camera'), and specifies the temporary render mode, the PNG evidence return, and the restoration of settings. This clearly distinguishes it from siblings like render.save or viewport.capture without needing to open the schema.
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?
The usage context is implied: it is a preview render that produces temporary PNG evidence and restores settings. However, it never explicitly says when to use this tool instead of render.save or viewport.capture, nor does it state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly=false, destructiveHint=true, and idempotentHint=true. The description adds meaningful context beyond those hints by specifying the exact shape-key constraints and requiring an active transaction. It accurately aligns with the annotations and clarifies that this is a mutating, transactional value overwrite.
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 a single focused sentence with no redundant words. It front-loads the action and resource, then adds the key constraints. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive, idempotent mutation with eight required parameters and zero schema descriptions, the description is too thin. It does not explain the expected-identity concurrency mechanism, idempotency semantics, or consequences of the destructive hint, leaving significant gaps for an agent attempting correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for explaining the eight required parameters. It only implicitly maps to transaction_id, object_name, shape_key_name, and value; it leaves expected_object_identity, expected_shape_key_identity, expected_scene_generation, and idempotency_key completely unexplained, which an agent needs to invoke the tool correctly.
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 states a specific action ('set'), a precise resource ('one exact non-Basis, non-driven mesh shape key'), and the semantics ('absolute value inside the active transaction'). It clearly distinguishes this tool from broader siblings like object.set and material.set_input.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys clear usage context: the operation requires an active transaction and applies only to non-Basis, non-driven shape keys. It does not explicitly mention alternative tools or when not to use it, but the scoping is strong enough for an agent to recognize the intended situation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses key behavioral facts: changes are retained only in the current session, and the blend file is not saved. This adds meaningful side-effect context beyond the destructiveHint and idempotentHint annotations. It does not contradict any annotation.
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?
Two sentences with no filler. The primary action is front-loaded, and the important limitation about saving is stated separately. Every clause contributes to understanding the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too thin for a three-required-parameter transaction operation. It does not explain how expected_scene_generation is used, what idempotency_key guarantees, or what happens if the transaction is invalid or already committed. The output schema may cover return values, but the missing parameter semantics and lifecycle guidance leave significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description needed to compensate, but it does not mention transaction_id, idempotency_key, or expected_scene_generation at all. While the names are suggestive, the critical semantics of expected_scene_generation and idempotency protection are left unexplained.
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 uses a specific verb ('End'), a clear resource ('a transaction'), and states the outcome ('retaining its changes in the current Blender session'). The added clarification that it 'never saves the blend file' distinguishes commit from persistence operations and from transaction.rollback, which discards changes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the right context: commit when you want to end a transaction and keep its changes, and not roll back. It does not explicitly contrast with transaction.rollback or mention that a transaction must first be opened via transaction.begin, but the intent is clear enough for basic routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds useful context about compatibility checking and summarizing the session, but does not disclose anything beyond that, which is acceptable for a no-argument read-only status tool.
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 sentence that opens with the action and the condition being checked. No filler or repeated schema information.
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?
For a no-argument status tool with rich annotations and an output schema, the description is complete enough to select and invoke correctly. The only slight gap is the unspecified meaning of 'compatible,' but the output schema can carry that detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so there is no parameter semantics burden. The schema coverage is 100% because the input schema is empty; a baseline of 4 is appropriate.
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 uses a specific verb ('Report'), names the resource ('compatible Blender MCP session'), and states the outcome ('whether ... running and summarize it'). This distinguishes it from sibling status tools like connection.ping (connection state) and project.status (project state).
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?
The intended use is implied: call this to check whether a compatible session is running before proceeding. However, the description never explicitly contrasts it with related siblings such as connection.ping or application.launch, and gives no when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as readOnly, idempotent, and non-destructive. The description adds useful behavioral context beyond those annotations by enumerating exactly what aspects of the image are inspected, including packed state and absolute path, and by emphasizing the exact-match scope.
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 a single focused sentence with no filler. It front-loads the core purpose and then lists the returned attributes compactly, every phrase earning its place.
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?
For a simple one-parameter read-only inspect tool with an output schema present, the description is nearly complete: it specifies the target, the scope, and the inspected aspects. It does not cover edge cases like missing images, but with output schema and read-only annotations available, that is a minor gap.
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 0%, so the description must compensate. It partially does by indicating that the input identifies one exact Blender image data-block, making 'image_name' reasonably clear. However, it does not explain whether the name is the data-block name, a file name, or a path, nor does it address case sensitivity or lookup behavior.
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 uses a specific verb ('Inspect') and a specific resource ('one exact Blender image data-block'), and lists concrete fields that will be returned (path, dimensions, color space, users, packed state). It clearly differentiates from sibling tools like image.load and other inspect tools by scoping to a single named image data-block.
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?
The usage context is implied: use this tool to retrieve details about one exact image data-block by name. However, the description does not explicitly state when not to use it or name alternatives such as image.load or the other inspect tools, so the guidance relies on inference from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool destructive and idempotent, and the description adds meaningful detail: unsaved changes are discarded unless save_current is true, and the operation is deferred to the main-thread tick. No contradiction with 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?
Two sentences carry all essential information: the action and timing are front-loaded, and the destructive warning is concise and clear. No redundant wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple and an output schema exists, so return-value documentation is not needed. However, the description covers only one of three parameters and does not fully explain the deferred reload mechanism's implications, leaving noticeable gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for all parameters. It only explains save_current, leaving load_ui and use_scripts semantically unexplained. Their names and defaults offer some hints, but the tool does not describe their behavioral impact.
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 states a specific verb ('Reload'), a specific resource ('current saved .blend file'), and a precise scheduling detail ('on the next main-thread tick'). It clearly distinguishes this from sibling tools like project.save and project.open.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: this tool reverts to the last saved state, and using save_current=true preserves unsaved changes. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for an agent to infer when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is not read-only and is destructive/idempotent. The description adds meaningful transactional behavior: the active camera is changed and the previous camera is restored on rollback. It could further describe failure behavior around expected identity or generation, but the rollback semantics are a valuable addition beyond 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?
The description is one sentence with no filler. The primary action is front-loaded and the rollback consequence is stated immediately, making it easy to scan and parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for selecting the tool and understanding its transaction/rollback nature, especially with annotations and an output schema present. However, it leaves key invocation details undocumented, particularly how to obtain or satisfy the expected_camera_identity and expected_scene_generation, and what 'structural transaction' entails. This is a minimum-viable description with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, but it does not. It only hints at camera_name and transaction context; expected_camera_identity, expected_scene_generation, and idempotency_key remain unexplained. With five required parameters, this is a significant gap.
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 uses a specific verb and resource: 'Set one exact Camera object as the active scene camera.' It also clearly distinguishes this from broader sibling operations like object.set or world.set by focusing on the scene camera and the exactness of the identity. The rollback behavior is stated without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the operation happens 'inside the structural transaction,' and clarifies what happens on rollback. It does not name alternatives or give exclusions, but the context is clear enough for an agent to know this is the tool for changing the active scene camera within a transaction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the operation read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond annotations by noting the result is 'bounded' and 'evaluated', and that raw vertex/face arrays are intentionally withheld. No contradiction with 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 that conveys the tool's scope, output nature, and a key limitation with zero filler. Every word earns its place.
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?
For a single-parameter, read-only inspection tool with a rich output schema and clear annotations, the description is nearly sufficient. It could be more complete by noting how to handle missing objects or by explicitly routing to sibling inspection tools, but the core calling context is well covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning, but it does not mention object_name at all. The parameter name and title are self-explanatory, but the description adds no value beyond the schema's own 'Object Name' label.
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 states a specific verb ('Return') and resource ('bounded evaluated mesh summary'), and uses the negative clause 'without exposing raw vertex or face arrays' to clarify exactly what the tool does not return. This distinguishes it from broader inspection tools like object.inspect or scene.inspect.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'evaluated mesh summary' gives clear context that this tool is for geometry-level inspection rather than scene-level or lookdev inspection. However, it does not explicitly name alternatives or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by disclosing exactly what is surfaced: bounded node input identities, ranges, links, drivers, and write eligibility. This aligns with the read-only annotation and clarifies the introspection scope.
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 sentence that front-loads the core verb and resource, then precisely lists the output contents. There is no filler or repetition of schema details.
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?
The tool has an output schema, read-only annotations, and a focused scope. The description sufficiently explains the purpose and returned data. It could add an explicit note about the object_name parameter or when to prefer this over material.set_input, but overall it is complete enough for correct invocation.
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 0%, so the description must compensate. It reinforces the meaning of material_slot_index via 'one exact material slot', but it does not explicitly explain object_name or the relationship between the two parameters. The schema property names and constraints are still fairly self-explanatory, so the gap is moderate rather than severe.
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?
Description uses a specific verb ('Inspect') and a specific resource ('one exact material slot'), then enumerates the exact data returned: node input identities, values, ranges, links, drivers, and write eligibility. This clearly distinguishes it from other inspect tools like object.inspect or material.set_input.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'one exact material slot' provides clear context that this is for targeted, read-only material inspection rather than broad scene or object inspection. It also implies a pre-write use case by exposing 'write eligibility', though it does not explicitly name alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some useful scope detail ('active' mode, 'available' viewports), but beyond that it does not provide rich behavioral context such as response characteristics or timing.
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 a single concise sentence with the verb and resource front-loaded. Every word contributes meaning, and there is no redundant or filler content.
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?
With no parameters, strong annotations, and an output schema present, the description fully covers what the tool does and what the agent can expect. The enumerated context items are sufficient for a simple read-only tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, and the schema coverage is effectively complete. Per baseline for zero-parameter tools, the description is not required to add parameter detail, and it appropriately avoids inventing any.
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 starts with a clear verb ('Read') and names the exact resources: active Blender mode, selection, scene, and available viewports. This distinguishes it from siblings like context.snapshot and context.restore, which imply state capture/restoration rather than plain reading.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies this should be used when an agent needs the current read-only Blender context state. It does not explicitly mention when not to use alternatives like context.snapshot, but the read-only framing and enumerated fields provide sufficient context for an agent to select it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint true; the description adds value by listing the exact data points read and noting that no 3D viewport is required. It does not contradict the annotations and gives behavioral context beyond the structured hints.
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 sentence that front-loads the verb and resource, then lists specific fields concisely. There is no filler or redundant explanation.
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 zero-parameter, read-only status tool, the description is complete. It names the exact information available, states the no-viewport condition, and safety is already covered by annotations; the output schema handles return structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters and schema coverage is 100%, so no clarification is needed. The description's explicit list of properties confirms that the tool takes no arguments and merely reads fixed project attributes.
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 states a specific verb ('Read') and a well-defined resource: the current Blender project path, dirty state, generation, transaction, and most recent lifecycle operation. This clearly scopes it to project-level status and differentiates it from siblings like application.status by naming project-specific fields.
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?
The description implies this tool is for reading project state and explicitly notes it works without a 3D viewport, which is useful context. However, it does not name alternatives (e.g., application.status) or provide when-not-to-use guidance, leaving usage selection partly to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already flag destructive and non-read-only behavior; the description adds specificity by disclosing that existing targets are overwritten and that the tool commits an active transaction. This complements, rather than merely repeats, the structured hints.
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?
Two tight sentences: the primary action and optional path are front-loaded, and the important overwrite behavior is stated immediately after. No filler or redundant restatement of the tool name.
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?
With one optional parameter, an output schema, and annotations covering safety, the description covers the essential call semantics. The only modest gap is the behavior when no active transaction exists, which is implied but not spelled out.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must explain the lone path parameter. It does so meaningfully by identifying it as an optional absolute Save As path, which disambiguates its role and format beyond the bare string/null schema.
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 states a concrete action and resource: it commits the active transaction and saves the current project, with optional Save As behavior. This clearly distinguishes it from project.open, project.reload, render.save, and transaction.commit within the sibling set.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes when to use the tool (when you want to persist the project and commit the active transaction) and even covers the Save As variant. It does not explicitly name alternative tools or exclusion conditions, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![blender-research-mcp MCP server](https://glama.ai/mcp/servers/Haiyang-Bian/blender-research-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Haiyang-Bian/blender-research-mcp)

Score Badge

Copy to your README.md:

[![blender-research-mcp MCP server](https://glama.ai/mcp/servers/Haiyang-Bian/blender-research-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Haiyang-Bian/blender-research-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/Haiyang-Bian/blender-research-mcp'

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