Globimmo Property Search

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

The annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered structurally. The description adds one meaningful piece of context beyond them: the effect is permanent, and it targets only public relay actions rather than the conversation entirely. It says nothing about recovery, permissions, or what happens to existing messages.

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 front-loaded sentence with no wasted words; the key qualifier 'Permanently' is placed where it will be read first. It is efficient, though its brevity is partly under-specification rather than tight editing.

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 destructive, irreversible mutation with three undocumented parameters and no output schema, one sentence is not enough to call it correctly or explain the result. The annotation coverage offsets some risk, but the parameter gaps and absent recovery/permission context leave the definition materially 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 0% across three parameters, including a 'reason' enum with five values and the pairing of conversationToken with conversationId, so the description needed to compensate and does not. It never mentions any parameter, leaving the meaning of the token/id pair and the purpose of the reason enum entirely undocumented.

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 (block) and resource (conversation) and adds scope ('further public relay actions'), which is more precise than the title alone. It does not explicitly distinguish itself from close_conversation, the closest sibling, so an 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?

Usage is only implied: 'Permanently' hints that this is the irreversible counterpart to close_conversation and reopen_conversation, but no sibling is named and no condition for choosing one over the other is given. There is also no guidance on 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.

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=false, so the safety profile is known. The description adds nothing beyond that: it never says what closing changes, whether it is reversible, or who may close a conversation. For a destructive mutation, that is a real gap even with annotations present.

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 short sentence with no filler, and the core action is front-loaded. Brevity here reflects under-specification rather than tight editing, but nothing is wasted or buried.

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?

A destructive, non-read-only mutation with no output schema and zero schema coverage needs more: preconditions, effects, and reversibility are all unstated. The description is not sufficient for an agent to call this tool confidently in a conversation-lifecycle workflow.

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 0% and there are three parameters, so the description carries the burden. It only hints that the conversation must be 'open', and does not explain why both conversationId and conversationToken are required or what the reason enum affects.

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 a specific verb and resource ('Close an open conversation'), making the effect clear at a glance. It does not differentiate from siblings such as block_conversation or reopen_conversation, which share the same conversation-lifecycle domain.

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, no statement of prerequisites (e.g. that the conversation must currently be open), and no routing to alternatives like block_conversation or reopen_conversation. The agent must infer all selection logic from sibling names alone.

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?

The description adds the key reciprocal behavior: the caller accepts some offered fields while sharing some requested fields. Annotations already disclose that it is a non-read-only, idempotent, non-destructive operation, so the description does not need to repeat that. It still omits what happens to declined fields, what the token represents, and what state changes result from confirmation.

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 definition is a single front-loaded sentence with no filler or redundancy. Its brevity is efficient, though it leaves important operational details unstated rather than explaining them elsewhere.

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 four-parameter mutation tool with no output schema and no parameter descriptions, the description is too sparse. It omits prerequisite workflow details, token sourcing, conversation context, and the effect of confirmation on the participants' shared information.

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 0%, so the description must compensate for undocumented parameters. It gives useful conceptual meaning to 'accept' and 'share' as subsets of offered and requested fields, but says nothing about the required conversationToken or conversationId and does not clarify how the subsets should be chosen.

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 reciprocal action: accepting a subset of offered fields and sharing a subset of requested fields. However, it never names the resource as a contact exchange, defines 'offered' versus 'requested' fields, or distinguishes the action from siblings such as prepare_contact_exchange and get_contact_exchange. The purpose is only fully clear when combined with the tool name.

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 guidance on when this tool should be used, when it should not, or how it relates to the sibling prepare_contact_exchange and get_contact_exchange tools. An agent must infer the workflow context and any prerequisite steps entirely from the name.

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=true and destructiveHint=false, so the safety profile is covered. The description adds real value by disclosing the side effect — a verified user gets attached to the session — which is not visible in annotations. It stops there, saying nothing about failure behavior for wrong/expired codes, code lifetime, or rate limits on attempts.

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 tightly written sentence with the action first and the consequence second — zero filler. Its brevity is efficient rather than padded, though it leaves too much unsaid, which is penalized under contextual completeness rather than here.

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?

