Track & Blade
Server Details
Marketplace for used construction equipment: read-only listings + OEM specs. Not seller of record.
- Status
- Healthy
- Uptime
- 100.0% over 25 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool targets a clearly distinct operation: single listing retrieval, multi-listing search, OEM spec lookup, and job-based recommendation. Overlap between search_listings and recommend_machines is minimal and descriptions clarify when to use each.
All tools follow a consistent snake_case verb_noun pattern (get_listing, get_specs, recommend_machines, search_listings). Singular/plural choices align naturally with semantics.
Four tools is well-scoped for a read-only marketplace/research server, covering search, retrieval, specs, and recommendation without redundancy. Each tool earns its place.
The read-only buyer workflow (search, get, specs, recommend) is fully covered with no dead ends. Minor gaps exist: no write/management operations and no bulk enumeration of makes or classes, though these may be out of scope.
Available Tools
4 toolsget_listingGet listingAInspect
Get one Track & Blade listing by listing_id. Sold units return status sold and price null.
| Name | Required | Description | Default |
|---|---|---|---|
| listing_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and delivers a useful non-obvious behavioral detail: sold units return status 'sold' and price null. This is exactly the kind of quirk-wise context that helps an agent interpret results. It lacks error/not-found behavior and auth notes, keeping it below 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with the primary action, the second sentence adding high-value edge-case info. Zero waste.
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 single-param read tool with no annotations or output schema, the description supplies the key domain quirk (sold → null price). It would be fully complete with a note on not-found behavior or id source, but it's largely sufficient.
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?
One parameter with 0% schema description coverage. The description implies listing_id identifies the listing but adds no format or provenance detail (where the id comes from, expected shape) beyond the name. Baseline for a single param with full context would be higher; here it's marginal.
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 ('Get') and resource ('one Track & Blade listing by listing_id'), identifying the singular-lookup nature that distinguishes it from the plural sibling search_listings. The resource bounding is clear.
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 guidance or reference to alternatives. The 'one ... by listing_id' phrasing implicitly signals single-item retrieval versus search_listings, but no condition or exclusion is stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_specsGet specsAInspect
Official OEM spec figures from data/spec-cards.json. Pass listing_id or make and model, with optional year. Missing figures are omitted; nothing is estimated.
| Name | Required | Description | Default |
|---|---|---|---|
| make | No | ||
| year | No | ||
| model | No | ||
| listing_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses the data source and the completeness policy ('missing figures are omitted; nothing is estimated'), which tells the agent not to expect back-filled data. It says nothing about read-only nature, auth needs, or failure behavior for unmatched lookups.
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 resource and source, followed by invocation and data-quality notes. No filler, no repetition of the name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only lookup with no output schema, the description covers source, invocation modes, and missing-data behavior — enough for an agent to call it correctly. It stops short of describing the shape of returned spec figures, which an agent might reasonably want given no output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and no parameters are marked required, so the schema alone gives no guidance. The description compensates well by clarifying the alternative key sets (listing_id OR make+model) and that year is optional — a relationship the bare schema does not express.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource precisely (official OEM spec figures) and its backing source (data/spec-cards.json), so an agent knows exactly what comes back. It does not, however, distinguish this from siblings like get_listing, which presumably also returns listing data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It tells the agent how to call it ('Pass listing_id or make and model, with optional year'), which implies the two supported lookup modes. But it never states when to prefer this tool over get_listing or search_listings, and offers no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recommend_machinesRecommend machinesBInspect
Recommend fitting live inventory for a job, then verified OEM models not in stock. Read-only. Sold units are excluded. Missing specs stay unknown.
| Name | Required | Description | Default |
|---|---|---|---|
| job | Yes | ||
| soft | No | ||
| limit | No | ||
| job_notes | No | ||
| include_oem_suggestions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose meaningful traits: it is read-only, sold units are excluded, and missing specs remain unknown rather than being fabricated. It does not cover how soft filters behave or what the OEM toggle changes, but the core behavioral profile is unusually well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences with no filler, front-loading the primary behavior (recommend live inventory) before qualifications. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema or annotation coverage, and the tool has a large nested soft-filter object plus a limit and free-text notes field. Given that complexity, the description omits too much about inputs and result shape to be considered complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across 5 parameters, including a nested soft-object with 15 undocumented filter fields. The description never names or explains job, soft, limit, job_notes, or include_oem_suggestions, only loosely hinting at 'job' and OEM suggestions. It fails to compensate for the coverage gap.
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 (recommend) and resource (machines) and adds scope detail: fitting live inventory first, then OEM models not in stock. This functionality is clearly distinct from retrieval siblings (get_listing, search_listings, get_specs), though it never names 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?
Usage is only implied ('for a job'). There is no guidance on when to choose this over search_listings or get_specs, no prerequisites, and no exclusions. An agent must infer the decision boundary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_listingsSearch listingsAInspect
Search Track & Blade used-equipment listings. Filters: class, make, model, year/price/hours min and max, free-text query. Limit defaults to 10 and caps at 25.
| Name | Required | Description | Default |
|---|---|---|---|
| make | No | ||
| class | No | ||
| limit | No | ||
| model | No | ||
| query | No | ||
| year_max | No | ||
| year_min | No | ||
| hours_max | No | ||
| hours_min | No | ||
| price_max | No | ||
| price_min | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does disclose useful behavior beyond the schema: results are capped at 25 and default to 10, which tells the agent to be careful about pagination. It omits result shape, ordering, and whether filters are AND-combined, and 'Search' only implies a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no filler, with the resource identified up front before the filter inventory. Every clause maps to a calling decision and nothing is repeated from the schema verbatim.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 11-parameter tool with no annotations and no output schema, the description covers the input side adequately and gives the limit behavior. It leaves out how results are returned or ordered, empty-result behavior, and whether the min/max pairs can be combined with free-text query, which an agent would need to call 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 0%, so the description must carry meaning, and it does group and name all 11 parameters: class, make, model, the year/price/hours min-max pairs, the free-text query, and limit. It also adds the default/cap semantics for limit that the schema alone does not convey. It stops short of units, currency, or matching semantics (exact vs partial) for the string filters.
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 (Search) and resource (Track & Blade used-equipment listings), so it is immediately distinguishable from get_listing (single fetch), get_specs, and recommend_machines. It does not name a sibling or explicitly contrast itself, but the verb+domain is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the verb and the enumerated filter dimensions, which conveys that this is the multi-criteria browsing entry point. However, it never states when to prefer this over get_listing or recommend_machines, nor any prerequisite conditions, leaving routing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
- Added
recommend_machines
3 tool updates
- First observed
get_listing - First observed
get_specs - First observed
search_listings
Related MCP Connectors
Public, zero-auth, read-only access to Gkmex used-crane inventory.
Live listings, sold prices and resale scores from GovAuctions.app, the public surplus-auction site.
BigIron MCP — US ag/construction/livestock/transportation equipment auctions from bigiron.com.
AI-native used car marketplace. 145K+ vehicles, 4300+ dealers, 13 US states, 20 MCP tools.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables searching live and confirmed-sold agricultural, construction, livestock, and transportation equipment auctions, with lot details, current bids, and Buy-It-Now prices.609 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search live musical-instrument marketplace listings — guitars, amps, pedals, synths, drums and pro audio — filtering by make, model, category, condition, price band, year and region, and to pull full listing detail, seller profiles and the category tree. It returns current asking prices only, with no realized sold-transaction data.7 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables browsing and searching European industrial equipment, vehicles, real estate, and bankruptcy/insolvency liquidation auction lots, with live bids, lot details, and realized sale-price comps.205 npmMIT
- AlicenseNot gradedqualityDmaintenanceDeterministic industrial parts replacement engine with official catalogs and expert accuracy checksMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.