Luw MCP Server

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

Annotations already declare the safety profile (readOnlyHint false, destructiveHint false, openWorldHint true, non-idempotent), so the description's job is to add what they cannot. It does so meaningfully: cost of 1 credit per ~3000 words, the statelessness of each call, and the image-attachment behavior. It still doesn't describe response shape or latency, but this is solid added context.

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

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

Three front-loaded sentences with no filler; the capability list, the image instruction, the statelessness warning, and the credit cost each carry distinct information. Slightly dense in the opening enumeration, but nothing is wasted and the most actionable guidance comes early.

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

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

With only one required parameter, no output schema, and annotations covering safety, the description supplies what an agent actually needs: scope, image handling, statelessness, and cost. The only unresolved point is the mild tension between 'each call is a standalone question' and the persona_id parameter that 'remembers this conversation'; the description never reconciles those, and no return-shape note exists (acceptable given no output schema).

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

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

Schema description coverage is 100%, so the baseline is 3. The description goes beyond the schema for the two semantically tricky parameters: it explains that the message must be self-contained ('put the details it depends on into the message') and that an image should be attached in order to discuss it, which clarifies intent rather than just repeating field definitions.

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

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

States a specific verb (Ask) and resource (Luw.ai's ArchiGPT, an AI architect) and enumerates concrete capability areas: design advice, feng shui, space planning, materials/colors, technical questions, and square-meter estimation from an image. That capability list cleanly separates it from generation-oriented siblings like luw_interior_design, luw_exterior_design, or luw_render, which produce assets rather than answer questions.

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

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

Gives clear operating context: attach an image when the question is about an image, and treat each call as a standalone question so all dependent details go into the message. It never explicitly names an alternative sibling or states when NOT to use this (e.g. when the user wants a generated render instead of advice), so it falls short of a full 5.

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

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

Annotations already declare the safety profile (readOnly=false, openWorld=true, idempotent=false, destructive=false), so the description's main added value is the credit cost ("Costs 1 credit") and the transparent-PNG output. It does not disclose the return/retrieval flow or any async behavior, which matters for a generation tool, leaving a meaningful gap despite the useful cost disclosure.

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

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

The core behavior is front-loaded, examples are embedded inline, and the cost note is a single trailing clause. Every sentence carries information about what the tool produces or how to trigger each mode, with no filler.

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

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

For a single-required-param generation tool with no output schema, the description covers both modes, output type, and cost. The one missing piece is how results are retrieved (likely async via luw_get_result given the sibling set), which an agent would otherwise have to infer from other tools.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds genuine value by illustrating prompt syntax with a concrete scene example ("on a marble kitchen counter, morning light") that shows the expected natural-language style. It does not touch engine or format, but the schema already covers those, so this is above baseline.

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

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

States a specific verb+resource ("Change Background") and immediately enumerates the two distinct behaviors: cut out the object to a transparent PNG, or generate a new scene when a prompt is given. This clearly separates it from neighbors like luw_remove_furniture (furniture-specific) and luw_edit_image (general edits). An agent can pick this tool without opening any schema.

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

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

Gives explicit mode-selection guidance: include a prompt to place the object in a generated scene, omit it to just remove the background. It also signals the marketing-shot use case, which helps an agent decide when to reach for it. It stops short of naming a sibling alternative or stating exclusions, so it is clear context without routing.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, openWorldHint=true, non-idempotent, non-destructive). The description adds one genuinely useful operational fact not in annotations: cost of 1 credit per variation. Beyond that it says nothing about what is returned, whether the source image is preserved, or any permission requirements, which is thin for a paid generative call.

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

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

Three dense sentences: capability plus examples first, then the reference-image mechanism, then the sibling escape hatch and billing note. Every clause carries information; the examples do real work in illustrating prompt style.

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

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

For a 9-parameter generative tool with no output schema, the description covers the essential decision inputs: what to prompt, how references behave, when to use the sibling, and the cost model. It leaves engine/resolution/variation trade-offs and returned artifact shape unexplained, but the core call path is complete.

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

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

Schema description coverage is 100%, so all nine parameters including enum constraints are already documented structurally; the baseline of 3 applies. The description adds only the semantic intent of reference_images (products, materials, mood boards to place or apply), which the schema already mostly conveys, plus no guidance on engine, resolution, or variations.

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

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

