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

Since annotations are absent, the description carries the burden of behavioral disclosure. It covers the side effect (appends a snapshot), the precondition (ingest role), and the conditional requirement for trusted origin (ingest_attestation). It does not mention whether the operation is destructive, reversible, or how failures are handled. For a mutating append operation, this is a moderate disclosure, but it omits details like whether the original snapshot is preserved.

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 short and front-loads the primary action. It packs essential information (returns new view_id, role requirement, trusted origin detail) into two sentences. It is efficient but slightly dense; it could be a bit more structured with bullet points, but overall every sentence 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?

Given the tool's complexity (4 params, nested object, no output schema), the description covers core elements but leaves gaps: no explanation of what a VerificationCheck is, what the 'check' object should contain, or what the return format looks like beyond the new_view_id. The description explains some parameter semantics but not enough to fully use the tool without schema. The presence of sibling tools suggests the description could be more complete for an agent to select and invoke 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 coverage is only 25%, so the description must compensate, and it does: it explains that 'new_view_id' is optional and content-derived when omitted (adding meaning beyond the schema's simple 'optional' description), and it clarifies the role of 'ingest_attestation' as a requirement for trusted origin. It does not detail the structure of 'check', but the schema already uses a generic 'object' type, so the description could add value by specifying expected fields, but it doesn't.

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 action ('Append a VerificationCheck') and the resource (a snapshot), and adds the key behavior of creating a new snapshot from the latest one. It mentions the return value (new view_id), which helps distinguish it from sibling tools like ewp_evidence_view_get. However, it does not explicitly contrast with siblings such as ewp_evidence_record, so it is clear but not fully differentiated.

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 provides some usage context: it mentions the ingest role requirement and trusted origin requiring ingest_attestation, which hints at when this tool is appropriate (when caller has ingest role). It does not explicitly state when not to use it or point to alternatives, but the role requirement is a clear gate. Given the sibling set includes similar tools, more explicit when-to-use guidance would be helpful.

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 behavioral burden. It discloses that this is a write operation (append and create), states the authorization requirement (ingest role), and names the return value (new view_id). The 'snapshot from the latest one' phrasing implies non-destructive append behavior, though side effects and failure modes are not detailed.

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 one compact sentence plus two short clauses, front-loading the core action and proceeding to role and return value. Every phrase earns its place and there is no 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?

The description gives the essential behavioral, authorization, and return-value context, which is helpful given no annotations. But the nested evidence object and optional parameters remain under-documented, so an agent cannot confidently construct a complete call without inspecting the schema or external domain knowledge.

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 only 20%, and the description adds little parameter meaning beyond saying polarity is required. It does not explain proposition_id, the evidence object fields (content, observed_at, source), text, ingest_attestation, or the relationship between the optional new_view_id input and the returned new view_id.

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 ('Append an EvidenceItem') and a concrete outcome ('creates a new snapshot from the latest one' and 'Returns the new view_id'). It is clear but does not contrast itself with siblings such as ewp_evidence_view_put, so it is not fully differentiated.

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 'Append' verb plus 'creates a new snapshot' implies when to use it, and 'Requires the ingest role' gives an access prerequisite. However, there is no explicit when-to-use vs. alternatives and no mention of ewp_evidence_view_put/get or other sibling tools that might serve related view operations.

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 provided, so the description carries the burden of behavioral disclosure. It does communicate that this is a read-style operation ('Load') and clarifies snapshot selection behavior ('latest snapshot unless view_id is given'). However, it does not disclose error behavior, permissions, or whether any side effects occur.

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 sentence that is front-loaded with the core action and resource, then efficiently adds the parameter behavior. Every part earns its place with no repetition 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 simple two-parameter getter, the description is mostly complete: it identifies the resource, the required parameter, and the optional parameter's behavior. However, with no output schema and no annotation coverage, it does not describe the shape of the returned snapshot or any error/not-found behavior, leaving a notable 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%, but the description compensates by explaining both parameters: proposition_id is the basis for selecting the snapshot, and view_id optionally selects a specific snapshot instead of the latest. This gives the agent meaningful parameter semantics beyond the bare 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?

The description uses a specific verb ('Load') and a clear resource ('stored EvidenceView snapshot'), and specifies the lookup key (proposition_id) with an optional variant (view_id). This clearly distinguishes it from the sibling ewp_evidence_view_put, which is the write counterpart.

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 clear context for when to use the tool: to retrieve a stored EvidenceView snapshot, with the default behavior of getting the latest snapshot unless a specific view_id is provided. It does not explicitly name alternatives or exclusions, but the usage intent is unambiguous.

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 meaningful work: it states an auth requirement, a body-type restriction, and a conditional attestation flag. It does not disclose persistence semantics such as overwrite-versus-create behavior or failure modes, but the core behavioral constraints are present.

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-load the action and follow with the two most important constraints. There is no filler or repetition of the schema.

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 tool with two parameters, no annotations, and no output schema, the description covers auth and the key conditional, but it omits what a trusted origin is, what happens on refusal, and any success/error behavior. An agent can invoke it correctly only if it already understands EvidenceView and trusted-origin context.

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. It adds meaning to the 'view' parameter (must be an EvidenceView, not WarrantView) and clarifies that 'ingest_attestation' should be true for trusted origins, but it leaves the nested structure of the view object undocumented.

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 and resource ('Persist an EvidenceView'), making the core action unmistakable. It also distinguishes from warrant-related siblings by explicitly refusing WarrantView bodies, so an agent can tell this is for evidence views, not warrant operations.

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 provides clear invocation conditions: the caller must have the ingest role, WarrantView bodies must not be sent, and trusted origins must set ingest_attestation=true. It does not name alternative sibling tools or state when to prefer a different tool, so it stops short of fully explicit 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?

