leboncoin-seller-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Most tools have clearly distinct purposes, with detailed descriptions separating search, pricing, draft, and publish workflows. The main ambiguity is between search_listings, batch_search_listings, and search_similar_listings, but their specific roles are clarified. estimate_price and analyze_market_price are also distinct in intent, though they share market data.
Naming Consistency4/5
The naming is overwhelmingly verb_noun snake_case (search_listings, create_draft, validate_listing). A few slight exceptions like whoami, diagnose, and my_listings break the pattern but remain readable and predictable. Overall the convention is consistent enough for agents to infer behavior from names.
Tool Count4/5
At 23 tools, the server is on the heavier side but the count is justified by the full seller workflow: search, pricing, categories, drafts, publishing, and account management. Each tool serves a concrete step in the process, so the number feels scoped rather than bloated.
Completeness3/5
The core lifecycle from draft creation to publishing is thoroughly covered, including validation and photo management. However, there is no way to update or delete a live, published ad, which is a significant gap for a seller tool. The experimental my_listings reads are also limited, but the primary workflow is well-supported.
Average 4.4/5 across 23 of 23 tools scored. Lowest: 3.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 13 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the agent knows it is a safe read. The description adds what the tool returns (detailed fields, history, etc.) but does not disclose edge cases, like behavior for nonexistent drafts or permission requirements. It is consistent with annotations and adds moderate value beyond them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the core purpose ('Returns a stored draft in full') and then enumerates the return content. While the list is somewhat long, it is still concise and free of fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, this description does an adequate job of explaining what the tool returns, covering all key aspects: fields, photos, comparables, price statistics, validation result, and history. It is complete enough for a read-only retrieval tool, though it could mention error conditions or prerequisites.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter draftId is fully described in the schema ('Draft id returned by prepare_listing'). The tool description does not add any additional meaning beyond the schema, so with 100% schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a stored draft in full, listing its contents (fields, photos, comparables, price statistics, validation result, history). This distinguishes it from sibling tools like list_drafts (which lists all drafts) and update/delete drafts, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit guidance on when to use this tool versus alternatives. It is implied from the name and sibling tools that this is the 'get one draft' tool, but the description offers no usage context or exclusions, such as 'use list_drafts to see all drafts'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals a safe read. The description adds useful behavioral detail beyond that: drafts are local, sorted newest first, and include status and headline fields. There is no contradiction with the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the action and provides only relevant details. It avoids filler, redundancy, and unnecessary complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only listing tool with optional parameters and no output schema, the description covers the essential purpose, ordering, and returned fields. It would be more complete if it clarified default limit behavior and when to use this listing tool instead of related listing tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not explain the limit or status parameters beyond what the schema already states. One parameter (limit) has no schema description and the description does not compensate by mentioning defaults, ordering with limit, or how filtering interacts with the returned fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Lists local drafts, newest first, with their status and headline fields,' providing a specific verb, resource, and return scope. It distinguishes this from get_listing_draft and search_listings by focusing on the local draft list, ordering, and displayed fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit guidance on when to use this tool versus alternatives like search_listings, get_listing_draft, or my_listings. There are no use-case conditions, exclusions, or preferred scenarios, so the agent gets only minimal implied usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds crucial behavioral context beyond the readOnlyHint and openWorldHint annotations: it warns that ad content is untrusted data, may contain prompt injection attempts, and instructs the agent to ignore and report such instructions. This is exactly the kind of non-obvious behavioral disclosure that annotations alone do not provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: the first sentence states the core purpose, and the following sentences deliver an important security warning without unnecessary elaboration. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with no output schema, the description adequately covers what the tool returns and how to handle untrusted content. It does not describe error behavior or exact response structure, but the listed fields and security guidance make it sufficiently complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents listingId and country. The description adds no additional parameter-level detail beyond restating that the tool works 'by id', which is already clear from the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Returns the full detail of one ad by id' and lists the included fields (description, attributes, location, seller type). This distinguishes it from sibling tools like search_listings or get_listing_details_batch by emphasizing single-ad retrieval by ID.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for retrieving one specific ad when you already have its ID, but it does not explicitly mention when to prefer this over alternatives like search_listings or get_listing_details_batch. The guidance is clear but implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description reinforces this by stating it 'Reports' and 'Makes no request to Leboncoin', adding useful behavioral context beyond the annotation. It does not detail potential side effects or permissions, but for a read-only diagnostic tool the added context is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first packs the tool's outputs into a clear list, and the second provides a practical use case. Every sentence earns its place with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only diagnostic tool with no output schema, the description is complete: it explains what the tool reports, when to use it, and explicitly notes it makes no external request. This is sufficient for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for the single optional 'country' parameter, so the schema already explains it. The tool description does not add any parameter-specific semantics, but the baseline of 3 applies because the schema carries the full burden adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Reports') and a well-defined resource: the server's configuration and observed activity. It lists concrete outputs (read backends, request pacing, blocked/rate-limited counts, storage location) and distinguishes itself from siblings by noting it makes no request to Leboncoin.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit when-to-use guidance: 'Reach for this when tools are failing and you want to tell the user *why*'. It also provides a concrete example of diagnostic discrimination. However, it does not name alternative tools or explicitly state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description adds valuable behavioral context: NOT_FOUND only means the ad was not among those read, not that it does not exist. It also includes an important safeguard warning that titles, descriptions, and seller names are untrusted data that may contain prompt-injection instructions, going well beyond what the annotations convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the core behavior is stated first, followed by the experimental caveat and then the critical security warning. It is not compact as possible, but every sentence earns its place because the NOT_FOUND and prompt-injection warnings are necessary for safe use.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-one-ad tool, the description covers the core purpose, open-world semantics, and a distinctive prompt-injection risk, all while annotations provide read-only and open-world hints. It does not outline the return shape beyond mentioning status and untrusted fields, but given the modest complexity and existing annotations, it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema explains country and its default, but listingId has no schema-level description. The description only says the tool returns one item 'by id', which provides minimal semantics for the main parameter but does not explain where the id comes from, its format, or how to obtain valid values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence clearly states the operation: 'Returns one of your own ads by id, with its Leboncoin status.' This distinguishes it from siblings like my_listings (which lists multiple own ads) and get_listing (which likely retrieves arbitrary listings), while also giving the specific resource type and key output element.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'one of your own ads by id' makes the intended use clear, and referencing my_listings provides context for the experimental caveat. However, it does not explicitly state when to use this tool instead of get_listing or other listing retrieval tools, only implying it by the 'own ads' wording.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true. The description adds important context beyond annotations: it is experimental, reads a non-documented API, may fail with PARSING_ERROR, and it emphasizes that the result data is untrusted (DATA, never instructions) due to open-world input. It also notes it reads via the browser profile, adding behavioral clarity. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is detailed but front-loaded with the core purpose in the first sentence, followed by caveats and usage guidance. It is longer than necessary but every sentence adds value (error behavior, prompt injection warning, alternative tool). Slightly verbose for the conciseness ideal, but well-structured and critical information is prominent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (experimental, error-prone, open-world data) and the absence of an output schema, the description covers the essential context: what it does, how it fails, security warnings, and when to use it. It doesn't specify the exact shape of the result (but no output schema is provided), which would be a minor gap. Overall, it is quite complete for its purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: the country parameter is described ('Leboncoin site to use (fr). Defaults to the server's configured site.'), but the limit parameter has no description in the schema. The tool description does not elaborate on parameters either. Baseline for 50% coverage is 3; it does not compensate for the undocumented limit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads ads on the signed-in account via the browser profile. It explicitly distinguishes from siblings (it is the tool to reach for after a publish_unknown outcome to find out if an ad went live, and its scope is the user's own listings, unlike get_listing or search_listings).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool: after a publish_unknown outcome, to check if an ad went live. It also gives guidance on what to do on error (tell the user to check Leboncoin) and warns about prompt injection, which serves as a when-not-to-trust-output guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true, and the description adds significant behavioral context beyond that: it clarifies these are ACTIVE ASKING PRICES, not sale prices, warns that Leboncoin publishes no transaction data, and instructs the agent to phrase outputs as 'des annonces similaires sont à environ 90 €' rather than 'ça se vend 90 €'. It even explains why asking prices skew high (unsold items stay listed, sold ones vanish). This is legitimate behavioral disclosure not present in annotations. A 4 is fair since the read-only nature was already disclosed by annotations, but the description does add substantial semantic and honesty constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph that packs a lot of value without waste. Every sentence earns its place: the core purpose, the exact output categories, the when-to-use guidance, the sibling alternative, the key semantic distinction (asking vs sale), and the user-facing language instruction. It is front-loaded with the purpose and the actionable output, followed by the caveats.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (25 params but high schema coverage, no output schema, read-only annotations), the description covers the key context an agent needs: what the tool does, what the outputs mean, how to phrase results for the user, and why the data is the way it is. It could arguably mention the percentile return more explicitly, but overall it is fairly complete for its complexity. A 4 is justified because it covers the important interpretive pitfalls without being exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high at 88%, so the baseline is 3. The description adds meaning for targetPrice and listingId implicitly by stating 'the user's asking price, or an ad you are looking at' and the schema says targetPrice is 'The price to judge. Required unless listingId is given.' The purpose text helps the agent understand the relationship between the judgment and the comparables, but most parameter semantics are already well covered by the schema. The description does not add much beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource combination: 'Places a price you already have... inside the distribution of comparable active listings' and explicitly names the five output verdicts (well_below, below, fair, above, well_above) plus percentile. It also distinguishes itself from its sibling estimate_price ('For "what should I ask?", use estimate_price instead.'), which clearly separates this judging tool from the pricing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use this tool: 'Use it to answer "is this a good deal?" or "is my price reasonable?".' It also provides an explicit alternative: 'For "what should I ask?", use estimate_price instead.' This is exactly the kind of when/when-not guidance that helps an agent choose correctly between siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and idempotentHint, so the description's claim of being 'purely local' adds valuable context beyond those. It also discloses the ranking behavior and leaf distinction, which are not implied by annotations. No contradiction found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at four sentences, front-loaded with purpose, then key behavioral insight, then a note about locality. Every sentence adds value with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description appropriately states it returns numeric IDs with full paths. It also provides critical domain knowledge about leaf categories and the consequence of choosing a wrong category. While it doesn't detail the ranking algorithm or edge cases, it covers the essential context needed for effective use. Missing explicit guidance on when to use this vs. list_categories, but overall complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67% (query and leafOnly have descriptions, limit does not). The description enhances understanding of leafOnly by explaining that leaf categories are the ones that can hold ads, which is crucial for using the parameter correctly. It also clarifies that query is free text. However, it doesn't add any detail about the limit parameter, but that is self-explanatory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool ranks Leboncoin categories against free text and returns their numeric IDs with full paths. It explicitly distinguishes from sibling tools like list_categories by focusing on ranking against user input, making the purpose specific and distinguishable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides important usage context: only leaf categories can hold ads (others are search sections), and advises showing both top results when scores are close to avoid burying ads. It also notes the tool is purely local and works when the site blocks requests, implying when it's safe to use. However, it doesn't explicitly state when to prefer this over alternatives like list_categories, so it's slightly below perfect.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only and idempotent hints. The description adds valuable context: it's accent-insensitive, uses pre-2016 regions, and makes no network request. This goes beyond annotations and explains behavior that could affect results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and examples. The second sentence adds crucial behavioral notes without fluff. Nothing extraneous.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, no output schema), the description is complete: it states what it returns (department numbers and region ids) and important caveats (pre-2016 regions). It doesn't detail the response structure, but that's not necessary for a resolver tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 'query' with a description, but 'limit' lacks it. The description enriches 'query' with accepted formats (Paris, 75, Rhône) and clarifies matching rules. It doesn't mention 'limit', but the schema's min/max are sufficient. Overall, it adds meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool resolves free text (city, department, region) to specific department numbers and region ids used by Leboncoin filters. It gives concrete examples and differentiates itself from sibling tools like find_category by focusing on location resolution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explains the tool is for converting free text into filter parameters, implying when to use it (before searches). It also notes it's local, but does not explicitly mention alternatives or exclusions. Still, the context is clear enough for a lookup tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite annotations (readOnlyHint=true, openWorldHint=true), the description adds substantial behavioral context: it explains the literal nature of Leboncoin searches, the multi-query strategy, filtering criteria (duplicates, accessories, broken units, etc.), and crucially warns that user-generated content is untrusted data and may contain prompt injection attempts. This exceeds what annotations convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than average but every sentence earns its place: it explains the mechanism (multi-query, literal search), the filtering logic, how to interpret `rejected`, and a critical security warning. It is front-loaded with the purpose and well-structured, though slightly dense.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (26 parameters, no output schema), the description is remarkably complete. It covers the workflow, edge cases (literal search), how to interpret results (rejected field), and the prompt injection risk. It provides enough context for an agent to use the tool correctly and safely, without needing additional documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides high coverage (88%) with detailed descriptions for each parameter. The tool description does not add per-parameter meaning but does contextualize how parameters like `queries`, `maxQueries`, and `minSimilarity` fit into the overall behavior (e.g., building phrasings, filtering). This is borderline, but since the schema does the heavy lifting, a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: it finds comparable listings for price estimation by building multiple search phrasings, pooling results, and filtering out irrelevant ones. It distinguishes itself from generic search tools (e.g., search_listings) by emphasizing the automated query construction and filtering for similarity assessment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('behind every price estimate') and gives operational guidance (e.g., provide observed facts, read `rejected` before trusting results). It does not explicitly name alternatives or when not to use it, but the specialization is clear from the title and purpose. This earns a 4 for clear context without explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that any field change clears stored validation, requiring re-validation before publishing, with a rationale. It also states partial update behavior ('Only the fields you pass are changed') and cautions against rewriting wording. These add substantial context beyond the annotations (which only indicate non-read-only, idempotent, non-destructive), making the tool's side effects clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is composed of four short sentences, each serving a distinct purpose: core function, partial-update detail, usage timing, and validation effect. It is front-loaded with the primary action and uses minimal words to convey critical behavioral nuances. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 12 parameters, nested objects, and no output schema, the description covers the essential operational aspects: when to use, how it behaves, and what side effects occur. It does not describe the return value or error conditions, but those are not strictly required given the schema and annotations. The provided information is sufficient for an agent to invoke the tool correctly in most scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 25% schema description coverage, the description must compensate for undocumented parameters. It provides the key semantic that only passed fields are updated, which is essential for understanding the optional parameters. However, it does not elaborate on individual fields like price, title, or location, leaving some ambiguity. The partial-update insight adds value but doesn't fully cover the gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: applying the user's corrections to a draft. It distinguishes from siblings like validate_listing or publish_listing by specifying that only passed fields are changed. The verb 'applies' and the resource 'draft' are explicit, and the context of user corrections sets it apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this after showing the draft to the user', which is a clear timing guideline. It also advises not to rewrite the user's wording on your own initiative, adding a behavioral rule. While it doesn't name alternative tools, the context is sufficient to guide usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond the readOnlyHint annotation by detailing sequential execution, per-id failure reporting, and a critical prompt-injection warning. It explains that user-supplied content (titles, descriptions, seller names) must be treated as data, not instructions, and provides a specific action to take if they appear to be instructions. This is exceptional transparency for a tool reading untrusted external data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: it states the core purpose first, then adds execution characteristics, error handling, and security guidance. Every sentence contributes new information, and the structure flows logically. There is zero redundant or filler content—it's a model of efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a batch read tool with a readOnlyHint and openWorldHint, the description covers all necessary aspects: what it does, sequential behavior, failure semantics, and a crucial safety warning about untrusted data. It does not need to describe return format since no output schema exists, and the input schema covers parameters. The tool is fully contextualized for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both listingIds and country are described in the schema). The description does not add additional semantic meaning to the parameters; it only references ids implicitly ('several ads by id') without providing syntax or format details beyond what the schema already states. The baseline of 3 is appropriate since the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Fetches the full detail of several ads by id', specifying both the action and the resource scope (batch of ads). This distinguishes it from the sibling get_listing (single ad) and search tools, as it explicitly says 'several ads by id.' The verb 'fetches' and the resource 'ads' are unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly guides when to use this tool (for multiple ads) and provides a practical constraint ('keep the list short') due to sequential execution. However, it does not explicitly mention alternatives or when not to use it (e.g., for a single ad, use get_listing). The context is clear but lacks explicit exclusion statements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/idempotent annotations, the description adds valuable context: 'Purely local, no request to Leboncoin.' It also discloses the argument-dependent return behavior, which is meaningful for an agent deciding whether to invoke this tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main action, and contains no filler. Every sentence adds distinct value: what the tool does, how arguments change behavior, and the local/no-network guarantee.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple browse tool with two optional parameters and rich annotations, the description is complete. It explains the core behavior, parameter effects, and the local execution model. No output schema exists, but the description sufficiently characterizes what the tool returns at a high level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already well documented in the schema. The description reinforces the `parentId` behavior but does not add significant semantic detail beyond what the input schema already states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Browses') and clear resource ('Leboncoin category tree'), and explains the two main behaviors: returning top-level sections with no argument and listing children with `parentId`. This clearly distinguishes it from sibling tools like find_category.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives practical usage context: no argument returns top-level sections, passing `parentId` lists children. It could explicitly mention when to prefer this over find_category, but the usage pattern is clear and self-contained.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds rich behavioral context beyond annotations: the tool doesn't throw, defines what each state means, and warns that datadome_blocked is not fixed by reauthentication. It also tells the agent never to ask for a password. This complements the annotations (readOnly, openWorld) without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense yet well-structured, with a clear state list and follow-up actions. Every sentence adds value, including the nuanced datadome_blocked distinction and the manual login command. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema, the description fully specifies all possible return states and the correct user-facing action for each. It also includes the manual login flow and a security note, making it self-contained for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides 100% coverage for the single 'country' parameter. The description does not add parameter-specific details, but no gap exists, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Reports whether a usable Leboncoin session exists' and enumerates specific states, making it distinct from siblings like whoami or diagnose. The verb 'Reports' and the resource 'session' are precise.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives actionable guidance: only prompt sign-in when reauthenticationRequired is true, and provides the exact manual login command. However, it doesn't explicitly compare with alternative tools or state when to choose this over them, so it's clear but lacks exclusionary guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, and the description adds value by disclosing the thrown-error behavior and the precise-code failure mode. It could have described the return shape or failure code format, but the conditional behavior is a useful addition beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler. The purpose is stated first, and the important caveat and alternative are packed into the second sentence without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only whoami tool with one optional parameter and clear failure behavior, the description is complete. It explains what it returns, when it fails, and which sibling tool to use instead.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the single optional parameter is fully described in the schema ('Leboncoin site to use (fr). Defaults to the server's configured site'). The tool description adds no extra parameter meaning, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Returns') and names the exact resource: the Leboncoin account the stored profile is signed in as. It clearly distinguishes itself from session_status by noting the failure behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool versus an alternative: 'use session_status instead if you want a diagnosis rather than a failure.' It also signals that a failure is thrown when no usable session exists, so agents know this is for identity queries, not session diagnostics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint, readOnlyHint), the description discloses additional behavioral details: it removes copied photos, does not affect Leboncoin, and explains the rationale for force deletion (local record is the only trace linking to live ad). This adds valuable context that the annotations do not cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) and well-structured, with bold for the key point. It front-loads the main action and then explains the exception. No unnecessary words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a delete operation, the description covers the primary action, its scope, and the special condition for force. It lacks an explicit statement about the return value or irreversibility, but the destructiveHint covers the latter. Given the simplicity of the tool and no output schema, this is sufficient, though slightly more detail about success/error behavior would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (only `force` has a description). The description expands on `force` by explaining the reasoning behind needing it ('the local record is the only trace'), which goes beyond the schema's brief line. For `draftId`, it provides no additional meaning, but the name makes it clear. Given low coverage, this compensation is adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Removes') and resource ('a local draft and its copied photos'), and explicitly distinguishes its scope from online content ('Does not touch anything on Leboncoin'). It is specific and distinct from sibling tools, which focus on other draft operations like get_draft, list_drafts, or update_draft.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the `force: true` flag (for published drafts or unknown publish states) and clarifies that it does not affect published ads. While it doesn't mention alternative tools directly, the condition for `force` serves as a usage guideline for edge cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=true, openWorldHint=true), the description discloses critical behaviors: the tool may run a search itself (openWorldHint), it removes outliers, it outputs active asking prices (not sale prices) due to Leboncoin's lack of transaction data, and it deliberately provides no recommended price at `insufficient_data`. These details add significant transparency beyond the structured annotations and directly impact agent behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively detailed but appropriately so, given the tool's complexity (25 parameters, no output schema). It front-loads the primary purpose and output summary, then adds important usage caveats. The bolded **Respect `confidenceLabel`** draws attention to a critical instruction. No redundant content, though it could be slightly more compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Since there is no output schema, the description thoroughly covers the return values (statistics, outliers, recommendation, confidence score). It also explains the confidenceLabel semantics, the handling of insufficient data, and the nature of the prices (asking vs. sale). Combined with high parameter schema coverage, the description leaves little ambiguity for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 84% (high), so the baseline is 3. The description adds meaning by explaining the two distinct input modes (using `comparables` vs. providing item facts) and clarifies that the tool can operate in either mode. While it does not elaborate on each parameter, it contextualizes the overall input strategy, which goes beyond what the schema alone provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Turns comparable ads into a price distribution and a recommendation' and enumerates the specific outputs (min, Q1, median, etc.). It also distinguishes itself from sibling tools by describing two invocation modes (pass comparables or run search) and mentioning the confidenceLabel behavior, which is not present in other pricing-related siblings like analyze_market_price.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage instructions: either pass `comparables` from a previous search, or pass item facts to let the tool run its own search. It also advises on how to handle `insufficient_data` (communicate lack of data, do not quote a number) and cautions against phrasing results as sale prices. However, it does not explicitly state when to choose this tool over alternatives like `analyze_market_price`, though the distinct scope is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds critical behavioral context beyond annotations: 'Nothing is sent to Leboncoin and nothing is published. The draft lives on this machine.' Also explains the offline mode with research:false. This aligns with annotations (openWorldHint=true, destructiveHint=false) and provides additional safety reassurance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two paragraphs, front-loaded with the primary purpose, and uses bold for key phrases like 'Nothing is sent' and 'research: false'. Every sentence adds value, but the flow is a bit dense; however, it remains readable and structured well.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (23 params, nested objects, no output schema), the description provides a complete overview of what the tool does from start to finish, including the workflow and offline option. It fully addresses the agent's need to understand the tool's behavior and role in the listing process.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 96%, so the schema already documents parameters thoroughly. The tool description adds minimal parameter-specific guidance beyond what's in the schema (e.g., research:false, price skip). It does not compensate for any gaps but doesn't need to, given high coverage; baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's role as 'The main entry point' for creating a listing draft, detailing specific actions (searches comparables, computes price, resolves category, writes title/description). It distinguishes from sibling tools like update_listing_draft and validate_listing by describing the full pipeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly outlines the workflow: 'Show the result to the user, apply their corrections with update_listing_draft, then validate_listing.' Also gives a specific use case for setting research:false 'when Leboncoin is blocking and you still want a draft the user can copy in by hand.' This provides clear when-to-use and alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
While annotations flag mutability, non-idempotency, and destructiveness, the description adds substantial unique context about retry safety ('Never retry, or you will create a duplicate public ad'), the server-side re-validation process, and a detailed three-state `outcome` contract (published/publish_failed/publish_unknown) explaining partial execution. This goes far beyond simply restating the annotation flags.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A dense, high-stakes description where every sentence delivers safety-critical guidance without fluff. It covers authorization, server-side checks, outcome states, and emergency procedures in a tight, purposeful flow. A bulleted outcome list could marginally improve scannability, but the paragraph structure effectively matches the gravity of the irreversible action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an irreversible, high-risk, non-idempotent action, the description leaves no gap: it defines user permission, server-side re-validation, all possible outcomes, and the correct response to ambiguity (publish_unknown). The absence of an output schema is fully addressed by the thorough documentation of the `outcome` field, making this end-to-end complete for an agent to act safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description significantly enriches the `confirm` parameter from the schema, clarifying it is 'necessary but NOT sufficient' and binding it to a per-turn user approval. It compensates for the missing output schema by thoroughly defining the `outcome` field and its three values, which is critical for the agent. The `draftId` parameter receives no additional depth, but its purpose is self-evident from its name and type.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a precise verb+resource statement: 'Publishes a draft as a real, public Leboncoin ad,' making the tool's core function unambiguous. It distinguishes itself from sibling tools in the prepare/validate/publish pipeline by emphasizing 'real, public' and 'IRREVERSIBLE,' which positions it as the final publishing step, clearly separating it from prepare_listing, validate_listing, and update_listing_draft.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit when-to-use guidance is provided: 'you may only set [confirm] after the user has seen the draft and explicitly told you, in that turn, to publish this specific ad.' It also gives a clear when-not with the example that "Looks good" about a draft is not permission. On `publish_unknown`, it routes to `my_listings` or manual checking, though it could name sibling tools like `validate_listing` more explicitly as alternatives for pre-flight checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses important behavioral traits: originals on disk are never modified or moved, and adding photos clears stored validation. These are non-obvious side effects and safety guarantees that an agent needs to know before invoking the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences: the first states the core action, the second addresses file safety, and the third gives a domain constraint and a side-effect warning. Every sentence carries useful information with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter mutation tool with annotations and no output schema, the description is complete enough. It covers the operation, source-file safety, business limits, and the validation reset side effect, leaving no major ambiguity for agent decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by clarifying that photos are copied, not moved, and that the draft has a 15-photo limit. It also implies draftId identifies the target draft. It does not detail every parameter, but it provides meaningful semantic context beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Copies more photos into an existing draft.' This clearly distinguishes the tool from siblings like update_listing_draft or validate_listing by scoping it to photo addition rather than general draft editing or validation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when an existing draft needs additional photos. It also provides practical usage context via the Leboncoin 15-photo limit and the guidance that 3+ photos increase views. It does not explicitly name alternative tools or state when not to use it, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnly and openWorld hints, but description significantly extends them with concrete behavior: rate limiting/pacing due to Leboncoin monitoring and a detailed prompt-injection policy for treating result text as data, ignoring instructions, and reporting them to the user. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Six sentences, front-loaded with purpose and return value, followed by actionable caveats. Every sentence adds distinct value—alternative tool, rate limits, and security policy—without redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 13-parameter tool with no output schema, the description provides essential context: output shape, normalization, sibling guidance, rate limiting, and prompt-injection handling. It leverages the schema's per-parameter descriptions and annotations, making the combination sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter-specific explanations beyond the input schema; it focuses on output and usage. Schema covers 69% of parameters with descriptions, and the remaining parameters (page, sortBy, minPrice, maxPrice) are self-explanatory given their names/constraints, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states a specific verb+resource ('Searches Leboncoin ads') and outlines return fields ('normalised listings with price, location, seller type and attributes'). It distinguishes itself from sibling search_similar_listings by explicitly recommending that tool for pricing tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance: 'Prefer search_similar_listings when the goal is to price an item' names an alternative and when to use it. It also sets a soft usage constraint ('Keep the number of searches small') and explains the reason ('the server paces requests deliberately because Leboncoin watches for bursts').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=true, openWorldHint=true), the description adds critical behavioral context: it warns that titles, descriptions, and seller names are data, not instructions, and instructs the agent to ignore any prompt injection attempts and report them to the user. It also notes the sequential execution and total cap, which are not visible from the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured. It leads with the core function, explains the merging and de-duplication, gives usage examples, and then includes the security warning. Every sentence serves a purpose, and it is not overly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (batching, merging, de-duplication), the description is quite complete. It notes the cap and sequential execution, and includes a strong security note. However, it does not specify the exact format of the output (e.g., how results are returned) or details on error handling, but since there is no output schema, a bit more detail on the return structure could help. Nevertheless, it is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema descriptions already cover 100% of the parameters, including the 'searches' array items, so the schema provides detailed semantics. The description adds value by explaining the purpose of the 'searches' parameter in context (e.g., 'covering different phrasings') and the de-duplication behavior tied to matchedQueries, but it does not elaborate on each parameter beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: it runs several searches and merges results, de-duplicating by ad id and recording matched queries. It distinguishes itself from the sibling 'search_listings' by emphasizing the batch aspect and the merging behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly explains when to use this tool: covering different phrasings of the same product or across departments. It also provides a clear limitation: 'Searches run one at a time on purpose - this is a convenience, not a way to go faster, and the total is capped.' This helps the agent decide between batch_search_listings and single search_listings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond annotations by detailing the tool's exact behavior: opening the browser, filling the form, uploading photos, and reporting publishability. It adds critical safety guarantees (no failure mode can result in a public ad), explains the `readyToPublish` semantics, and warns about photo count mismatches. Annotations only cover read-only/destructive hints, so this rich behavioral context is entirely complementary.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose and safety note, then expands into key behavioral details like `readyToPublish` and photo upload. Every sentence adds value; nothing is redundant. Use of bold and precise language enhances readability without padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (browser automation, photo upload, validation) and lack of output schema, the description covers all essential aspects: what it does, how it works, safety, success criteria, and a critical warning about photo uploads. It is fully self-contained for an agent to understand the tool's role and boundary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers `screenshot` with a description, and `draftId` is self-evident from context. The description adds meaning by explaining how the draft is used and clarifies the photo upload aspect, but does not explicitly detail the parameters themselves. Given the 50% schema coverage, the description compensates sufficiently without overexplaining.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool validates a draft against the live Leboncoin form, clearly distinguishing it from publication ('It cannot publish') and other draft-related tools. The verb 'validate' and specific resource 'a draft against the real Leboncoin form' provide immediate clarity on function and scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives direct guidance on when to use the tool ('run it before asking the user for permission to publish') and explains its role as a safe pre-publication check. It also implies the alternative (publish_listing) by contrast, making usage context explicit without extra verbiage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

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

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

Card Badge

Copy to your README.md:

[![mcplebon MCP server](https://glama.ai/mcp/servers/rachid598/mcplebon/badges/card.svg)](https://glama.ai/mcp/servers/rachid598/mcplebon)

Score Badge

Copy to your README.md:

[![mcplebon MCP server](https://glama.ai/mcp/servers/rachid598/mcplebon/badges/score.svg)](https://glama.ai/mcp/servers/rachid598/mcplebon)

Latest Blog Posts

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

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/rachid598/mcplebon'

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