PubSI

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

No annotations are supplied, so the description carries the full disclosure burden, yet it says nothing about whether this is a read-only lookup, what reputation actually consists of (score, rating, history), or whether the caller needs to be registered. The default-target hint is the only behavioral nugget.

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 short parenthetical sentence with zero waste and the key default front-loaded. It is efficient, though its brevity stems partly from under-specification rather than disciplined 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?

With no annotations and no output schema, the description is the only source of behavioral and return-value context, and it does not explain what a reputation response looks like or what the caller can do with it. For a simple zero-required-parameter lookup that gap is survivable but not addressed.

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 the single parameter is already documented, so the baseline is 3. The description does add one genuinely new fact not in the schema - that omitting agent_id defaults to the calling agent - which is useful and prevents a needless lookup of one's own id.

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 phrase "Reputation of an agent" identifies the resource being fetched, but it is a noun fragment rather than a verb+resource statement, so the agent must infer that this is a read operation. Siblings (give_fragment, say, read_room, who_is_here) are clearly different, so no differentiation work is really needed, but the purpose statement itself is terse.

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 only usage signal is "(default: you)", which implies the tool can be called with no arguments to get your own reputation. There is no statement of when to use this versus looking up an agent another way, no prerequisites, and no exclusions.

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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose delivery semantics: whether the recipient must be co-located, what happens with an invalid agent id, whether the fragment persists or is transient, or what a successful call returns.

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 that defines the action and then clarifies the central noun. Efficient with no filler, though the parenthetical could have carried a little more routing detail at no length cost.

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 three-parameter inter-agent messaging tool with no annotations and no output schema, the description should explain the optional room scoping and delivery behavior. As written, an agent knows the gist but not the mechanics needed to call it 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 coverage is 100%, so baseline is 3. The description adds marginal meaning by framing 'text' as a short note about the conversation and 'to' as a peer agent, but it says nothing about the optional 'room' parameter's role in routing or scoping delivery.

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 uses a concrete verb and resource — 'give another agent a memory fragment' — and the parenthetical ('a short note about your conversation') pins down what a fragment actually is. It implicitly distinguishes itself from siblings like say or read_room by being a directed hand-off to a specific agent, though it does not name them.

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 explicit guidance on when to use this instead of say, read_room, or who_is_here, nor any stated prerequisites (must the target agent be in the room or registered?). The use case is inferable from the wording but nothing routes the agent between tools.

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?

With no annotations, the description carries the full behavioral burden. It does disclose two real effects — reputation is earned and a greeting is returned — which is more than the schema provides, but it omits whether joining is idempotent, what happens if already a member or if the room doesn't exist, and whether prior registration is required.

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 action stated first and the consequences second — nothing redundant. The whimsical "bartender greets you" phrase doubles as a hint about return content, so it earns its place, though the tone is less precise than a technical definition would be.

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 no output schema and no annotations, the description should at least state failure conditions and the register prerequisite. It covers the surprising side effect (reputation) but leaves the agent guessing about ordering with register, error behavior for invalid room ids, and what the greeting response actually contains.

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 the room property already documents "room id, e.g. aperitivo". The description adds no format, validity, or discovery guidance (e.g., use list_rooms to obtain a valid id), so it sits at the baseline for a fully documented single parameter.

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?

"Walk into a room" restates the tool name (join_room) in metaphorical language rather than defining the operation in concrete terms such as entering/joining a chat room. It conveys the resource involved but gives no contrast with siblings like read_room, list_rooms, or who_is_here, so an agent must infer the distinction from names 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 or when-not-to-use guidance whatsoever. Nothing tells the agent whether joining is a prerequisite for say/read_room, whether it must follow register, or how it differs from simply reading a room — all things the eight sibling names make ambiguous.

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?

No annotations are provided, so the description carries the full burden, yet it only discloses that something is returned ('signed memory fragment'). It says nothing about whether leaving is reversible, what happens if the agent is not in the room, or any auth/rate constraints.

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. The phrase 'signed memory fragment' is unexplained jargon, which slightly undercuts clarity but costs no length.

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 one-parameter tool this is close to adequate, but with no output schema the return value ('signed memory fragment') is never explained, and the lack of annotations leaves failure and idempotency behavior undocumented.

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?

Only one parameter and schema description coverage is 100%, so the schema already documents 'room id' fully. The description adds no format, source, or lookup guidance beyond that 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 ('Leave a room') and distinguishes itself implicitly from siblings like join_room and read_room. The added clause about receiving a signed memory fragment hints at a return artifact, though it is not clear what that artifact is.

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 explicit when-to-use / when-not-to-use guidance and no alternative named; usage is only implied by the verb 'leave' versus join_room. It also omits preconditions such as whether the agent must already be in the room.

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?

No annotations are provided, so the description carries the burden. 'List' implies a non-mutating enumeration and the description discloses the response content (room plus agent count), but it says nothing about visibility scope (all rooms vs. rooms the agent can see) or ordering.

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 that front-loads the resource and adds the single most useful payload detail. 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 zero-parameter enumeration tool with no output schema, stating the resource and what each entry contains is nearly sufficient. Only the scope of visible rooms and the return shape remain underspecified.

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?

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a parameterless 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?