This is a state-changing, session-mutating tool with three required parameters at 0% schema coverage and no output schema. The description never says where verificationId comes from, what the call returns, or what happens on an invalid code, leaving significant gaps for a tool in an auth flow.

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 0% across three required parameters, so the description must carry the meaning and largely does not. 'The code' and 'the session' loosely map to code and sessionToken, but verificationId is never explained (presumably returned by start_email_verification), and no format constraints are restated.

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 pairs a specific verb ('Confirm') with a specific object ('the code') and names the resulting effect ('attach a verified Globimmo user to the session'), which lets an agent distinguish it from start_email_verification or confirm_contact_exchange. It falls short of 5 only because it does not explicitly name the sibling it complements.

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: 'Confirm the code' suggests this is the second step after start_email_verification, but the description never states that prerequisite, nor does it describe when not to call it (e.g. already verified sessions, expired codes). An agent can infer the flow but must guess.

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 write, open-world, non-destructive and idempotent profile, so the safety picture is covered. The description contributes two useful behavioral facts beyond that: inquiries are pseudonymous (an anonymity contract the caller likely cares about) and a verified session is required. It does not explain what idempotency means here (whether a repeat call returns the existing inquiry or errors) or what happens to the inquiry afterwards.

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 front-loaded sentence with no filler or redundant restatement of the tool name. Its compactness is a virtue structurally, though it tips into under-specification rather than tightness.

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?