States a specific verb+resource ("edit any image") and anchors it with three concrete instruction examples, so the agent knows exactly what kind of input it accepts. It also distinguishes itself from the closest sibling by naming luw_magic_wand and the condition that selects it.

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

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

Gives a clear usage context (plain-language edits, reference images for placing products/materials/mood boards) and an explicit alternative for one case: area-restricted edits go to luw_magic_wand. It stops short of routing among the other image siblings (luw_generate_image, luw_interior_design, luw_render), so it is strong but not exhaustive.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, and destructiveHint=false, so the mutation profile is covered. The description adds the genuinely useful cost signal ('Costs 1 credit'), but omits that this is an async/generated-output operation likely requiring luw_get_result to retrieve the result.

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

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

Two short sentences, with the core operation front-loaded before the cost note. The 'Luw.ai Expand AI:' branding prefix is minor filler, but the rest wastes nothing.

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

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

No output schema exists, so the description is the only source for what the call returns or how the result is delivered; it says nothing about the response or the likely need to poll a get-result tool. For a credit-consuming generation tool with three parameters, that is a real gap.

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

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

Schema description coverage is 100%, so image, format, and precision are all already documented with their formats, enum values, and precision semantics (90 precise / 75 balanced / 40 creative). The description contributes no additional parameter meaning, making the baseline 3 correct.

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

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

The description names a specific operation (outpaint/expand) on a specific resource (a tightly cropped architectural or interior photo) and states the outcome (a wider view), which separates it cleanly from luw_upscale_image, luw_background, and luw_edit_image. It does not explicitly name a sibling alternative, so it lands just below the top score.

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

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

The phrase 'tightly cropped architectural or interior photo' implies the intended input condition, but the description never states when to prefer this over luw_upscale_image or luw_edit_image, nor any prerequisite such as uploading first. Usage is inferable rather than explicit.

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

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

Annotations already declare the safety profile (readOnly=false, destructive=false, non-idempotent, open-world). The description adds genuinely useful behavioral context not in the annotations: the credit cost ('Costs 1 credit per variation') and the structure-preserving constraint. It does not explain async result retrieval or failure behavior, so it is solid but not rich.

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

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

Two tight sentences with no waste: the tool identity and effect are front-loaded, and the credit cost is isolated as its own sentence. It earns its length, though the middle em-dash list is denser than necessary.

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

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

For a 13-parameter generation tool with no output schema and only 1 required param, the description covers the core operation and cost but omits how generated results are retrieved (e.g., luw_get_result) and any constraints like supported input size. Adequate but leaves the agent short of full operational understanding.

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

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

Schema description coverage is 100%, so every one of the 13 parameters is already documented (precision, variations, style_reference, persona_id, etc.). The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

State a specific verb+resource: 'redesign a building exterior or facade photo', with concrete building-type examples and the output nature (new style, materials, colors, landscaping, structure preserved). The 'exterior' scope implicitly separates it from luw_interior_design and luw_landscape_design, but no sibling is named explicitly, so an agent must infer the routing.

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

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

There is no when-to-use/when-not guidance and no naming of alternatives, despite adjacent siblings (luw_interior_design, luw_landscape_design, luw_render) that overlap closely. The scope word 'exterior' implies usage but leaves the agent to infer selection.

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

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

Annotations cover the safety profile (not read-only, open-world, non-idempotent, non-destructive), so the burden is lighter. The description still adds genuinely useful operational context the annotations lack: a per-image cost of 2 credits and the fact that format="svg" reroutes execution to a different underlying model.

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

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

A single dense sentence plus a short cost/format clause; the core capability is front-loaded and nothing is wasted. It is slightly overstuffed with use-case examples, but each clause carries information.

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

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

For a 9-parameter creative generation tool with no output schema, the description covers purpose, cost, and the vector mode but omits how results are delivered — notably whether generation is asynchronous and requires luw_get_result, and how multiple variations are returned. That omission matters given the sibling luw_get_result exists.

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

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

