Kolect Creator Search

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

Discloses the cost model (free first daily checks, then 5 credits each), the no-charge case for thin-data creators, 7-day free reuse, and the crucial caveat that this is a rule-based estimate rather than platform data with a presentation instruction. This adds substantial context beyond the annotations and explains why readOnlyHint=false while idempotentHint=true.

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 sentences, front-loaded with the core action, then constraints, pricing, and the estimation caveat. Every clause carries actionable information with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-output-schema tool it covers inputs, cost, reuse, and the nature of the result well. It stops short of describing the shape of the returned estimate (score scale, per-creator breakdown), which is the only remaining gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 67%; the description compensates by explaining the provenance requirement for creator_ids and the meaning of search_id (the search these creators came from). It reinforces the 20-item cap already in the schema rather than adding new detail there.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Estimate how real up to 20 creators' followers are.' It even names the signals used (views, engagement, likes, following) and the 20-item scope, so an agent distinguishes it from search_creators or lookup_creators without opening a schema.

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?

Gives explicit prerequisites (creator ids must come from this user's searches, lookups, or saved creators) and routes credit questions to get_account. It also states the when-not condition via the 7-day reuse rule and the fresh=true override, leaving little to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: a call is free (consumes no credits) and the returned values include today's free allowances and this key's daily credit limit, which is the kind of quota context annotations cannot express.

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?

Compact and dense — a single enumerative sentence plus two short fragments with no filler. The one weakness is that the most actionable guidance ("Free. Check it before a large paid step.") is trailing rather than 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 carries the burden of describing return values, and it enumerates the returned fields (plan, credits, daily allowances, limits, collections) well enough for an agent to know what it will get. It does not cover error states or auth requirements, which is a minor gap for a read-only, free call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes no parameters, so there is no parameter semantics to explain; the baseline for a zero-parameter tool is 4. The description instead spends its words on what the call returns, which is the relevant substitute 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?

States a specific resource (the user's Kolect plan, credits, limits, collections) and the verb is implied by the retrieval framing. It is clearly distinguishable from action siblings like save_creators or check_fake_followers, though it never explicitly names a sibling it contrasts with.

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?

"Check it before a large paid step" gives an explicit when-to-use condition, and "Free" signals the cost tradeoff that motivates that guidance. It stops short of naming alternatives or when-not-to-call, so it is strong context rather than full routing.

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

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

Goes well beyond the annotations by disclosing billing behavior (5 credits per email, no email = no charge), free-tier conditions, a promotion with a daily cap, and a privacy constraint ('Only show emails to this user; never publish them'). This explains why readOnlyHint=false for what looks like a read, resolving potential confusion.

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?

Front-loads the core action, then layers billing/privacy conditions. Sentences are dense and information-rich; a reader must parse the free-vs-paid branches, but no sentence is 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?

No output schema exists, yet the description covers what is returned (public contact emails, per user only) and the cost model. It is nearly complete; only the exact return shape (e.g., per-creator missing-email handling) is left implicit.

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 50% (search_id documented, creator_ids only constrained). The description compensates by explaining search_id's role in billing and by reinforcing the 20-creator cap on creator_ids. It adds real meaning beyond the schema, though it does not detail creator_ids format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Get public contact emails') plus a concrete scope ('for up to 20 creators'). An agent can immediately distinguish this from siblings like lookup_creators (which finds creators) or get_account. The privacy note further pins down what is returned.

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?

Clearly explains the conditions that select this tool: pass search_id for creators from a prior search (already paid), or unlock creators found via lookup_creators at 5 credits each. It gives strong when-to-use context via the pricing branches but does not explicitly state when NOT to use it or name an alternative tool to reach for instead.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful cost context ('free') and paging behavior via the cursor, though it does not mention rate limits or auth requirements. Given the lower bar with annotations, this is strong but not maximal.

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 tightly written sentences, front-loaded with the core purpose and immediately followed by paging and the sibling alternative. No filler or repetition.

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 paged list tool with rich annotations and no output schema, the description covers what is returned ('creators already delivered'), how to page, and when to use the alternative. It could be slightly clearer about the cursor naming mismatch, but nothing essential 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 coverage is 67%, putting the baseline at 3. The description hints at paging but calls the value 'next_cursor' while the actual parameter is named 'cursor', and the limit parameter remains undocumented. It adds little meaning beyond the schema's own descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: reading creators already delivered by earlier searches. It explicitly distinguishes itself from load_more_results, which retrieves new creators, so an agent can choose between them 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?

Names the exact alternative tool and the condition for using it: 'To get new creators beyond those already delivered, use load_more_results.' It also implies the search_id source ('one of the user's earlier searches') and explains paging via the cursor.

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

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

With readOnlyHint and openWorldHint already declared, the description adds genuine non-schema context: the call is free, and the response includes current follower and view numbers plus the user's collections. That tells the agent what kind of data comes back and that there is no cost barrier, going beyond the annotations, though it says nothing about pagination, freshness/staleness of the numbers, or auth requirements.

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 core action and scope are front-loaded in the first clause, and the trailing fragments ('Free', 'Good for...') each carry distinct information without padding. It is compact and readable, losing only a little on the choppy fragment style.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter read-only tool with no output schema, the description covers what is listed, the filtering options, the returned fields, and the cost signal, which is close to sufficient for correct invocation. The remaining gap is the undocumented 'limit' parameter and any statement of pagination behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50%: the 'collection' parameter is documented in the schema, while 'limit' has no description anywhere. The description's '(all, or one collection by name or id)' largely restates the collection schema text rather than adding syntax or behavior, and it leaves the limit/pagination semantics unexplained, so it only partially compensates 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?

It names a specific verb and resource ('List the user's saved creators') and scopes it to 'all, or one collection by name or id', which cleanly separates it from siblings like search_creators and lookup_creators that don't operate on the saved list. It stops short of naming those siblings explicitly, so an agent must infer the boundary from the word 'saved'.

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?

'Good for building a shortlist, a report or a spreadsheet' hints at intended use cases, and 'Free' signals cost, which is relevant when choosing between this and heavier search tools. However, it never states when NOT to use it or points to an alternative such as search_creators when the user has not saved anything yet, leaving the routing decision to inference.

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

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

Annotations declare readOnlyHint=false (mutation via credit charge) and idempotentHint=true, but the description adds crucial context: the cost per 2 creators and the fact that repeated calls with the same args return the same page without charging. This explains the idempotency and cost model, adding value 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences covering purpose and cost behavior. Front-loaded with what it does, then cost details. Efficient without waste, though could be slightly more structured with usage conditions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description should explain return values, but it references 'new creators returned' and the credit model, giving enough for an agent to call correctly. It covers the mutation cost and idempotency, which are key for a tool with these annotations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50%: search_id is described in the schema, but count lacks a description. The description doesn't elaborate on the count parameter or its default/range, so it doesn't fully compensate for the coverage gap, leaving baseline 3.

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 (load more) and resource (results/new creators) for a prior search, distinguishing it from search_creators as a continuation mechanism. It's clear but doesn't explicitly name the sibling it continues, though the 'earlier searches' phrasing implies the connection.

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 implies usage context: for fetching additional results from a prior search, with the search_id linking to search_creators. It doesn't state when NOT to use it or name alternatives like search_creators explicitly, but the credit and re-call behavior provide practical guidance.

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

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

Goes well beyond the annotations by disclosing per-plan quotas (10/200, 30/500, 100/3000), the fact that the daily limit only counts first-time-found creators, and the over_daily_limit skip behavior. These are operational traits an agent cannot derive from readOnlyHint=false / idempotentHint=true.

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?

Front-loads the core purpose, then the dependency, then cost and limits. It is dense but nearly every clause carries a distinct fact; the long parenthetical quota enumeration is the only part that feels heavier than necessary.

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 usefully notes the returned creator ids and the skipped/over_daily_limit outcome. It stops short of describing the full response shape (e.g. how not-found creators are reported), but an agent has enough to call and interpret it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description restates that bare @handles need platform and restricts supported platforms to TikTok, Instagram and YouTube, which largely duplicates the schema's enum and field description rather than adding new semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('check whether specific creators are in Kolect's database'), the accepted identifier formats, and the output (creator ids), plus the downstream tools that consume those ids. This distinguishes it clearly from search_creators and list_saved_creators.

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?

Gives strong context: it is the prerequisite step for check_fake_followers, get_emails and save_creators, and it is free. It does not explicitly say when to prefer this over search_creators, but the lookup-vs-search distinction is implied by the identifier-based input.

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

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

Annotations cover the safety profile (non-read-only, idempotent, non-destructive, closed-world), and the description adds context beyond them: the operation is free, ids must originate from this user's searches/lookups/saved creators, results surface on the Kolect website with CSV export, and quotes are recorded as 'my quote' visible only to the user.

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?

Front-loaded with the core action, then progressively adds prerequisites, downstream effects, and the quotes nuance — no sentence is filler. It is somewhat dense in a single block, which costs it the top score.

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 compensates by describing where saved creators go and how they are used (website, CSV export, my-quote visibility). For a 4-parameter write tool this is nearly complete; only the return payload shape is left unstated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 75%, and the description still adds meaning: collection accepts a name or id and creates it when new; quotes record the rate the user actually got and are shown only to this user; search_id ties ids to their originating search. Only amount/currency/note remain purely schema-documented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('Save creators to the user's Kolect favorites') plus the optional collection scope, and implicitly distinguishes itself from list_saved_creators and lookup_creators by naming what it does rather than reads. An agent can identify the write path without opening the schema.

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?

Gives a concrete precondition: creator ids must come from this user's searches (with search_id), lookups, or saved creators — a real when-to-use rule. It does not explicitly name sibling alternatives (e.g., when to prefer lookup_creators first), so it falls short of a full routing rule.

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

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

Goes well beyond the annotations by disclosing the credit economics (1 credit per 2 creators, count 20 = 10 credits, no results are free), the 15-minute repeat-call caching that avoids double charging, and the operational caveat that ai_estimate values are estimates that must be surfaced to the user. It also explains why readOnlyHint is false: the call has a real cost. That is exactly the kind of context annotations cannot carry.

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?

Front-loads the purpose in one sentence, then layers the how-to-use, pricing, caching and follow-up routing in a tight sequence with no filler. It is on the dense side for a single paragraph, but every clause carries information an agent needs before calling.

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 correctly fills the gap by describing what comes back (creator id, search_id, ai_estimate) and how each is consumed downstream. Combined with the cost and caching rules, an agent has everything needed to call this correctly and present results responsibly.

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 75% and the description adds real meaning on top: 'any language' for brief, similar_to's three accepted input forms, and the credit consequence of count ('count 20 = 10 credits'). It does not restate the count min/max bounds, which the schema already covers, so it stops just short of a 5.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Search Kolect's database of TikTok, Instagram and YouTube creators') and immediately distinguishes itself from siblings like lookup_creators and list_saved_creators by naming them for follow-up work. An agent knows exactly what this tool returns: creators, not accounts or saved lists.

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 prescribes the three modes of use: a plain-language brief, similar_to for lookalike discovery, or both. It even names the accepted forms of similar_to (profile link, @handle, creator id) and routes the agent onward to check_fake_followers, get_emails, save_creators, load_more_results and get_search_results. Nothing about when to reach for this tool is left to inference.

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