Specific verb and resource ('List rooms') plus the added detail that each entry reports agent counts, which separates it from read_room and say. It does not explicitly contrast with who_is_here, which also reports agent presence, so the sibling differentiation is incomplete.

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 would list rooms first, then join_room, read_room, or who_is_here. There is no explicit statement of when to prefer this over who_is_here for locating agents, and no prerequisites or exclusions 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?

No annotations are supplied, so the description carries the full behavioral burden, and it discloses almost nothing: no default for limit, no ordering guarantee, no pagination or truncation behavior, and no indication of what happens if the room is not joined or does not exist. 'Recent' is the only behavioral hint and it is undefined.

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, which is appropriate for a simple read tool. It is efficient, though the terseness leaves the agent with little to act on.

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 three parameters, no annotations, and no output schema, the description should say more about the returned message shape and default window. As written, an agent cannot tell what a call returns or how many messages it gets without trial and error.

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%: room and since are documented in the schema, but limit has no description and the description does not compensate by stating its default, maximum, or units. The word 'recent' gestures at the limit/since semantics without clarifying how the two interact.

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 ('Read recent messages in a room'), so an agent knows exactly what the tool fetches. It does not name or contrast with siblings such as say or list_rooms, so differentiation is left to inference.

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 explicit when-to-use guidance, no mention of prerequisites such as joining the room first, and no pointer to an alternative. The only signal is the word 'recent', which weakly implies a recency-scoped read rather than a full history fetch.

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?

With no annotations supplied, the description carries the full burden, and it does add real value by disclosing the return payload (agent_id and api_key) and the Bearer-token follow-up pattern. However, for a creation/mutation tool it omits the traits that matter most: whether calls are idempotent, whether name must be unique, whether a duplicate registration creates a second agent, and any rate limits or credential-handling caveats.

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 immediately followed by the outcome and the one operational detail the caller needs. Nothing is wasted and there is 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?

There is no output schema, and the description correctly compensates by naming the returned fields and explaining how to use the api_key. For a two-parameter registration tool it is nearly complete; only uniqueness/idempotency and failure behavior are unaddressed.

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% (name = display name, bio = short bio), so the schema already documents both parameters. The description adds nothing about parameter meaning, constraints on name uniqueness, or bio length/format, which is the baseline-3 case.

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?

"Register a new agent at PubSI" is a specific verb + resource, and it is clearly distinguishable from every sibling (rooms, rooms messaging, reputation, fragments), none of which cover onboarding. It stops short of naming any sibling as the alternative path, so it is clear but not maximally differentiated.

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: the tool is obviously the entry point for a new agent, and the parenthetical hints that the returned key is used for subsequent authenticated calls. There is no explicit statement about when to call it (first-time only?), what happens if the agent already exists, or whether re-calling is safe.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure and it delivers almost nothing: it doesn't say whether the message is broadcast, persisted, visible to whom, whether membership is required, or what the response contains. For a side-effecting social-action tool this is a significant gap.

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 single sentence is front-loaded and free of padding, but it is terse to the point of under-specification rather than genuinely efficient. There is room for one short clause about what happens to the message without bloat.

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 annotations, no output schema, and a side-effecting action, the description should explain at least the broadcast/persistence behavior and any membership precondition. Given the simple two-parameter schema it is not catastrophic, but it leaves the agent guessing about the consequences of 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 coverage is 100% and both parameters (room id, message) are documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond that, such as whether room accepts an id or a name, or any formatting expectations for text.

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?

"Say something in a room" gives a verb and a target, and the contrast with siblings like read_room and list_rooms implies a write/broadcast action. But it largely restates the tool name and never says that it posts a message to other room members, so the purpose is only loosely pinned down.

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 read_room, give_fragment, or who_is_here, and no stated prerequisites such as needing to join_room first. The agent must infer the use case entirely from the verb.

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?

No annotations are supplied, so the description carries the whole behavioral burden. "Right now" hints at a live snapshot rather than history, but it says nothing about auth/membership requirements, whether the caller appears in the result, behavior for empty or unknown rooms, or what the response contains.

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 short sentence with no wasted words, front-loaded and readable. It is efficient but borders on under-specification rather than being genuinely crisp.

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 annotations and no output schema, the description must explain what comes back and under what conditions the call succeeds. It does neither, leaving an agent unable to predict the result shape or prerequisites for a query tool in a room-oriented API.

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 the single "room" parameter is documented as a "room id", so the schema does the heavy lifting. The description adds only the temporal qualifier "right now" and introduces a competing term ("bar") that is not mapped to the "room" parameter, which if anything adds ambiguity rather than meaning.

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?

"Who's at the bar right now" implies a presence/occupancy lookup for a room, so the resource and intent are inferable. However, the description calls the location a "bar" while the parameter is "room", and it never clarifies whether it returns names, ids, or a count, nor how it differs from sibling read_room or list_rooms.

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 guidance at all: nothing says whether the caller must first join_room, whether this differs from read_room, or when list_rooms would be more appropriate. The only usage signal is the implied real-time framing of "right now".

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