This is a state-mutating tool with no output schema, no annotation detail on outcomes, and 0% parameter documentation. An agent still lacks the return shape (inquiry ID? conversation ID? does it open a conversation?), error behavior for an unverified session or non-returned property, and any guidance on the message payload.

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 0%, so the description carries the full burden for all three required parameters. It obliquely maps sessionToken ("verified session") and propertyId ("returned property"), but gives no format, provenance or constraint detail, and never mentions the message parameter at all (length bounds, content expectations, or what "pseudonymous" means for message content).

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 ("Create a pseudonymous inquiry") plus a qualifier scoping it to a "returned property," which is materially more informative than the title "Create inquiry." It does not, however, distinguish itself from sibling tools such as send_message or report_message, which could plausibly be reached in a similar flow.

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 "using a verified session" implies a precondition (the caller needs an already-verified session), which is genuine usage context. There is no explicit when-to-use vs. when-not guidance and no routing to alternatives like send_message or prepare_contact_exchange, so usage is implied rather than stated.

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, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds only the actor scoping and a hint of what is returned (field-level consent plus released snapshots); it says nothing about whether conversationToken must be a live session token, what happens on an expired token, or how snapshots are versioned.

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 front-loaded sentence with no filler or redundancy. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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 tool that sits in a multi-step contact-exchange flow (prepare → get → confirm) with two required opaque parameters and no output schema, the description omits the workflow context, token semantics, and any sense of the return shape. It is not wrong, but it leaves the agent without enough to call this reliably.

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 0% for two required parameters, and the description does not compensate at all — it never explains what conversationId identifies or what conversationToken authorizes. With both parameters undocumented in the schema and absent from the description, an agent has no basis for constructing a valid call beyond guessing from the names.

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 ('Read') and a specific resource ('field-level contact consent and released snapshots'), scoped to 'the current actor'. An agent can distinguish this read from prepare_contact_exchange and confirm_contact_exchange by name, but the description never explicitly contrasts them, so sibling differentiation is only implied.

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 guidance on when this should be called — not after prepare_contact_exchange, not before confirm_contact_exchange, not in place of get_conversation. The agent must infer the position of this tool in the consent workflow from the name alone.

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, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds value by naming what the response contains (messages, lifecycle state, contact-exchange state), which matters since there is no output schema, but says nothing about permissions, scoping, or result size.

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 short sentence with no filler, and the return-content list is front-loaded. However, the brevity comes at the cost of under-specification rather than efficiency — the single sentence omits the resource identity and parameter meaning.

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 0% schema coverage, two required parameters, and no output schema, the description would need to explain identifier semantics and the shape of returned state. It covers only the return-content categories and leaves the identifiers and access conditions unexplained.

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 0%, so neither of the two required parameters is documented anywhere. The description does not explain what conversationId is versus conversationToken, why both are required, or how to obtain them, leaving a critical gap for a mandatory-2-param call.

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 ('Read') and enumerates the content returned (messages, lifecycle state, contact-exchange state), which does hint at what the call yields. But it never says the tool retrieves a single conversation identified by the supplied identifiers, and 'pseudonymous messages' is opaque phrasing that leaves the actual resource ambiguous against siblings like get_contact_exchange and mark_conversation_read.

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 guidance on when to use this versus get_contact_exchange, mark_conversation_read, or the conversation lifecycle tools, and no mention of prerequisites such as needing a valid conversation token. The agent must infer the use case entirely from the tool name.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered by structured data. The description's added value is the session-scoping constraint implied by 'same search session', which suggests the call will fail or be restricted without a matching token; however, 'safe' is left unexplained and the return behavior is not described.

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 front-loaded sentence with no filler or repetition. It is efficient, though the terseness borders on under-specification rather than tightness.

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 two-parameter, non-destructive read with no output schema, the definition covers the call mechanics minimally. It omits what the returned 'detail' contains and how failure modes (invalid or expired session token) behave, which for a tool without an output schema would be worth stating.

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 0%, so the schema names the parameters but explains nothing. The description partially compensates by tying sessionToken to a search session and propertyId to a property returned in that session, which is genuine semantic value, but it does not say whether the token expires, how IDs are formatted, or what happens with a mismatched token.

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 verb 'Read' and resource 'detail for a property' are present, and 'returned by the same search session' hints at the scope. But 'safe detail' is undefined, and it never states what kind of detail (listing attributes, contact info, pricing) comes back, nor how it differs from siblings like select_property or search_properties.

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 'returned by the same search session' implies a usage precondition: this tool is meant to be called after a search has produced a property. That is implied context rather than an explicit when-to-use rule, and no alternative tool (select_property, search_properties) is named or excluded.

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, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. What the description should add for an incremental-fetch tool — what counts as 'new', whether results are relative to the last call or to the 'since' cursor, whether returned items are consumed/marked read, and how results are ordered — is entirely absent.

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 front-loaded sentence with no filler or redundancy. It is efficient, but the brevity comes at the cost of under-specification rather than being genuinely tight prose.

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 and no schema descriptions, the description is the only place an agent can learn what a 'match' object looks like and how incremental retrieval behaves, and it supplies none of that. For a three-parameter polling tool the definition is materially incomplete even though annotations cover safety.

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 0% across three parameters, so the description carries the full burden and mostly fails it: savedSearchId, since, and limit are never mentioned. Only the word 'new' loosely hints at the temporal role of 'since', and nothing explains that limit is capped at 20 with a default of 20.

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 verb 'Return' plus the object 'new matches' is concrete, and the qualifier 'owned by the authenticated AI client' narrows the scope. However, 'matches' is never tied explicitly to a saved search — the reader has to import that from the tool name — and no sibling tool in the list concerns saved searches, so no differentiation work is done in the text.

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 statement of when to call this versus alternatives, no mention of the sibling save_search that creates the searches being polled, and no guidance on polling cadence or whether this should be called repeatedly. The only implied usage is 'fetch updates', which an agent must infer.

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=true, destructiveHint=false, so the safety profile is covered. The description does add one useful behavioral fact that annotations cannot convey: the scope of the write is limited to the calling actor's unread count, not everyone's. It says nothing about permissions, side effects on other counters, or what the response looks like.

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 front-loaded fragment with no filler, but the brevity is under-specification rather than efficiency; a few more words on the target conversation and token would cost little and remove real ambiguity.

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 two-parameter mutation with no output schema and no schema documentation, the description carries too much of the burden and delivers too little. It omits the target resource, the semantics of the token parameter, and any indication of failure or return behavior.

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 0%, so both required parameters (conversationId and conversationToken) are completely undocumented in the schema. The description does not mention either parameter or explain the difference between an ID and a token, leaving the agent to guess how to construct the call.

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?