Schema description coverage is 89%, so the schema already documents seed, image, engine, format, styles, variations, and enhance_prompt. The description restates the guide-image option and the svg/vector-model behavior, which the schema also covers, adding little beyond it. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb+resource ('generate a photorealistic image or illustration from a text prompt') and enumerates use cases, so the agent knows exactly what it produces. It partially differentiates from siblings by naming the Fluw Vector AI switch for format="svg", but does not explicitly distinguish itself from luw_generate_pattern, luw_render, or luw_vectorize_image.

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

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

Usage is implied by the prompt-driven framing and the optional guide-image note, and the svg tip gives one actionable routing hint. However, there is no explicit when-to-use vs. when-not guidance against the many neighboring generation tools (luw_render, luw_edit_image, luw_generate_pattern).

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false), so the bar is lower. The description adds the 1-credit cost and the seamlessness guarantee, but says nothing about generation being asynchronous or that the result must be fetched via luw_get_result, which is the most consequential behavioral fact for a generator.

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

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

A single dense sentence leads with the tool identity and core capability, followed by a short cost note. No filler, and the most important information (what it produces) is front-loaded.

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

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

For a 6-parameter generator with no output schema, the description omits how the result is obtained (async polling via luw_get_result) and any prompt-authoring expectations despite a 4000-char prompt field. What it does say is accurate, but the operational loop around the call is incomplete.

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

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

Schema description coverage is 100% and the schema already documents engine/size interactions, reference image, format, and prompt. The description adds no parameter meaning beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource ('generate a seamless, tileable pattern or texture') and enumerates concrete domains (tiles, wallpaper, fabric, terrazzo, wood, stone). This is clearly distinguishable from the generic sibling luw_generate_image without opening either schema.

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

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

The phrase 'ready to repeat across a surface' implies the use case (surface-covering textures), but there is no explicit when-to-use guidance and no alternative named — an agent must infer that luw_generate_image is for non-tiling images. The credit-cost note is informative but not routing guidance.

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

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

Annotations already signal a non-readonly, non-idempotent, open-world operation, so the description correctly reinforces that this is a generation job. It adds valuable behavior beyond annotations: asynchronous processing ('takes a few minutes'), a processing_url to collect with luw_get_result, and credit cost tiers when end_image is used.

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

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

Purpose and the result-collection/cost facts are front-loaded, and the camera-motion list, though long, is load-bearing because the schema defers to it. Some density could be trimmed, but little of it is wasted.

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

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

With no output schema, the description still covers the return path (processing_url → luw_get_result), timing expectations, pricing, and the end_image workflow, which is everything an agent needs to invoke and poll this tool correctly.

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

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

Schema coverage is 100% (baseline 3), but the description goes further: it enumerates the 12 valid camera_motion values that the schema only refers to as 'listed above,' and explains the end_image pairing pattern with a worked example. Seed, prompt, and engine are left to the schema, but the enum values would be unknowable without the description.

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

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

States a specific verb and resource: animating a design image into a short cinematic video, with named scope (fly-throughs, dolly moves, drone shots, reveals). This clearly distinguishes it from image-generation siblings like luw_generate_image or luw_render.

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

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

Gives concrete usage context (use end_image for a before → after transition, collect results via luw_get_result) and pricing, which helps an agent decide. It does not explicitly compare against alternatives such as luw_image_to_3d or luw_run_model, so it falls short of full when/when-not guidance.

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

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

Annotations already declare readOnly/destructive/openWorld, so the safety profile is covered. The description adds real behavioral value beyond that: long-polling semantics bounded by the server's wait limit, retry guidance, and the cost fact ('Free') that discourages re-running. It stops short of describing the returned payload, but no output schema exists to lean on.

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

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

Three tight sentences with zero filler, front-loaded with the job-retrieval purpose before the retry and cost guidance. Every clause earns its place.

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

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

For a result-retrieval tool whose annotations carry the safety profile and with no output schema to explain, the description is nearly complete: it covers trigger, waiting, retry, and cost. The only gap is not naming what the collected result contains, which is minor here.

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

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

Schema coverage is 100%, so all three parameters (including wait and source_image) are documented in the schema itself. The description only implies the processing_url's provenance and the waiting behavior; it adds little parameter detail the schema doesn't already carry, matching the baseline for full coverage.

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

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

States a specific verb (collect) and resource (result of a Luw.ai generation), and immediately scopes it to jobs that were 'still processing'. This clearly differentiates it from the sibling generation/design tools, which produce jobs rather than retrieve their results.

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

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

