ZacharyR0th
Server Details
Anonymous public tools for ZacharyR0th. See the published agent boundary before use.
- Status
- Healthy
- Uptime
- 100.0% over 22 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 7 tools
Each tool targets a distinct resource/action except search_work and search_writing, which could be confused since 'work' and 'writing' both imply portfolio content; descriptions clarify one is selected projects and the other publications, but the boundary is not immediately obvious. The get_project/get_publication and list/search operations are otherwise clearly separated.
All tools follow a consistent snake_case verb_noun pattern: get_ for single items, search_/list_ for discovery. No mixed conventions or vague verbs like 'process' or 'do'. The names accurately reflect their operations.
Seven tools is well within the ideal range and each tool covers a distinct aspect of a personal portfolio (contact, experience, projects, publications, writing). Nothing feels redundant or excessive for the site's purpose.
The read-only personal-site domain is well covered: contact, experience, projects, and publications are all accessible. Minor gap: projects lack a dedicated list_all equivalent, relying on search_work for discovery, but this is workable for the scope.
Available Tools
7 toolsget_contact_optionsGet Contact OptionsARead-onlyInspect
Use this when an agent needs to return public contact and profile links without sending a message.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering the read-only and non-destructive nature. The description adds a behavioral nuance by stating 'without sending a message', which clarifies the tool is not a communication action—useful context beyond the annotations, especially given the word 'contact' might suggest messaging. This extra specificity earns a 4.
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 zero waste. It presents the primary usage condition first, then the resource, and fits entirely in one line. This is the ideal level of conciseness for a simple tool.
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-parameter tool with an output schema, the description is fully complete. It states what the tool returns and when to use it. Since there are no inputs, no behavior beyond read-only is needed, and the output structure is defined by the schema. Nothing an agent would need to call it correctly 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?
With 0 parameters and 100% schema coverage (trivially), there is no ambiguity. Per the rubric, 0 params sets a baseline of 4. The description adds no parameter details because none are needed, and it does not contradict the schema. This 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 verb ('return') and resource ('public contact and profile links'), and explicitly contrasts with sending a message. It clearly differentiates from sibling tools that return experience, projects, publications, or writing content, so an agent can immediately know this is the right tool for contact/profile 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?
The description opens with an explicit trigger condition ('when an agent needs to return public contact and profile links without sending a message'), giving clear guidance on when to invoke it. It does not explicitly list exclusions or alternative tools, but the context is unambiguous for a zero-parameter tool, and the sibling set makes the alternative obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_experienceGet ExperienceARead-onlyInspect
Use this when an agent needs to return the public professional positioning and selected systems published on the site.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds light context ('public ... published on the site') but does not disclose behavioral details such as response shape, pagination, or rate limits, though the output schema may cover return structure.
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 filler. It states the action and resource immediately and earns its length without 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?
For a parameterless, read-only getter with an output schema, the description adequately identifies what data will be returned. The phrase 'selected systems' could be more explicit, but the output schema can carry the structural detail, so nothing critical is missing for 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?
The tool accepts zero parameters and the schema has no properties, so there is no parameter meaning for the description to add. Schema coverage is effectively complete, and a zero-parameter tool does not require parameter elaboration.
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 action ('return') and names a distinct content resource: 'public professional positioning and selected systems published on the site.' It is not a tautology and is reasonably distinguishable from sibling tools like get_project, get_publication, or search_work, though it does not explicitly contrast with 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?
The opening 'Use this when an agent needs to...' provides an explicit condition for when the tool is appropriate. It does not list exclusions or compare directly with sibling tools, so it falls short of full guidance, but the intended context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_projectGet ProjectARead-onlyInspect
Use this when an agent needs to get one public project by canonical identifier.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Canonical public identifier |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the base safety profile is known. The description adds the important scope limitation that the project must be public, and clarifies it returns exactly one result ('one public project').
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 sentence that front-loads the use case and ends with the identifying mechanism. Every word 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?
This is a simple read-only get-by-id tool: one required parameter with a complete schema, an output schema, and safety annotations. Nothing an agent needs to call it correctly is missing; the description appropriately stays minimal.
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% – the schema already explains id as 'Canonical public identifier.' The description's phrase 'by canonical identifier' simply restates the parameter's meaning without adding format, constraints, or edge-case behavior.
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 the specific verb 'get' with the resource 'project' and narrows to 'one public project by canonical identifier.' The verb-resource pair clearly distinguishes it from sibling tools like list_publications or search_work.
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 phrase 'Use this when an agent needs to...' gives a direct invocation condition. It lacks explicit exclusions or alternative tool names, so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_publicationGet PublicationARead-onlyInspect
Use this when an agent needs to get one public publication by canonical identifier.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Canonical public identifier |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds slight context by noting the publication is 'public' and the identifier is 'canonical,' but these details are also present in the parameter schema. No behavioral surprises are disclosed beyond those already implied by 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 that instantly communicates purpose and usage. Every word earns its place; there is no redundancy or 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 single-parameter read-only getter, the description is fully adequate. The output schema exists, annotations cover the behavioral safety profile, and the description tells the agent exactly when to use it. 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 100%, with the 'id' parameter described as 'Canonical public identifier.' The description echoes 'canonical identifier' but adds no semantic meaning beyond the schema, so the baseline of 3 applies because the schema carries the full parameter explanation.
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 the verb 'get' and the resource 'one public publication by canonical identifier,' which is specific and distinct from its siblings. It inherently separates itself from list_publications (singular vs plural) and from other resource-specific getters like get_project or get_experience.
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 frames the usage condition ('when an agent needs to get one public publication by canonical identifier'), giving clear context for when to invoke it. It does not mention alternatives or exclusions, so it stops short of the top score but provides unambiguous guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_publicationsList PublicationsBRead-onlyInspect
Use this when an agent needs to list public writing and publications.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'list' action is consistent with those — no contradiction. The description adds the scoping nuance ('public writing and publications') but little else; for a zero-parameter list tool whose output schema handles return values, the annotations carry most of the behavioral disclosure burden.
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 efficient sentence with no filler. The 'Use this when' framing front-loads the usage intent, though the clause largely echoes the tool name, so it is slightly redundant rather than additive.
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 low-complexity tool with no parameters, an output schema, and safety annotations covering mutability, the description is largely sufficient. The main gap is the lack of differentiation from search_writing, which a caller relying on the description alone would not be able to resolve, but that is a minor omission for such a simple 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?
The tool has zero parameters, so the schema trivially provides 100% coverage and there is nothing for the description to explain. Per the zero-parameter baseline, a 4 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 action (list) and a resource scope ('public writing and publications'), and the plural verb distinguishes it from the singular sibling get_publication. The wording is slightly redundant with the name, and the phrase 'public writing and publications' is a bit ambiguous about whether writing and publications are distinct categories, but the core purpose 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?
The description is framed as a usage guideline ('Use this when...'), but the content simply restates the purpose ('an agent needs to list...'). It provides no exclusions, no conditions for choosing this over the siblings search_writing, search_work, or get_publication, and no guidance on when a search would be more appropriate than a full list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_workSearch WorkARead-onlyInspect
Use this when an agent needs to search Zachary Roth’s public selected work.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Case-insensitive public search query |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the search targets public content, but discloses no further behavioral details such as result ordering, limits, or search semantics. This is adequate but not rich.
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 sentence that directly states the tool's purpose and appropriate use. There is no filler, and the key 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 simple one-parameter search tool with read-only annotations and an output schema, the description is mostly sufficient. However, the close sibling `search_writing` is not addressed, so the context for choosing between the two search tools is incomplete.
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%, with the `query` parameter already described as a case-insensitive public search query. The tool description adds little beyond the resource context, so the schema carries the semantic weight and the baseline score applies.
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 action ('search') and the target resource ('Zachary Roth’s public selected work'), so an agent can understand the basic purpose. However, it does not differentiate from the sibling tool `search_writing`, which may refer to overlapping content and introduces selection ambiguity.
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 states when to use the tool: 'when an agent needs to search Zachary Roth’s public selected work.' It does not mention alternatives or exclusions, which would strengthen guidance, but the stated use case is clear enough for most invocation decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_writingSearch WritingARead-onlyInspect
Use this when an agent needs to search public writing and publication metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Case-insensitive public search query |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so no safety contradiction exists. The description adds a 'public' scoping boundary, which helps set expectations about the search universe, but it does not disclose behavior like result ordering, pagination, or coverage limits beyond what annotations and schema show. It contributes only modest additional behavioral 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?
The description is a single front-loaded sentence with no filler, restating neither the name nor the schema. Every phrase contributes either a usage condition or a resource definition.
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 one well-documented parameter, a true output schema, and read-only annotations, the description is largely sufficient for a basic search call. The main gap is the lack of differentiation from search_work and list_publications, which could cause an agent to select the wrong sibling without extra inference. This is a minor gap given the low complexity.
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 documents the sole parameter, including its case-insensitive behavior and max length, so the baseline is 3. The description adds no query-specific semantics beyond the resource scope identified in the main text. There is no deficit because coverage is complete.
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 identifies a specific action ('search') and resource ('public writing and publication metadata'), making the tool's core function clear. It does not explicitly contrast with sibling tools like search_work or list_publications, which creates some overlap ambiguity. Overall, the purpose is stated distinctly enough.
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 opening 'Use this when...' provides an explicit trigger condition, telling an agent the intended scenario for invoking this tool. However, it offers no guidance on when not to use it or how to choose among siblings such as search_work, get_publication, or list_publications.
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.
7 tool updates
- First observed
get_contact_options - First observed
get_experience - First observed
get_project - First observed
get_publication - First observed
list_publications - First observed
search_work - First observed
search_writing
Related MCP Connectors
Anonymous public tools for Zachary Roth Music. See the published agent boundary before use.
Anonymous public tools for Raintree Technology. See the published agent boundary before use.
Anonymous public tools for Raintree Minerals. See the published agent boundary before use.
Anonymous public tools for FlightSweeper. See the published agent boundary before use.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables autonomous agents to access transparent public utilities such as UTC time, HTTP status catalogs, IANA time zones, and tool compatibility checks, while preserving privacy through daily rotating pseudonyms and no storage of raw identifiers.9 npmMIT
- AlicenseAqualityBmaintenancePortable agent tools with typed schemas (diff, cron, units, JSON→TS, outdoor helpers, prompts). Free to try—no account required.30MIT
- AlicenseCqualityAmaintenanceStateless URL, DNS, x402, JWT, encoding, and parsing tools for AI agents.44MIT
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to discover and create agents, durably submit messages with verifiable replies, and search source-linked local memory. Exposes eight authenticated tools with owner-approved OAuth, transcript-backed verification, and explicit control over history import and embedding.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.