"Clear the actor unread count" names a specific verb and effect, so the agent can tell it apart from siblings like get_conversation or block_conversation. However, it never mentions the conversation, which is the actual target resource implied by both required parameters, and "actor" is unexplained jargon.

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, no exclusion versus siblings such as get_conversation, and no stated preconditions. The agent must infer that this is the tool to call when the user opens or views a conversation.

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 indicate this is an idempotent, non-destructive write operation. Beyond that, the description only restates the offer/request purpose and does not explain that it likely creates a pending exchange proposal, what happens to the offered fields, or whether the other participant must accept.

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 description is a single sentence with no wasted words and the action is front-loaded. It is under-informative rather than bloated, so conciseness itself is good.

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?

This is a four-parameter write tool in a prepare/confirm/get flow with no output schema and no schema descriptions. The description does not cover the conversation context, required tokens, confirmation requirement, or what an agent should expect after calling 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 description coverage is 0%, so the description should compensate, but it never explains conversationToken or conversationId. It vaguely gestures at offer/request with 'selected contact fields' and 'selected fields' but adds no meaning about allowed values, uniqueness, or minimum length beyond what the schema already enforces.

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 a specific action: offering selected contact fields and requesting selected fields from the other participant. It is clear enough to distinguish from fully completing or retrieving an exchange, but it never mentions the conversation scope or that this is a preparatory step relative to confirm_contact_exchange.

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 guidance on when to use this tool versus confirm_contact_exchange or get_contact_exchange, nor any prerequisites such as an active conversation. The name implies preparation, but the description does not state that a separate confirmation step is required.

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 idempotentHint, destructiveHint=false, and readOnlyHint=false, so the safety profile is covered. The description adds a real business rule (blocked conversations cannot be reopened), but says nothing about what happens on rejection, permission requirements, or whether state changes are reversible.

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 short sentence with the precondition front-loaded after the action; no redundant or filler wording.

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 mutation tool with two fully undocumented required parameters and no output schema, the definition leaves the agent without guidance on parameter meaning or the failure mode when the conversation is blocked. Annotations cover safety but not enough to fill these gaps.

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 0% for two required parameters. The description never explains what conversationId refers to or whether conversationToken is an auth/access token, which is a meaningful ambiguity for an agent assembling the call.

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 ('Reopen a previously closed conversation') plus a precondition ('previously closed'), which distinguishes it from close_conversation and block_conversation. It stops short of naming those siblings explicitly.

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 'unless it is blocked' clause gives one when-not condition and the 'previously closed' qualifier implies the when. However, no alternative tool is named (e.g., what to do with a blocked conversation) and no prerequisites or permissions are stated.

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?

The annotations already declare idempotentHint=true, readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the description repeating 'idempotent' adds essentially no new information. It omits what happens after a report is filed (whether the message is hidden, whether the other participant is notified, whether blocking is implied) and any throttling or duplicate-report behavior beyond the idempotency claim.

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 front-loaded sentence with no filler, which is the right shape for this tool. Its brevity edges into under-specification rather than over-writing, but as a structural matter nothing 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?

For a five-parameter mutation tool with no documented parameters and no output schema, the definition is too thin. An agent cannot tell from the description what the two conversation identifiers are for, what fields are required beyond the schema, or what the call returns, so it lacks the context needed to invoke this confidently.

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 0% across five parameters, so the description must compensate and does not. Most critically it never distinguishes conversationToken from conversationId, two similarly named required strings, and it says nothing about the 'details' free-text field or the reason enum 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?

The description names a specific verb and resource ('Create ... abuse report') and adds a scope constraint ('for a message from the other participant'), which separates it from general conversation tools like close_conversation or get_conversation. It does not explicitly contrast with block_conversation, another plausible sibling for handling abuse, so it stops 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?