Explicitly says when to use it (a generation tool returned a processing_url because the job outlasted its wait), what to do if incomplete ('call again if it's still running'), and a when-not ('never re-run a generation instead' / 'Free'). This routes the agent away from the costly, wrong alternative.

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

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

Annotations already cover safety (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds genuinely useful behavior beyond them: explicit credit cost per engine (3 aria / 8 symphony), the engine-dependent nature of options (reflections is symphony-only), and the max of 3 supplemental photos. It stops short of disclosing latency or how/where the GLB is returned.

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

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

Four short clauses, front-loaded with the core action, then enrichment hints, then the alternative workflow, then cost. Every sentence carries information; density is high but nothing is redundant.

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

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

With no output schema, the description correctly states the output format (GLB) and the cost, which is what an agent most needs for this generation tool. The notable gap is result retrieval — sibling tools include luw_get_result, and the description doesn't say whether the model is returned inline or fetched asynchronously afterward.

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

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

Schema coverage is already 86%, so the baseline is 3. The description nonetheless adds real meaning: extra_angles is framed as 'photos from other angles' capped at 3, and engine values are tied to concrete pricing and naming (symphony = Symphony-3), which helps the agent choose a value rather than just read an enum.

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

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

States a specific verb and resource: 'generate a textured 3D model (GLB) from a photo of an object', and enumerates the target subjects (furniture, decor, products). It also distinguishes itself from image/video siblings by naming the text-to-3D path explicitly, so an agent can route correctly without opening the schema.

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

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

Clear usage context: supply a photo, optionally add up to 3 additional angles for accuracy, and for text-to-3D first call luw_generate_image. It names the alternative workflow, though it doesn't state when not to use this tool (e.g. vs. luw_sketch_to_render or luw_render for 2D outputs).

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

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

Annotations cover the safety profile (readOnly=false, idempotent=false, openWorld=true), and the description adds value beyond them: credit cost per variation and the guarantee that room architecture is preserved while surfaces are restyled. It stops short of describing result retrieval or failure behavior, so not a 5.

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

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

Three dense sentences, zero waste, with the core verb and scope front-loaded before the mode hint and the cost note.

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

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

For a 14-parameter, mutation-capable generation tool with no output schema, the description covers the operating modes, what is preserved, and billing. It omits how results are retrieved (likely via luw_get_result) and any latency/rate context, leaving a small gap.

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

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

Schema coverage is 100% and already documents all 14 parameters, so the baseline is 3; the description goes beyond it by explaining the empty_room mode semantics (virtual staging / room-type conversion) and by pointing to luw_list_options for style and room_type values.

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

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

States a specific verb+resource ('redesign an interior photo — home, office, shop, hotel — in any style while keeping the room's architecture') and enumerates what is restyled (furniture, materials, colors, lighting), which clearly separates it from siblings like luw_exterior_design, luw_landscape_design and luw_remove_furniture.

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

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

It gives a mode condition ('Set empty_room=true to furnish an empty room or turn it into another room type') but never states when to prefer this over sibling tools such as luw_exterior_design, luw_render or luw_edit_image. Usage is implied by the interior-photo scope rather than explicitly routed.

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

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

Annotations already cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds the non-obvious fact that each call costs 1 credit, which is real operational context an agent needs before invoking. It stops short of explaining result retrieval or latency.

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

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

Two sentences, zero filler, with the core action front-loaded and the cost constraint placed last. Nothing is redundant with the title.

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

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

For an 8-parameter generative tool with no output schema, the description covers the core action and cost but says nothing about how the result is obtained — notable here because the sibling set includes luw_get_result, implying asynchronous job handling the agent must know about.

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

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

Schema description coverage is 100%, so all 8 parameters are already documented, and the description's mention of 'climate and sun exposure' only loosely maps to city/sun_exposure. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a specific verb and resource: designing a garden/yard/outdoor area inside a masked region of a photo, with plants selected for climate and sun exposure. This is more precise than a generic 'edit image' sibling, but it never names or differentiates itself from luw_exterior_design or luw_render, which an agent might reasonably confuse it with.

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

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

Usage is implied by the requirement that the work happen 'inside a masked region of a photo', which tells the agent the mask_image prerequisite. However, there is no explicit when-to-use versus siblings (e.g. exterior_design vs landscape_design) and no guidance on when a plain edit_image would suffice.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds a useful cost disclosure ('Free') not present in annotations, but says nothing about output shape, pagination, or how many values are returned. Adequate but thin 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.

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

A single dense sentence with zero filler, front-loading the purpose and the kind→parameter mapping. Slightly run-on, but every clause earns its place.

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

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

With no output schema, the description still conveys it returns valid values and, via the schema's details flag, descriptions and preview URLs. Complete enough for an agent to call correctly, though it could say more about result size/format.

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

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

Schema coverage is 67% with search and details self-documented. The description adds real value by naming the target parameter for each enum value (e.g. design_styles→styles, materials→Magic Wand material_image catalog), which the schema's bare enum does not convey.

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

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

States a specific verb (look up) and resource (valid values) and enumerates exactly which downstream tool parameter each kind feeds, making it unmistakable versus siblings like luw_personas or luw_magic_wand. An agent knows precisely what this returns without opening the schema.

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

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

Frames the tool as a prerequisite lookup for other Luw.ai tools and ties each kind to its consuming parameter, which strongly implies when to call it. It does not state exclusions or say when not to use it, but the usage context is clear.

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

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

Annotations already declare the non-read-only, non-destructive, open-world profile, so the description only needs to add beyond that. It does: a per-call cost of 1 credit, the constraint that the mask must be the same size as the input, and the white-marks-the-target convention. It omits permission/auth requirements and whether calls are async.

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

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

Front-loaded with the core action, then mode selection, then mask mechanics, then cost — a sensible priority order in four tight sentences. The mask color/size explanation partially duplicates the schema's mask_image description, which is the only minor redundancy.

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

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

For a 10-parameter generative tool with no output schema and no annotation coverage of output handling, the description leaves out how results are retrieved (no mention of luw_get_result or whether the tool returns the image directly) and what happens if prompt, remove, and material_image are combined. Mask sourcing and credit cost are covered, so it is adequate but not complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine semantic value by explaining the interaction between modes: remove=true erases rather than generates, and material_image applies a texture instead of a prompt-described object. That tells the agent how to choose among parameters, not just what they are.

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

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

The description names a specific verb and resource ('change only a masked area of an image') and enumerates the three edit modes (prompt add/replace, remove, material_image), which clearly separates it from full-image edit tools. It stops short of naming the sibling it displaces (e.g. luw_edit_image or luw_remove_furniture), so sibling differentiation is implied 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.

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

It gives concrete selection rules: use a prompt to add/replace, remove=true to erase, material_image to re-surface, with a domain example ('new flooring or wall tiles'). It also routes the agent to luw_segment for obtaining masks. What's missing is an explicit when-not-to-use, i.e. that whole-image edits belong to luw_edit_image.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is covered. The description adds substantial domain behavior the schema cannot express: slot partitioning (1-6 style, 7 default input, 8+ free-form data) and the 'like' semantics of slotless add_training. It does not warn that delete/delete_training/clear_slot are irreversible, but that is largely covered by the destructive annotation.

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

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

Dense but information-bearing: the slot taxonomy and the action list both earn their place, and the action enum is conveniently restated at the end. The opening sentence is somewhat meandering before it gets to concrete usage, but nothing is filler.

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

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

With 14 parameters, ten actions and no output schema, the description should map parameters to actions (e.g., what list_trainings needs vs. add_training) and give some sense of return shape. It covers the slot model well but leaves action-to-parameter wiring and response behavior to inference, which is a meaningful gap at this complexity.

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

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

Schema description coverage is 64%, and the description compensates on the parameters the schema leaves bare: it explains the meaning of slot values, the role of persona_id, and the behavior of add_training without a slot. It does not explain which parameters apply to which of the ten actions, which is the main remaining gap for a multi-action tool.

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

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

The description states the resource (personas + their training images) and enumerates all ten actions, so an agent knows this is the CRUD hub for personas. It also differentiates from siblings by noting that persona_id is consumed by generation tools. The first sentence leans conceptual ('Personas hold a reusable design identity') rather than immediately stating what the tool does, which slightly blurs the verb+resource framing.

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

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

It gives real conditional guidance — add_training without a slot 'likes' a design, slot 1 is the style-transfer reference used by style_reference="persona", and persona_id should be passed to generation tools. However, there is no explicit when-to-use-this-tool-vs-siblings routing and no indication of prerequisites or ordering between actions.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true and non-idempotent, so the safety profile is covered. The description adds nothing beyond that: it does not say whether delete/delete_folder/delete_media are permanent or reversible, whether media is removed from disk, or what permissions are needed. With annotations doing the work, this is thin.

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

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

Two sentences: the first front-loads the purpose and nesting model, the second covers the add_media routing and the action list. No filler, though the flat action enumeration is dense and does not convey per-action structure.

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

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

For a 9-parameter, 12-action destructive tool with no output schema, the description covers purpose and the action inventory but omits per-action parameter requirements, return shape, and irreversibility of deletes. It is minimally adequate rather than complete.

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

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

Schema coverage is 67%, and the schema already documents url, extras, folder_id and parent_id. The description lists the action enum values but never maps parameters to actions (e.g., that get/rename/delete need project_id, that create_folder needs name and optional parent_id). It adds the project/folder/media vocabulary but no per-action parameter guidance.

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

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

States a specific verb+resource ('Organize work in Luw.ai projects') and enumerates all 12 supported actions, so the agent knows this is the project/folder/media management surface. It also disambiguates the API naming ('called boards in the API'). It does not explicitly contrast with siblings, but the siblings are all generation/design tools, so the distinction is largely self-evident.

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

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

It gives one concrete routing hint — 'Use add_media to save generated results into a project' — which ties this tool to the sibling generation tools. However, there is no guidance on when to use this tool versus luw_get_result or luw_upload_file, and no indication of which action to pick for a given intent.

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

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

Annotations only cover the generic safety profile (not read-only, open-world, non-idempotent, non-destructive). The description adds genuinely new behavior: the operation is content-preserving (walls, floor, windows kept) and costs 1 credit. It stops short of describing the return value or delivery mechanism, but the credit cost and preservation guarantee are real added value.

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

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

One front-loaded sentence carrying the action, the preservation guarantee and the cost, with zero filler. The only slack is the redundant branded prefix that restates the tool name.

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

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

For a 3-parameter, fully documented schema with no output schema, an agent has what it needs: accepted input formats, output format, and the semantics of precision. The cost note is useful. Slightly incomplete in not saying how the resulting image is returned (directly vs. via luw_get_result), which matters given the sibling set.

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

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

Schema description coverage is 100%, so all three parameters (image, format, precision) are already documented with examples including the accepted input forms and the precision values. The description adds nothing on parameters, which is acceptable at full coverage — the baseline of 3 applies.

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

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

States a specific verb (remove) and resource (furniture) plus the scope constraint (from a room photo, keeping walls, floor and windows). An agent can distinguish it from siblings like luw_interior_design or luw_edit_image without opening any schema. The 'Luw.ai Remove Furniture AI' prefix is brand boilerplate but harmless.

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

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

The description implies the input is a furnished room photo but never states when to choose this tool over siblings such as luw_background, luw_edit_image or luw_magic_wand. No exclusions, prerequisites, or alternative routing are given.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true and destructiveHint=false, so the mutation profile is covered externally. The description adds the billing rule ('Costs 1 credit per variation'), which is genuinely useful and not in the annotations, but it says nothing about latency, async behavior, or how generated results are retrieved (a luw_get_result sibling exists), which matters for a generation tool.

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

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

Two tight sentences: the first delivers the core transformation, the second delivers the cost constraint. Zero filler and no repetition of the title or schema.

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

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

With 7 parameters, no output schema, and generation semantics, an agent still lacks information on result retrieval, expected latency, and how the returned variations are ordered or delivered. The credit-cost note partially compensates, but the definition is thin for a tool of this complexity.

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

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

Schema description coverage is 100%, so every one of the 7 parameters is already documented in-schema, including enum meanings and the precision scale. The description adds no parameter-level detail beyond the schema, which is acceptable but earns only the baseline 3.

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

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

States a concrete transformation ('turn a 3D model view, CAD/BIM screenshot, clay render... into a photorealistic architectural render'), which is a specific verb+resource. It is clear on its own, but never differentiates itself from the very similar sibling luw_sketch_to_render or from luw_generate_image, so it falls short of a 5.

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

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

The description implies its use case by naming acceptable input types (3D views, CAD/BIM screenshots, clay renders, basic visualizations), which steers the agent toward appropriate inputs. However, it gives no explicit when-not guidance and does not mention the near-identical sibling luw_sketch_to_render, leaving the agent to infer which render tool to pick.

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

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

Annotations cover the safety profile (readOnly=false, openWorld=true, idempotent=false, destructive=false), and the description adds value on top: it warns 'Spends credits like the model's own tool' and notes image fields accept local paths and data: URIs. It omits what the raw call returns, but the cost and input-handling disclosures are real additions.

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

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

Front-loaded purpose, then scope condition, then the reference list. The long model enumeration earns its place as a discoverability aid for a generic pass-through tool; no filler sentences.

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

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

For a raw pass-through tool with no output schema, the description supplies the model list, the parameter docs link, and the credit-spend warning, which is enough to invoke correctly. It does not describe the response shape, a minor gap given no output schema exists.

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

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

Schema coverage is 100% (baseline 3), and the description goes further by listing accepted image field names, the parameter reference URL, and the full model id roster. This meaningfully reduces guesswork for the free-form 'params' object.

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

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

States a concrete verb+resource ('Call POST /generate with raw API parameters') and explicitly scopes itself as the escape hatch for cases the dedicated tools don't cover. Enumerating the supported model ids makes it immediately distinguishable from the ~24 specialized siblings.

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

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

Clearly states when to reach for it: 'for models or options the dedicated tools don't cover (e.g. persona-slot inputs, webhooks)' — implying the specific siblings are the default. No explicit when-not, but the fallback framing is unambiguous.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), so the bar is lower, and the description still adds real value: the return format (black-and-white mask image URLs) and the cost ('Costs 1 credit'). It does not say whether the call is synchronous or requires polling via luw_get_result, which is a notable gap for a generation tool.

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

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

Three compact clauses with zero waste: what it does, the two segmentation modes, the downstream handoff, and the credit cost. The key capability and the routing hint are front-loaded.

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

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

With no output schema, the description correctly explains the return value (mask image URLs) and adds cost. However, for an openWorld, non-idempotent generation tool it omits execution semantics such as latency/async result retrieval and how labels interacts with prompt.

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

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

Schema description coverage is 100%, so the schema already documents image, labels, and prompt, including the 'omit to segment everything' behavior. The description only restates the prompt's effect and never mentions the labels filter, adding little beyond the schema — baseline 3 is correct.

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

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

States a specific verb+resource+output: 'detect objects in a photo and return black-and-white masks as image URLs', and clarifies the two modes (all objects vs. prompt-described objects). This clearly distinguishes it from sibling edit/render tools without opening a schema.

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

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

Explicitly routes the agent forward: 'Feed a mask URL into luw_magic_wand or luw_landscape_design to edit exactly that area', naming concrete downstream alternatives. It lacks an explicit 'when not to use this' clause (e.g. vs. luw_background or luw_remove_furniture), so it falls 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.

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, so the mutation/non-reproducible profile is covered. The description adds a genuinely useful billing fact ('costs 1 credit per variation'), but omits other behavioral traits such as whether the job is asynchronous and must be polled via luw_get_result, or any auth/quota requirements.

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

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

Two sentences with no filler and the purpose front-loaded ahead of the cost note. The 'Luw.ai Sketch AI:' lead-in is mild branding repetition of the title rather than information, otherwise fully efficient.

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

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

For a 12-parameter generation tool with no output schema and no result-retrieval documentation, the description is thin on the workflow side. Given the crowded sibling set (luw_render, luw_interior_design, luw_generate_image, luw_get_result), the absence of any disambiguation leaves an agent guessing which tool to invoke.

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

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

Schema description coverage is 100%, so all 12 parameters (including enum meanings, precision scale, styles case-sensitivity, and style_reference semantics) are already documented. The description only echoes the per-variation billing that the schema also states, adding no new parameter meaning beyond the baseline.

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

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

States a specific transformation (sketch/line drawing/floor-plan perspective/rough draft → photorealistic render), which is concrete and distinguishes the input type. It does not, however, differentiate itself from close siblings like luw_render or luw_generate_image, so the agent must infer the boundary.

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

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

Usage is only implied through the input type: an agent can infer 'use this when the source is a hand sketch.' There is no explicit when-to-use, when-not-to-use, or named alternative (luw_render, luw_interior_design, luw_exterior_design), so routing among the 24 siblings is left to inference.

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

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

Annotations already declare readOnly=false, idempotent=false, openWorld=true, destructive=false. The description adds genuinely useful behavioral context beyond that: uploads are normally unnecessary because other tools auto-upload, and the URL is reusable across tools. It does not restate the 12-hour auto-deletion (that lives in the schema) or discuss failure modes for unreachable URLs.

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

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

Three sentences, front-loaded with the primary purpose, then the caveat, then the exceptions. No filler and every clause carries decision-relevant information.

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

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

No output schema exists, and the description compensates by stating the return value is a URL usable by every Luw.ai tool. Combined with full schema coverage and annotations, an agent has everything needed to decide and to call it.

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

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

Schema coverage is 100%, so source, persistent and persona_id are all fully documented in the schema itself. The description's mention of 're-host an image from a site Luw.ai can't reach' and 'store a file permanently' loosely maps to source and persistent but adds no format or syntax beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('Upload an image, video or 3D file to Luw.ai storage') plus the outcome ('get a URL usable by every Luw.ai tool'). This distinguishes it clearly from the many design/render/generate siblings, which produce content rather than host it.

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

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

Explicitly frames scarcity of need ('Rarely needed: all tools already accept local paths and data: URIs and upload them automatically') and then names three concrete cases that do justify it: shareable URL, re-hosting an unreachable image, permanent storage. This is textbook when/when-not plus alternatives.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true and destructiveHint=false, so the safety profile is largely covered. The description adds genuinely new behavior in stating the 1-credit cost, but says nothing about auth, result retrieval, or failure behavior.

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

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

Two compact sentences with the capability statement first and the cost constraint second. No filler, no repetition; every clause carries information an agent can use.

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

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

For a simple generation tool whose annotations cover the safety profile and whose schema is fully documented, the description is nearly adequate. However, the presence of luw_get_result among siblings suggests generation is asynchronous, and the description never mentions how or where the upscaled image is retrieved.

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

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

Schema description coverage is 100%, so all four parameters (image, scale, format, precision) are already documented with defaults, valid values and meanings. The description restates the scale values, adding nothing the schema does not already contain; baseline 3 applies.

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

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

The description gives a specific verb and resource — enhance/enlarge an image — with the concrete scale options (2x, 4x, 8x). It never distinguishes itself from close siblings like luw_edit_image or luw_vectorize_image, which also take an image and return a transformed image, so the agent must infer the difference.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative named, despite many image-manipulation siblings. The only decision-relevant context offered is the 1-credit cost, which helps but does not tell the agent how to choose this tool over its neighbors.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context by disclosing the cost ('Costs 1 credit') and the output format (SVG). However, it says nothing about how the result is obtained (immediate return vs. polling a sibling like luw_get_result) or latency, which matters for a generation tool.

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

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

Two short sentences, zero filler. The action and output are front-loaded, and the cost constraint is placed last where it reads as a footnote rather than burying the purpose.

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

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

For a one-parameter tool with full schema coverage and annotations covering the safety profile, the description supplies the two things structured fields cannot: the output artifact (SVG) and the credit cost. The only meaningful omission is how the converted result is retrieved, which the sibling set (luw_get_result) suggests may be asynchronous.

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

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

Schema description coverage is 100% and the single parameter already documents accepted input forms (URL, local path, data URI). The description adds no parameter-level detail of its own, so the baseline 3 applies.

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

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

States a specific verb and resource ('convert a photo or drawing into a clean SVG vector'), which clearly separates it from siblings like luw_upscale_image, luw_edit_image and luw_expand_image. It also names the provider ('Luw.ai Vector AI') and the output artifact (SVG), so the agent knows exactly what this tool produces.

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

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

There is no when-to-use guidance beyond the implicit conversion intent, and no mention of alternatives (e.g., when to prefer luw_upscale_image or luw_edit_image). The only advisory content is the credit cost. Prerequisites and follow-up steps are absent.

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