syntropy-mcp

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the fork is isolated and private and that the public axioms remain unaltered, but it omits permissions, whether the fork inherits all axioms, and what happens to the source world after forking.

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 definition is a single front-loaded sentence with no wasted words. The action and its rationale are both immediately clear.

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 creation tool with no output schema and no annotations, the description covers isolation and non-alteration well. It does not state what is returned (for example, the new fork's handle or ID), which is a meaningful gap when no output schema exists.

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 both parameters are already documented in the input schema. The description adds no extra meaning about the format of world_id_or_handle or any constraints on title, so the baseline of 3 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 states a specific verb and resource: "Create an isolated private fork of a public Small World." The trailing purpose clause ("so custom rules can be ingested without altering public axioms") implicitly separates forking from the sibling ingest_axioms tool, though it does not name that sibling 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?

It gives a rationale for when forking is appropriate: custom rules can be ingested without altering public axioms. However, it does not explicitly say when to choose this over ingest_axioms directly, nor does it state prerequisites such as whether the source world must be public or whether the caller needs ownership.

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 no annotations, the description carries the full load, and it does disclose the return payload concretely: a complete interactive SKILL.md document, plus the specific topics it covers (ground-truth sources, max_failures iterations, on_refuted behavior, API keys) and code templates. It implies a read-only retrieval with no side effects but never says so outright, and says nothing about document size/versioning, so not a 5.

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 sentences, front-loaded with the return value before the usage guidance, with no filler. The second sentence is dense, packing several parenthetical topic names and a code-template clause, but each element is informative rather than redundant.

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 zero-parameter, no-annotation, no-output-schema document fetcher, the description covers what is returned and when to call it, which is what the agent needs to select and invoke it. The only omission is behavioral framing (static/read-only, document size), a minor gap given the simplicity of the 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 takes zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. The description correctly implies no inputs are needed before calling it.

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: it returns the complete SKILL.md onboarding/implementation guide. The resource is clearly distinct from the sibling tools (world/axiom/verify operations), so an agent can tell what this does without opening a schema. It stops short of an explicit contrast statement against siblings, hence a 4 rather than a 5.

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 clear trigger: call it whenever the user asks to integrate, set up, or connect Syntropy into their project. It also explains the downstream benefit (knowing which questions to ask and which code templates to apply), which is strong context. There are no explicit exclusions or named alternatives, which keeps it at 4.

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 no annotations and no output schema, the description carries the full burden; 'Retrieve' establishes this is a read-only fetch and 'all atomic ground-truth axioms' signals an unfiltered, complete return set. It does not disclose volume, pagination, ordering, or any permission requirements, which matters for a 'retrieve all' call against a document collection.

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 sentence with zero filler, front-loading the verb and the returned content before the input qualifier. It is efficient but arguably undersized, since some of the freed space could have been spent on routing to siblings.

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 tool with no annotations and no output schema, the definition covers what is fetched and what identifier to supply. It leaves gaps around what an 'atomic axiom' looks like in the response, whether results are bounded, and how this differs from syntropy_verify on the same world.

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% and the single parameter is documented with both a handle example ('@pravo:obcansky-zakonik-cz') and the UUID alternative. The description only restates that a handle or ID is accepted, adding no format or resolution behavior beyond the schema; baseline 3 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 uses a specific verb ('Retrieve') and a clearly named resource ('atomic ground-truth axioms and metadata') scoped to a Small World handle or ID. An agent can distinguish it from syntropy_list_worlds (enumeration) and syntropy_verify (validation), though it never explicitly states those contrasts.

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 or when-not-to-use guidance and no sibling tool is referenced, so the agent must infer that this is the fetch-by-identifier path rather than the verification or listing path. The only contextual clue is that it takes a handle or ID, which is a parameter fact rather than usage 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?

No annotations are supplied, so the description carries the full burden. It does usefully disclose that deduplication and conflict resolution happen, which is real behavioral context beyond the schema, but it omits whether the operation overwrites existing axioms, what permissions it needs, whether it is idempotent, and what it returns.

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 dense sentence with no filler, front-loaded on the action and its output. It is jargon-heavy ('Axiomat', 'Small World') but that terminology is consistent with the surrounding tool family.

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 five-parameter write tool with a nested payload object, no annotations, and no output schema, one sentence is thin. The agent still lacks input-mode guidance, mutation/overwrite semantics, and any indication of the result shape, though the deduplication and conflict-resolution hint covers part of the behavioral surface.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds a little by framing text vs payload as two source modes and tying conflict resolution to the ingest step. It stops short of clarifying the key ambiguity the schema leaves open: neither text nor payload is required, so nothing tells the agent which one to supply.

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 pair (extract and synchronize) and a specific resource (atomic axioms) with a named destination (a Small World via Axiomat). This is clearly distinguishable from read-oriented siblings like syntropy_get_world_axioms and syntropy_list_worlds, though it never names a sibling 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?

The description offers no when-to-use guidance, no prerequisites, and no alternatives. It says axioms can come from 'raw text or a JSON record' but never states when to choose one input mode over the other, nor whether they are mutually exclusive – which is exactly the decision an agent faces at call time.

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 no annotations, the description must carry the behavioral burden, and it does disclose meaningful scope: only public and officially verified worlds are returned, so private or unverified content is excluded. However, it says nothing about pagination, result limits, ordering, no-auth-required status, or what a returned world record looks like.

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, which is appropriate for a simple list tool. The one weak spot is the unexplained '@domain:tag' notation, which adds ambiguity rather than value for a reader who hasn't seen the library.

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-optional-parameter read-only list tool with no output schema and no annotations, the description covers what is listed and its visibility scope, which is the essential part. It stops short of describing return contents, ordering, or result-size behavior, which an agent needs to plan a follow-up call correctly.

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 both optional parameters are already documented with examples. The description adds only the '@domain:tag' notation for world identity, which hints at the domain parameter's vocabulary but does not explain how 'domain' and 'search' interact or whether search covers tags.

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 gives a specific verb ('List') and a specific resource ('public and official verified Small Worlds'), plus scope qualifiers that tell the agent this is a discovery/enumeration tool. Siblings like syntropy_get_world_axioms retrieve content for one world, so the distinction is inferable, though the description never names them 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?

Usage is only implied: an agent can guess this is the entry point for discovering worlds before calling syntropy_get_world_axioms. There is no explicit 'use this when...' statement, no mention of prerequisites, and no guidance on choosing between the optional domain filter and keyword 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?

With no annotations provided, the description carries the full disclosure burden and does well: it explains the adversarial trial mechanism, that the verdict is deterministic, and what fields the response contains. It does not mention cost, latency, or authentication expectations, and the word 'deterministic' is slightly opaque given model-backed debate, but overall behavioral context is strong.

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 two dense sentences that front-load the core action and then the return contract, with no filler. Some technical jargon ('5-sieve Syntropy dialectical engine', 'Syntropy dialectical') may slow comprehension but is not wasteful.

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 complex, multi-parameter tool with no output schema, the description adequately covers what the tool does and what it returns (verdict plus supporting argument structure). Missing details like expected runtime or the implications of model choice are minor, and the 100% schema coverage fills in parameter-level 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 description coverage is 100%, so parameter meaning is already supplied by the schema; the description adds little beyond reiterating axioms and Small World inputs. It does not clarify trade-offs among model_name, max_failures, or enable_research beyond what those fields already state, so baseline 3 is appropriate.

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

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

Names a specific verb-and-resource action ('put a falsifiable claim on formal adversarial trial') and enumerates concrete inputs (axioms, Small World handles) and outputs (CONFIRMED/REFUTED verdict, winning thesis, refuting argument, triggered axioms). This clearly distinguishes it from siblings like syntropy_get_world_axioms and syntropy_list_worlds, which only inspect state.

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 useful context about the types of claims suitable for trial (contract clauses, scientific hypotheses, AI outputs) and indicates that axioms and/or a Small World are needed. However, it doesn't explicitly say when to prefer this over sibling tools or whether to call syntropy_get_world_axioms first, leaving some workflow guidance to inference.

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