ActualHumanTake
Server Details
Submit products for human-written feedback and retrieve review status through MCP.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
Each tool targets a clearly different object: aggregate public service metrics, a single request's private status/feedback, and creation of a new request. The two read tools could superficially overlap, but the descriptions make the public-aggregate vs. per-request-token distinction explicit.
All three names follow a consistent snake_case verb_noun pattern (get_public_stats, get_review_status, submit_product_for_review) with verbs that match the operation type (get for reads, submit for create).
Three tools is minimal but each covers a distinct step of the workflow (submit, poll/read, public stats) with no filler. It sits at the low end of the comfortable range, so slightly thin rather than over-scoped.
The core lifecycle is covered: submit a request, retrieve its status or completed feedback, and view public service stats. Minor gaps exist (no cancel/withdraw or ability to list one's own requests), but the token-based model makes those largely non-essential for the stated purpose.
Available Tools
3 toolsget_public_statsGet public review statsAInspect
Read the public completed-review count, average turnaround, and target SLA.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden: it at least establishes this is a read-only, public-facing lookup with no side effects. It says nothing about data freshness, caching, rate limits, or availability, which are the meaningful behavioral traits for a stats endpoint.
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 well-formed sentence with the resource list front-loaded and zero filler. Nothing could be removed without losing information.
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 name the return values, and it names all three metrics. It falls short only on freshness/as-of semantics that an agent might want before citing the numbers.
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 zero parameters and the schema is empty, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly does not invent input 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?
The description pairs a specific verb ("Read") with concrete resource fields — completed-review count, average turnaround, target SLA — so an agent knows exactly what it returns. It does not explicitly contrast with the sibling get_review_status, leaving the boundary between the two somewhat implicit.
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 statement of when to call this versus get_review_status, no prerequisites, and no exclusions. The word "public" is the only signal, and it is not framed as guidance about auth or audience.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_review_statusGet review statusAInspect
Check a request or read its completed feedback. Requires both the request ID and its secret receiptToken. Keep the token private.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| receiptToken | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden. It does disclose the key access-control fact — both the ID and a secret receiptToken are mandatory, and the token must be kept private — which is genuinely useful beyond the schema. However, it says nothing about read-only versus mutating behavior, what happens with an invalid or expired token, or whether feedback becomes unavailable at some point.
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 short sentences, front-loaded with the action and followed by the hard requirement and the security caveat. Nothing is redundant and there is 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?
With no output schema and no annotations, the description should explain what comes back — a status value, a feedback payload, or both — and whether results appear only after review completes. It never describes the return shape, so an agent knows how to call it but not what to expect. Adequate for a two-parameter read tool, but with a clear 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 description coverage is 0%, so both parameters are undocumented in the schema. The description partially compensates by naming what each parameter is — the request ID and its secret receipt token — which is more than the bare property names give. It still omits where the token originates and any format expectations, so the gap is only half closed.
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 concrete verb-and-resource pair: check a submitted request's status or read its completed feedback. It is distinguishable from submit_product_for_review (which creates the request) and get_public_stats (unrelated aggregate data). The phrase 'check a request' is slightly loose, but the intent is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: you call this once you hold both the request ID and its receipt token, typically to poll status or fetch finished feedback. There is no explicit statement of when to prefer it over siblings, no note on repeated polling, and no exclusions. An agent can infer the situation but gets no routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
submit_product_for_reviewSubmit a product for human reviewAInspect
Submit a product for an honest, human-written review. The request starts queued; only a human reviewer completes it. The returned receiptToken is secret and is required to read a private result. Public visibility is off by default.
| Name | Required | Description | Default |
|---|---|---|---|
| focus | No | ||
| product | Yes | ||
| publicOk | No | ||
| contactEmail | No | ||
| submitterName | No | ||
| idempotencyKey | No | ||
| submitterModel | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the queued lifecycle, human-only completion, that receiptToken is secret and mandatory for reading a private result, and that public visibility defaults off. It omits mutating/destructive signalling and idempotency behavior for a write tool with an idempotencyKey parameter, leaving a real gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, front-loaded with the action, then the lifecycle, then the token and privacy caveat. No filler, though the token sentence would be clearer if it were explicitly framed as a return value rather than sitting ambiguously among call semantics.
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 7-parameter, nested-object submission tool with no annotations and no output schema, the description covers lifecycle and the key return artifact but leaves the submitter metadata, contact email, idempotency, and focus taxonomy unexplained. It is adequate to know the tool's shape but not to fill the payload confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across 7 parameters, including a nested product object with six subfields, so the description must compensate and largely does not. It only indirectly touches publicOk ('public visibility is off by default') and mentions receiptToken, which is not even a parameter; focus, contactEmail, submitterName, submitterModel, and idempotencyKey get no 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 opens with a specific verb+resource ('Submit a product for...review') and immediately scopes what kind of review (human-written, honest), which separates it from the read-only siblings get_review_status and get_public_stats.
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 conveys implied usage by explaining that the request starts queued and only a human completes it, so an agent understands this is an async handoff. But it never states when to call this versus get_review_status, nor any prerequisites such as what to do after receiving the token beyond a passing mention.
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.
3 tool updates
- First observed
get_public_stats - First observed
get_review_status - First observed
submit_product_for_review
Related MCP Connectors
Read-only MCP tools that check if a store and product feed are ready for AI shopping.
Use Everyn's hosted MCP server to turn datasets into reviewed, exportable results.
Validate authored product facts and export reviewed Merchant Center supplemental TSV files.
Synthetic UX reviews, findings, evidence images, and repair prompts. OAuth required.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables MCP agents to submit content for human review via LoopQuest, returning verdicts asynchronously.25 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to submit markdown for human review, track feedback, and apply revisions through an HTTP API with an optional MCP wrapper.2Apache 2.0
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to classify free-text purchase descriptions into United States federal procurement codes and submit authorized, idempotent reviews through typed tool contracts.MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to file review jobs that real human reviewers open, return pinned comments and verdicts on, and approve, so agents can iterate on built sites, videos, and other artifacts based on genuine human feedback.38 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.