Chenfeng AI Public Information MCP

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds only that the capabilities and contact entry points are 'public', which is minor context beyond the structured 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 a single front-loaded sentence with no wasted words. It is efficient, though its brevity contributes to gaps in usage and parameter guidance rather than being a structural flaw.

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 tool this is close to minimum viable, but with no output schema the description should explain what 'capabilities' and 'contact entry points' actually contain. It also fails to clarify the effect of the language parameter, leaving important context 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 0%, and the description does not mention the single 'language' parameter at all. The schema provides the enum values and default, but the description adds no meaning about how language affects the returned capabilities or contact entry points.

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

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

The description uses a clear verb ('Get') and names a specific resource ('public capabilities and contact entry points'), which distinguishes it from the sibling domain-resource tools. However, 'capabilities' is somewhat vague and the description does not explicitly contrast this tool with the get/list siblings.

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 no guidance on when to use this tool versus alternatives such as get_case, get_faq, or the list_* tools. It also provides no exclusions or prerequisites, leaving the agent to infer the use case.

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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds one real behavioral fact — only 'published public' cases are reachable, implying drafts/private cases yield no result — but says nothing about the not-found response or permission model.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

A single front-loaded sentence with no filler. It is efficient but arguably over-trimmed, since the space saved came at the cost of the language parameter.

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 with no output schema, the agent still lacks the language semantics and any indication of the returned shape or missing-id behavior. Adequate to call it, incomplete to call it well.

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%, so the description must carry parameter meaning and it only covers 'id'. The 'language' parameter (enum zh-CN/en, default zh-CN) is never mentioned, leaving the agent to guess that it controls the returned case study's locale.

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 one ... case study') and distinguishes itself from list-style siblings via 'one ... by id'. The qualifiers 'published public' narrow the scope usefully, though it never names list_cases as the lookup path.

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?

'By id' implies the caller must already have an identifier, which hints that list_cases is the discovery step, but this is left to inference. No explicit when-to-use or when-not-to-use statement, and nothing about what happens for unpublished or invalid ids.

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 readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description's only added behavioral fact is the 'published public' visibility constraint; it says nothing about not-found behavior or whether drafts/private records are filtered out silently.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

A single front-loaded sentence with no filler. Brevity is appropriate for a trivial lookup, though it undersells the tool rather than over-explaining it.

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 with full annotations and no output schema, most of what an agent needs is covered by structured fields. The unaddressed language parameter and the lack of any return/error semantics leave a meaningful gap given 0% schema description coverage.

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%, so the description must compensate and it does not. It never explains the id format (pattern ^[a-z0-9-]{1,80}$) and completely omits the second parameter, language, whose enum and zh-CN default are non-obvious and materially change the result.

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 (FAQ) with a scope qualifier ('one published public'), which is enough to distinguish it from the sibling list_faq. It stops short of naming that sibling explicitly, but the singular/plural split is inferable.

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?

'Get one ... by id' implies the retrieval-by-identifier use case and 'published public' hints that unpublished/private FAQs are out of scope. However, no alternative is named and no guidance is given on what to do when the id is unknown (fall back to list_faq or search?).

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one genuine behavioral fact beyond them – that only published, public resources are retrievable, implying unpublished ids fail – but says nothing about auth requirements or the shape of a not-found response.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

A single eight-word sentence with the resource and the published/public constraint front-loaded. There is no filler; the terseness is a coverage problem, not a structural one.

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 say something about what a returned resource looks like or how absence is signalled, and it does not. It also omits the language parameter entirely, leaving a caller unable to know it can request English content.

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%, so the description must carry parameter meaning, yet it only echoes the required id parameter without explaining its pattern or meaning. The optional language parameter (enum zh-CN/en, default zh-CN) is never mentioned, so an agent would not learn from the description that localized retrieval is even possible.

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, plus a meaningful scope qualifier: only one published public resource, retrieved by id. That scoping already separates it in spirit from list_resources, though it never names the sibling or states the list-vs-single relationship explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no mention of alternatives such as list_resources for discovery, and no statement about what happens when the id is unknown or the resource is not public. The only usage signal is the implicit 'by id', which the schema's required field already conveys.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact — only *published public* services are returned — but says nothing about what happens for unpublished/unknown ids or how the language parameter affects the response.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

