Which conferences a company sponsors, exhibits at or speaks at, and who is open to sponsors.
Glama couldn't complete the latest health check. If this server requires authentication, missing or expired test credentials may be the cause. A test profile lets Glama authenticate for health checks and discover tools; it is separate from your personal connections.
If you are the author, claim ownership, then add or update a test profile under Admin → Test Profile.
Scored across 9 tools
Each tool targets a distinct question: company footprint, sponsorship-open events, structured search, detailed conference info, CFPs, organizer contact, and change tracking. The apparent overlap between search/search_conferences and fetch/get_conference is explicitly resolved with 'prefer' guidance and different argument signatures, so an agent can choose correctly.
Names mix verb-first (search_conferences, get_conference, find_calls_for_speakers) with noun-first (company_events, organizer_contact, events_open_for_sponsorship) and bare verbs (search, fetch). There is no single predictable pattern, though the consistent snake_case style and related pairs like search/search_conferences keep it readable.
Nine tools is well within the ideal range and each one maps to a distinct marketer question about conferences. Even the two compatibility wrappers earn their place by enabling OpenAI-style connectors while the structured versions remain the preferred path.
The surface covers the full read-only workflow: discover events, inspect detailed line-ups, find sponsorship and speaking opportunities, check company footprints, monitor changes, and contact organizers. There are no obvious dead ends, and the honest 'whats_new' limitation is a data constraint, not a missing tool.
Every conference a company appears at, as sponsor, exhibitor or as the employer of a speaker. Past and upcoming. This is the question no other public source answers: give it a company name or a domain and it returns the event footprint. Up to 25 by default, 100 at most, upcoming first. Coverage depends on how a company spells its own name across event sites, so treat the list as strong evidence, not a complete census.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Rows to return. Default 25, maximum 100. | |
| company | Yes | Company name or domain, e.g. Datadog or monday.com. Pass it exactly as the user wrote it; do not strip or add a domain. | |
| include_past | No | Include finished events. Default true. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare openWorldHint=false, but the description directly contradicts this by warning that coverage depends on company name spelling and that the result should be treated as 'strong evidence, not a complete census.' That is explicitly an open-world completeness caveat, so an agent relying on the annotation would draw the wrong conclusion about absent results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the core scope, and every sentence earns its place: scope, unique value, output limits/ordering, and data-quality caveat. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers input type, result scope, default/maximum limits, ordering, and a meaningful coverage caveat. While there is no output schema and the exact returned fields are not itemized, the description gives enough context for an agent to invoke the tool correctly, apart from the open-world contradiction.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents company, limit, and include_past with defaults and usage guidance. The tool description adds only the conceptual 'name or domain' framing, which is already present in the schema, so it does not materially raise the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States precisely what the tool does: given a company name or domain, it returns conferences where that company appears as sponsor, exhibitor, or speaker's employer, covering past and upcoming events. This clearly distinguishes it from sibling tools like events_open_for_sponsorship and get_conference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description identifies the exact question this tool answers ('the question no other public source answers') and the correct input form. However, it does not explicitly name alternatives or state when not to use it, so routing relies on the agent's inference from sibling names rather than explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upcoming conferences that publish a sponsor page or a sponsor prospectus, so a marketer can see who is taking sponsors now. Filter by city, country or topic. Up to 25 by default, 100 at most. Pass a slug to also get the companies that sponsor comparable events but not this one.
| Name | Required | Description | Default |
|---|---|---|---|
| city | No | City name. | |
| slug | No | One conference slug. Adds the sponsors its peers have and it does not. | |
| limit | No | Rows to return. Default 25, maximum 100. | |
| topic | No | Topic or industry. | |
| country | No | Two-letter country code. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the operation read-only, idempotent, and non-destructive. The description adds meaningful behavioral details beyond that: the default and maximum row limits (25/100) and the unusual slug behavior that returns sponsors from comparable events not sponsoring this one. This helps the agent understand what the tool actually returns and how it behaves at boundaries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences with no filler. It front-loads the core purpose, then lists filters, limits, and the special slug behavior in natural order. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, filterable list tool with 5 optional parameters and no required fields, the description gives enough information to invoke it correctly. It covers what is returned, how to filter, the limit behavior, and the optional enrichment via slug. The lack of an output schema is acceptable because this is a list-retrieval tool and the descriptions focus on selection semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the input schema already describes each parameter and the default/maximum limit. The description reinforces the same information ('Filter by city, country or topic', 'Up to 25 by default, 100 at most') without adding meaningfully new semantics. This meets the baseline for a fully covered schema.
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 clearly identifies the resource: upcoming conferences with a sponsor page or prospectus, and the intended use case for marketers seeking sponsorship opportunities. It is immediately distinguishable from sibling tools like search_conferences or get_conference by focusing specifically on conferences 'open for sponsorship'. The phrasing 'see who is taking sponsors now' adds a concrete, actionable purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool: when a marketer wants to find conferences currently accepting sponsors. It also explains the available filtering dimensions (city, country, topic) and the optional slug behavior. However, it does not explicitly say when NOT to use this tool or compare it to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compatibility tool: OpenAI connectors require a tool with this exact name and one string argument. Returns one conference for an id from search — dates, location, speakers, sponsors and exhibitors — as a block of text. Prefer get_conference where you can: it returns the same edition as structured fields and lets you set how many of each list come back. The id is the conference slug.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | An id from search. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavioral nuance: the output is 'a block of text' rather than structured fields, and the id must be a conference slug obtained from `search`. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no filler. The compatibility constraint is front-loaded first, then the core behavior, then the preferred alternative, then the id semantics. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter, read-only compatibility shim, this is complete. It explains why the tool exists, what it returns (including the specific conference fields), how it relates to get_conference, and what the id means. No output schema exists, but the description enumerates the content sufficiently for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds the clarification that 'The id is the conference slug,' which is concrete and useful beyond the schema's generic 'An id from search.' This small but meaningful extra justifies a 4.
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 opens with a specific role: 'Compatibility tool: OpenAI connectors require a tool with this exact name and one string argument.' It then states the actual behavior: 'Returns one conference for an id from `search` — dates, location, speakers, sponsors and exhibitors — as a block of text.' It clearly distinguishes itself from get_conference, which returns the same edition as structured fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use it ('OpenAI connectors require a tool with this exact name') and when not to: 'Prefer get_conference where you can'. It gives a concrete reason — get_conference returns structured fields and allows configuring list sizes — so an agent can route correctly without ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Conferences currently accepting speaker submissions, with the deadline and the submission link. Soonest deadline first, up to 25 by default and 100 at most. Only calls that close before the event starts are returned.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Rows to return. Default 25, maximum 100. | |
| topic | No | Topic or industry, e.g. security. | |
| within_days | No | Only calls closing within this many days. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and idempotentHint=true, so no safety contradiction exists. The description adds meaningful behavioral detail beyond annotations: results are sorted by soonest deadline, limited to 25 by default and 100 max, and filtered to calls that close before the event starts.
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 crisp sentences deliver the core purpose, return contents, ordering, limits, and an important filter condition. There is no redundancy or filler; every sentence adds value.
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 read-only list tool with three optional, well-documented parameters and no output schema, the description adequately explains what will be returned (conferences with deadlines and links), how results are ordered, and the applicable limits and filters. Nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the three parameters (limit, topic, within_days) are already fully documented. The description adds some context about defaults and limits but does not meaningfully enhance parameter understanding beyond the schema, so the baseline 3 is appropriate.
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 clearly identifies the tool's purpose: finding conferences currently accepting speaker submissions, and specifies what is returned (deadline and submission link). It is also distinguishable from siblings like events_open_for_sponsorship by focusing on speaker calls rather than sponsorship.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives strong context for when this tool is appropriate—when you need open calls for speakers with deadlines and links. However, it does not explicitly state when to prefer an alternative or mention exclusions relative to sibling tools, leaving some inference to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One conference edition in full: its speakers, sponsors, exhibitors and sessions. Take the slug from search_conferences. This is the detailed form of fetch and the one to prefer — same edition, but you choose how many of each list come back. Lists are capped at 25 each while the counts are the true totals, so a result can read '312 sponsors, showing 25'. Many upcoming editions publish before their line-up does: empty lists are normal and do not mean the event has none.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Conference slug, e.g. websummit-2026. | |
| facet_limit | No | Rows per list. Default 25, maximum 50. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive behavior, and the description adds useful runtime behavior beyond that: lists are capped, counts represent true totals, and empty lists do not indicate missing data. The only blemish is that 'capped at 25 each' seems inconsistent with the schema's 50-row maximum for `facet_limit`.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four compact sentences, each earning its place: scope, source of slug, relationship to `fetch`, list cap behavior, and empty-list semantics. The most important scoping information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with only one required parameter and no output schema, this description is complete enough for an agent to call it correctly. It names the returned sections, clarifies list limits and counts, and tells the agent how to obtain the required `slug`.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value: it tells the agent the slug comes from `search_conferences` and explains that `facet_limit` controls how many rows come back per list. The 'capped at 25' wording conflicts with the schema's maximum of 50, which slightly weakens the guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific resource and action: fetching one conference edition in full with speakers, sponsors, exhibitors, and sessions. It also distinguishes itself from the sibling `fetch` by calling itself the detailed form of that tool, so an agent can reliably tell them apart.
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 explicitly tells the agent where to get the slug (`search_conferences`), which tool it should prefer over (`fetch`), and how it differs from that alternative. It also preempts confusion about empty lists by explaining they are normal for upcoming editions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
How to reach the organiser of one conference. Returns the conference page on conferencegrid.com plus its sponsor page and prospectus where the organiser publishes them. Direct organiser addresses are never returned. Events less than 21 days away are declined, because that is too late for an organiser to act on an approach.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Conference slug, from search_conferences. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only, idempotent, and non-destructive, so the description adds valuable behavior beyond them: it never returns direct organiser addresses, and it declines events less than 21 days away. It also clarifies that the sponsor page and prospectus are returned only when the organiser publishes them. There is no contradiction with the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four short sentences and every one earns its place: purpose, return content, privacy constraint, and date cutoff. It is front-loaded with the tool's purpose and keeps the most operationally important constraints near the end without padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read-only tool with no output schema, the description is complete: it states what is returned, when the request is declined, and what is never returned. An agent can safely invoke it using a slug from search_conferences and understands the key failure condition in advance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully describes the single slug parameter as 'Conference slug, from search_conferences,' so schema coverage is 100%. The description reinforces that the tool handles one conference at a time but adds no new detail about the parameter's format or source beyond what the schema provides. The baseline of 3 is appropriate here.
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 leads with a clear purpose ('reach the organiser of one conference') and then states specifically what it returns: the conference page, sponsor page, and prospectus where published. It also draws a firm boundary by saying direct organiser addresses are never returned. It does not explicitly distinguish itself from get_conference, which may also return a conference page, but the organiser-reaching framing makes the scope reasonably 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?
The intended use case is clear: use this tool when you need to approach the organiser of a single conference indirectly. It also gives an explicit when-not condition: events less than 21 days away are declined. It does not name sibling alternatives such as get_conference or events_open_for_sponsorship, but the context is enough for an agent to infer when this tool applies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compatibility tool: OpenAI connectors require a tool with this exact name and one string argument. Searches conferences by free text — a city, a topic, a company or a conference name — and returns at most 10 results as id, title and url only. If you can pass separate arguments, use search_conferences instead: city, country, topic and dates, up to 100 rows, with the detail this one leaves out. Pass an id to fetch.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to look for. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish this as read-only, idempotent, and non-destructive; the description adds important behavioral limits: maximum 10 results, only id/title/url fields, and the fact that richer detail is deliberately omitted. This goes well beyond annotation coverage and gives the agent realistic expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, each with a distinct purpose: compatibility reason, core behavior, alternative routing, and follow-up action. There is no filler or redundant restatement, and the most decision-relevant information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description still specifies return shape, result count cap, and query scope. It also points to the alternative for richer data and to fetch for record details, making the tool fully actionable on its own.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only describes query as 'What to look for,' but the description explains that it accepts a city, topic, company, or conference name and is a single string argument. This materially enriches the parameter meaning beyond the schema.
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 clearly states this is a compatibility tool for OpenAI connectors, searches conferences by free text, and returns at most 10 results as id, title, and url. It further distinguishes itself from search_conferences by noting the single-string-argument and limited-detail nature of this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool (when OpenAI connectors require the exact name and one string argument) and when to use the alternative (search_conferences for separate arguments and more detail). It also routes id-based follow-ups to fetch, giving clear decision guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find upcoming B2B conferences by city, country, topic or date window. The structured way to search, and the one to reach for first: up to 100 rows, soonest first, each carrying its counts and the date we last verified it. Use search only when you cannot send separate arguments; it takes one plain string, returns 10, and omits the detail here. An empty result means no match in the window asked for, not that the market is empty.
| Name | Required | Description | Default |
|---|---|---|---|
| to | No | Latest start date, YYYY-MM-DD. | |
| city | No | City name, e.g. Berlin. | |
| from | No | Earliest start date, YYYY-MM-DD. Defaults to today. | |
| limit | No | Rows to return. Default 25, maximum 100. | |
| topic | No | Topic or industry, e.g. devops, fintech. | |
| country | No | Two-letter country code, e.g. DE. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior. The description adds meaningful behavior beyond that: result cap of 100, soonest-first ordering, each row carries counts and a last-verified date, and empty results mean no match in the requested window, not an empty market. This is extra contextual value rather than repetition of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: purpose first, then the structured-search differentiator and key behavioral facts, then the empty-result caveat. It is front-loaded, scannable, and free of filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description must explain what results look like. It covers limit, ordering, row attributes (counts, verified date), and empty semantics, which is strong. The only gap is that 'counts' is vague without an output schema, so the exact return shape is not fully specified. Still, this is minor given the otherwise complete guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying that this is specifically for B2B conferences, framing `from`/`to` as a coherent 'date window', and explaining empty-result semantics in relation to that window. It doesn't duplicate schema details and gives a small but useful boost.
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 opens with a specific verb and resource ('Find upcoming B2B conferences') and immediately lists filter dimensions: city, country, topic, date window. It also distinguishes itself from the sibling `search` by calling itself the structured, first-choice search, so an agent can tell them apart without opening schemas.
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 explicitly says to reach for this tool first, and gives a concrete when-not condition: use `search` only when separate arguments cannot be sent, noting that `search` takes one plain string, returns 10, and omits detail. This is direct guidance about when to choose this tool versus an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Changes for one company or one conference since a date: sponsors, exhibitors and speakers that appeared, and editions that were edited. Up to 50 by default, 100 at most, newest first. Honest limit: this reports records that appeared, not records that were edited, so a sponsor moving from silver to gold does not show up here.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | No | Conference slug to watch. | |
| limit | No | Rows to return. Default 50, maximum 100. | |
| since | No | ISO date or timestamp. Defaults to 30 days ago. | |
| company | No | Company name or domain to watch. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even with readOnlyHint and idempotentHint annotations, the description adds important behavioral detail: default limit of 50, maximum of 100, newest-first ordering, and the crucial appeared-vs-edited distinction. This prevents false expectations about what 'what's new' means. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences front-load the core purpose, then state constraints (limit, ordering), then close with an honest caveat. Every sentence earns its place with no filler or repetition of schema fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description carries the burden of explaining what the agent will get, and it does so for the key dimensions: scope, record categories, ordering, limits, and semantic boundary. It does not specify the exact response shape or behavior when neither slug nor company is provided, but these are minor for a simple change-feed tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all four parameters. The description reinforces that slug and company correspond to 'one company or one conference' but adds no per-parameter semantics beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific query resource—changes since a date for one company or conference—and enumerates exact record types: sponsors, exhibitors, speakers that appeared, and editions that were edited. This clearly differentiates it from sibling tools like company_events or search_conferences by scope and change-tracking angle. The 'Honest limit' caveat further sharpens what the tool does and does not report.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this for one company or conference over a date range, with concrete defaults and limits. It also explicitly warns that sponsor tier changes won't appear, helping agents avoid using it for edit-detection. It does not name sibling alternatives, so it stops short of explicit when-to-use-versus-other-tools guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
company_eventsevents_open_for_sponsorshipfetchfind_calls_for_speakersget_conferenceorganizer_contactsearchsearch_conferenceswhats_newPublic index of YouTube sponsorships: which brands sponsor which creators, from sampled videos.
Company Insights: job postings, tech stack, news events, key customers, similar companies...
Sales intelligence — research companies, qualify prospects, and find contacts.
Find brands that already sponsor podcasts like yours, then reveal the buyer to pitch.
Add one secure layer between your agents and this server.