With no annotations, the description carries the full burden. It discloses case-insensitive substring matching, the return fields (ids, latest snapshot ids, assertion texts), and the notable limitation that it does not determine warrant. The 'Find' verb and 'Discovery only' strongly imply a read-only operation. It stops short of stating side effects, ordering, or pagination, but these are less critical for a search 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?

The description is two tight sentences with no filler. The main purpose and return values are front-loaded, and the caveat plus follow-up tool are given efficiently in the second sentence. Every sentence 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?

For a simple search tool with two optional parameters and no output schema, the description covers the purpose, query semantics, return fields, and boundary of responsibility, and it names the next step. It does not disclose the default limit behavior or what happens when `query` is omitted, which are minor but relevant gaps given there is no output schema.

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. It clearly explains the `query` parameter via 'by id or assertion text (case-insensitive substring)'. However, the `limit` parameter is not mentioned at all; its behavior and default value are left to inference. This is partial compensation, not 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 states a specific verb and resource: 'Find stored propositions by id or assertion text', and lists what is returned. It also distinguishes itself from sibling ewp_memory_context by explicitly saying it does not say what is warranted and pointing the agent to call ewp_memory_context next. This clearly differentiates its role among the sibling tools.

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 'Discovery only' tells the agent when this tool is appropriate, and the explicit instruction 'call ewp_memory_context next' routes to the correct alternative when warrant information is needed. This provides clear usage context and an exclusion condition without leaving it 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?

Since no annotations are provided, the description carries the full behavioral burden. It discloses that the tool requires a risk/reversible action, refuses certain view inputs, and that risk_policy is operator-only, which are useful constraints. However, it does not state whether the tool is read-only or has side effects, nor what the response format is, leaving the agent uncertain about the operation's nature.

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 three sentences and fairly compact, leading with the core purpose and then adding constraints. It is not overly verbose, but the phrasing could be tightened (e.g., 'Separate action gate' is unclear). Overall it is efficient.

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?

Given the tool's complexity (nested objects, 5 parameters, no output schema), the description is incomplete. It does not explain what the tool returns (e.g., a decision, denial reason), how to construct the action object correctly, or the relationship between proposition_id and view_id. The agent lacks enough information to invoke this tool properly without guessing.

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 low (40%), and the description partially compensates by explaining that view_id must be the latest snapshot, risk_policy is operator-only, and evaluated_at is a sanity check. However, it does not elaborate on the meaning of action, proposition_id, or the internal structure (kind, action_id), so several parameters remain under-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?

The description states the tool is a 'Separate action gate over the latest stored view at server time' and lists required inputs (risk, reversible), which gives a general sense of its function. However, the phrasing 'Separate action gate' is vague, and it does not clearly distinguish this from sibling tools like ewp_warrant_now or ewp_check_record, leaving the exact role ambiguous.

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 mentions what it refuses (inline views, caller-built WarrantViews, non-latest view_id) but provides no guidance on when to use this tool versus alternatives. It does not name any sibling tool or specify the conditions that would make this the preferred choice, so the agent is left without routing context.

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 full burden, but it only adds a default for evaluated_at and vague statuses ('OPEN and DEGRADED are explicit'). It does not disclose whether the operation is read-only, whether it has side effects, or what the caller should expect regarding errors or state changes.

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 text is compact and front-loads the core noun ('Bounded packet'), with no filler. Each sentence adds a distinct constraint or default, though the extreme terseness hurts overall clarity.

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?

The tool has no output schema and no annotations, and the description does not explain the return structure, the meaning of axes/evidence ids/warnings, or how statuses relate to the requested packet. An agent would need outside knowledge to invoke this 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 0%, so the description must explain parameters, but it only clarifies evaluated_at's server-time default. The required proposition_id and the optional query and view_id are left undefined, leaving an agent to guess how to populate the call.

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 an artifact ('Bounded packet: axes, evidence ids, warnings') and an exclusion ('Not a persona biography'), but it never states a verb or operation. An agent cannot tell whether ewp_memory_context retrieves, creates, or validates this packet, so the purpose remains vague rather than actionable.

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 use this tool or when to prefer a sibling like ewp_evidence_view_get or ewp_list_propositions. 'Not a persona biography' only says what the result is not, not which task should route here.

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 behavioral burdenency. It discloses key behavior: it returns five normative axes, does not persist a warrant, and demotes trusted origins for inline views unless the caller holds the ingest role and sets ingest_attestation. This is meaningful transparency, though it omits some details like required permissions for stored views or error behaviors.

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 three sentences, front-loaded with the core action and return value, and every sentence adds distinct information. It is compact without being vague.

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?

The tool has 7 parameters, nested objects, no annotations, and no output schema, so the description needs to carry more weight. It does not explain what the five normative axes are, which parameters apply to stored vs inline views, or the roles/requirements for policy_id, policy_version, and proposition_id. This is incomplete for an agent to reliably invoke 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?

Schema description coverage is 0%, so the description must compensate. It clarifies evaluated_at, view/view_id, and ingest_attestation, but leaves policy_id, policy_version, proposition_id, and the view object semantics unexplained. With 7 parameters and no schema descriptions, this is a significant 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?

The description states a specific verb and resource: evaluating an EvidenceView at a given time and returning five normative axes. It is not a tautology and gives a clear sense of the operation, though it does not name or explicitly distinguish sibling tools.

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 provides clear context for when to use the tool: to evaluate a stored or inline EvidenceView at evaluated_at, with the note that it does not persist the warrant. It also gives a conditional usage caveat for inline views and ingest_attestation, but it does not explicitly describe when to prefer this over sibling tools.

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