Usage is only implied: an agent can infer this is for flagging an abusive message rather than muting or blocking a participant. There is no explicit guidance on when to choose report_message versus block_conversation, nor on prerequisites such as needing an existing conversation context.

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, idempotent, openWorld and non-destructive, so safety is covered. The description adds one genuinely behavioral rule (never fabricate a geoId), but it does not disclose what the call yields (candidate list? coordinates? ambiguity handling) or that open-world results may include multiple matches.

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, front-loaded with the action and the constraint. Nothing is redundant and every sentence 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 four parameters at 0% schema coverage, no output schema, and an enum parameter, the description is too thin for the agent to call it correctly — it never explains how countryCode or transaction narrow results or what a successful resolution returns. The only thing it fully conveys is the anti-hallucination rule.

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 0%, so the description must carry parameter meaning, and it does not. Only "human place name" loosely maps to q; limit, countryCode, and especially the transaction enum (sale/rent) — the least intuitive parameter — are entirely unexplained anywhere.

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?

"Resolve a human place name before searching" states a specific verb (resolve) and resource (place name/geoId), and the second sentence clarifies the outcome is a geoId rather than free text. It is distinguishable from the property-search siblings, though it never names search_properties or another sibling explicitly.

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?

"Before searching" gives clear workflow ordering context, telling the agent to run this lookup ahead of any search call, and "never invent a geoId" implies what happens if the agent skips it. There are still no exclusions or guidance on what to do when multiple or zero locations match.

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 write profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the safety burden is largely covered. The description adds that this acts on a *verified* search session and optionally triggers email alerts, which is useful context. It does not say what happens on repeat saves, whether an existing saved search is overwritten, or whether auth/verification is a hard requirement.

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 front-loaded sentence with no filler. It is efficient, though its brevity borders on under-specification rather than pure conciseness.

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 four-parameter mutation tool with no output schema and no parameter descriptions, the definition is thin: what constitutes the saved payload, whether name is required, and what the response contains are all unstated.

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 0%, so the description carries the full burden for four parameters. It only obliquely implies sessionToken/sessionId via "verified search" and covers emailNotify via "email alerts", leaving the name parameter (maxLength 160) and its optionality completely unexplained.

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?

Uses a specific verb ("Persist") plus a specific resource ("the verified search"), which distinguishes it from read-only siblings like search_properties and get_saved_search_updates. It stops short of naming those siblings, but the action is unambiguous.

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?

No when-to-use or when-not-to-use guidance and no stated prerequisites beyond the vague adjective "verified". An agent cannot tell from the description whether a prior search session must be confirmed first or how this relates to get_saved_search_updates.

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 the safety profile is covered. The description adds one genuinely new behavior ('short-lived search session') but leaves its lifetime, how it is consumed downstream, and any rate limits or result caps unexplained; it also sits in mild tension with readOnlyHint=true since a session is server-side state (idempotentHint=false is consistent with that). 'Deterministic safe previews' is never defined.

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?

It is a single front-loaded sentence with no filler, which is structurally fine. But the brevity is under-specification rather than efficiency: two distinct behaviors (search and session creation) are compressed into one clause with no elaboration where elaboration is most needed.

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 20-parameter search tool with no output schema and no schema descriptions, the definition is far too thin. It never states what is returned (previews plus a session identifier?), how results are paginated or capped at size<=20, or how the session is subsequently used, leaving the agent to guess at both inputs and outputs.

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 0% across 20 parameters, so the description carries the full burden and adds nothing: no explanation of what a 'preview' returns, which session handle is produced, or what vocabulary is valid for categories, requiredFeatures, preferredFeatures and excludedFeatures (free-form strings with no documented values). Parameter names like priceMinEur are self-describing, which is the only reason this is not a 1.

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 verb+resource ('Search ... property previews') is identifiable, but the qualifiers 'deterministic safe' are unexplained jargon and the second clause ('create a short-lived search session') adds a side output that is never clarified. It gives no differentiation from siblings such as get_property or save_search, so an agent cannot tell which to reach for from the description alone.

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, no exclusions, and no mention of alternatives such as get_property (single lookup) or save_search (persisting criteria). Critically, it never says that geoId must first come from the sibling resolve_location, which is the main prerequisite for calling this tool successfully.

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 this is a non-destructive, idempotent, closed-world write, so the safety profile is covered. The description adds that the effect is scoped to a search session, but says nothing about side effects (e.g., notifying the listing agent), whether the interest can be withdrawn, or what 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?