A single front-loaded sentence with zero filler. It is efficient, though the brevity borders on under-specification rather than disciplined conciseness.

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 two-parameter read with full annotation coverage and no output schema, this is close to adequate. The gaps are the undocumented language parameter and the absence of any note on not-found behavior for non-published services.

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%, so the description must carry parameter meaning and it largely does not. "by id" weakly maps to the required id field (the regex constraint is left entirely to the schema), and the optional language enum with its default is never mentioned at all.

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 one ... service") and scopes it to "published public" records, which distinguishes it from list_services and from any admin-side retrieval. It does not explicitly name a sibling, but "one ... by id" makes the singular-vs-list distinction obvious.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: the agent can infer this is the single-record counterpart to list_services. There is no explicit statement of when to prefer it, what to do when the id is unknown, or how it relates to get_resource/get_case/get_faq.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful 'published public' filter scope, but says nothing about result size, pagination, or ordering, which matter for a list tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

One short sentence with no filler, and the key scope qualifier is front-loaded. It is efficient, though it is arguably too terse given the gaps elsewhere.

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 annotations covering safety and no output schema, the description is minimally adequate. It omits the language parameter's effect and any hint about result shape or volume, leaving small but real gaps.

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%, but the single parameter is a two-value enum (zh-CN/en) with a default, which is largely self-documenting. The description never mentions the language parameter or what the default implies, so it adds no 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?

States a specific verb (List) and resource (case studies) with a scoping qualifier ('published public') that tells the agent these are the public-facing entries. It implicitly contrasts with the singular get_case sibling, though it never names it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent can infer this is the enumeration counterpart to get_case, but the description never says when to use this versus get_case or the other list_* tools. No exclusions or prerequisites are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered elsewhere. The description's one contribution is the 'published public' filter, which tells the agent unpublished or private FAQs are excluded — useful, but no mention of result ordering, limits, or pagination.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

A single short sentence with no filler, front-loading the verb and scope. Efficient, though brevity comes at the cost of the missing parameter and usage detail.

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 rich annotations and no output schema, the description covers what is returned at a high level. It falls short on the language parameter's effect and on when to prefer get_faq, leaving real gaps for an agent choosing between the two.

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% and the single parameter ('language', enum zh-CN/en, default zh-CN) is not mentioned in the description at all. With one parameter and zero schema documentation, the description should compensate and does not.

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 ('list ... frequently asked questions') plus a scope qualifier ('published public'), which separates it from get_faq by implying a collection rather than a single item. It does not explicitly name any sibling, so the differentiation is inferred rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance at all: nothing says to call this instead of get_faq when a specific question is needed, nor any prerequisites or exclusions. The only hint is the 'list' versus 'get' naming convention shared with siblings.

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 readOnly, idempotent, non-destructive, and closed-world, so the safety profile is fully covered. The description contributes the non-obvious filter that only published, public resources are returned, which is genuine behavioral context, but says nothing about ordering, pagination, or result size.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

One front-loaded sentence with no filler. It is efficiently sized, though the terseness borders on under-specification given the surrounding toolset.

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, zero-required-parameter list tool with annotations covering safety and no output schema, the description is close to adequate. It still omits how the language parameter changes results and whether the list is paginated or bounded, which an agent would want before calling.

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%, so the single 'language' parameter relies entirely on its enum (zh-CN, en) and default. The description never mentions that the listing can be localized or what the default does, so it fails to compensate for the coverage gap, though the parameter is simple enough that the risk is low.

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 verb and resource ('List ... resources') and adds scope qualifiers ('published public') that meaningfully narrow the result set. It does not explicitly distinguish itself from the sibling get_resource, though the list/get split is reasonably self-evident.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to call this versus get_resource, list_cases, list_services, or list_faq. The agent must infer that this is the enumeration counterpart to get_resource purely from the verb.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds one useful behavioral fact — that only 'published' and 'public' services are returned, implying unpublished ones are excluded. It says nothing about result size, ordering, or pagination, so it adds moderate rather than rich context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

One front-loaded sentence with zero filler. It is efficient, though bordering on under-specified given the presence of an undocumented parameter and no output shape.

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, so the description should ideally hint at the return shape (list of service summaries? IDs to feed into get_service?) and at the language parameter's effect. Annotations cover safety, so the gap is mainly in return-value expectations and parameter behavior — enough to be adequate but not 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% and the description never mentions the single 'language' parameter, its zh-CN default, or what happens to returned content when a language is chosen. The enum values are self-explanatory, but the description contributes no semantics at all for the only parameter.

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

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

States a specific verb+resource: 'List published public services.' The plural 'list' plus 'published public' scoping distinguishes it reasonably from get_service (singular detail fetch). It does not explicitly contrast with list_cases/list_faq/list_resources, but the resource noun itself carries the differentiation.

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 guidance on when to use this versus get_service for detail, or versus the other list_* siblings. The only implicit signal is that it lists rather than fetches a single record. No prerequisites, exclusions, or alternative routing are given.

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