A single front-loaded sentence with no wasted wording. It is concise but borders on under-specified for a mutation that has two required, undocumented parameters.

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?

The tool is simple (two required scalar params, no output schema) and annotations cover the safety profile, so the description is close to sufficient. Gaps remain around session token provenance and the downstream effect of recording interest.

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 0%, so the schema only supplies names and minLength constraints. "Within the search session" hints at what sessionToken represents and "property" maps to propertyId, but the description does not explain how a session token is obtained or whether it must come from search_properties.

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?

"Record explicit interest in a property" gives a specific verb and resource, and usefully clarifies that "select" means recording interest rather than reserving or purchasing. It does not differentiate from siblings such as create_inquiry or save_search, which represent adjacent commitments.

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?

No when-to-use or when-not-to-use guidance is given. The agent must infer on its own when to call this versus create_inquiry, save_search, or get_property, even though those are the most likely confusions.

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, and destructiveHint=false, so the agent knows this is a non-idempotent external write that is not destructive. The description adds one genuinely useful behavioral fact beyond that: the relay design means no direct contact details are exposed. However, it says nothing about the consequences of sending (irreversibility, delivery, visibility to the other party) or about the required conversationToken and how it is obtained, leaving significant behavioral gaps for a message-sending mutation.

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?

It is a single front-loaded sentence with no wasted words, which is structurally sound. The problem is under-specification rather than verbosity: the one sentence cannot carry the tool's purpose, usage, and parameter semantics. It earns its place but is too thin for the job.

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 non-idempotent, externally visible write operation with three undocumented required parameters and no output schema, the description is far too sparse. It does not explain what success looks like, what the conversationToken must be, or what errors to expect. The relay/no-contact-detail note is the only substantive content beyond the annotations.

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 0% and all three parameters are required, yet the description explains none of them. In particular, conversationToken is opaque and its purpose (presumably authorizing the relay) is never clarified, nor is conversationId distinguished from it. The description does not compensate at all for the schema's complete lack of parameter documentation.

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 pairs a specific verb ("Send") with a specific resource ("message") and adds a distinguishing characteristic: it is a relay message sent without exposing direct contact details. That differentiates it reasonably from siblings like report_message or mark_conversation_read. It stops short of explicitly naming which sibling to use instead, so it is clear but not maximally differentiating.

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, no prerequisites, and no mention of alternatives. The agent is not told, for example, when to send a message versus create_inquiry or how this relates to prepare_contact_exchange and confirm_contact_exchange. Only the implicit signal from the verb "Send" indicates usage context.

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 and destructiveHint=false, so the mutation profile is covered. The description adds genuinely new behavior with 'short-lived', signaling the code expires and that calling again likely re-issues it, but it omits rate limiting, whether prior codes are invalidated, and any delivery-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?

A single front-loaded sentence with no filler or redundancy; the key fact ('short-lived verification code') comes first. Brevity tips into under-specification, but there is no wasted wording to trim.

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 should say what the agent receives and what to do next, and it does not. The expiration hint partially compensates, but for a two-required-param, fully undocumented flow step, an agent is left guessing about the session token and the follow-up confirm call.

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 0% for two required parameters, so the description carries the full burden and largely fails: 'search session' loosely hints at what sessionToken represents, but nothing explains the token's origin, lifetime, or relationship to the email. Neither parameter is meaningfully clarified beyond its type.

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 pairs a specific verb ('Send') with a specific artifact ('a short-lived verification code') scoped to 'the search session', which is clear on its own. It implicitly differentiates from confirm_email_verification by framing this as the code-issuing step, but it never names that sibling, so the distinction is left for the agent to infer.

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, no prerequisites, and no mention of the confirm_email_verification sibling that logically follows this call. The only signal is 'for the search session', which hints at a preconditions context but does not state one.

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