Boundra — Payment Approval Gateway for AI Agents

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

With no annotations, the description carries the burden and does disclose the decision protocol, the challenge/retry flow, and the mandate's authorization semantics. It omits other behavioral traits such as side effects, idempotency, and whether evaluation itself is read-only, which is a real gap for a no-annotation 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?

Front-loads the mandatory call ordering, then maps each outcome to an action in compact clauses. Every sentence carries operational meaning with 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?

The decision and retry protocol is complete, and the output schema relieves the description of explaining return values. However, for a 9-parameter tool with no annotations and 0% schema coverage, the near-total absence of parameter guidance leaves the agent under-informed on inputs.

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 9 parameters, so the description must compensate and largely does not: it explains only mandate ('user-issued single-task authorization') and implies approval_token. It never distinguishes amount from expected_amount, nor clarifies owner, agent_id, source_content, or purpose.

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 ('Evaluate a payment intent') and then defines the tool's decision vocabulary (ALLOW/DENY/ASK). No sibling in the list performs payment evaluation, so the agent can immediately place this tool relative to the policy/audit 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?

Gives a hard precondition ('MUST be called before executing any payment') and branch-specific next actions for each decision outcome, including the approval_token retry path. It does not name a when-not case or an alternative tool, but no sibling overlaps functionally.

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 behavioral burden. It implies a read-only, recency-ordered listing, but says nothing about permissions/auth requirements, pagination or truncation behavior, ordering guarantees, or what happens when the limit is exceeded. For a zero-annotation tool this is a substantial 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?

A single, front-loaded sentence with the resource and scope stated immediately and no filler. It is efficient, though extremely terse given the missing usage and parameter 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?

An output schema exists, so return-value explanation is not required. However, for a two-parameter tool with no annotations and no parameter descriptions, the description omits usage context and limit semantics, leaving an agent with only the minimum needed to attempt a call.

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 'owner' as the owner whose audit records are retrieved, but leaves 'limit' completely unexplained (no maximum, no effect on ordering or truncation), so half the parameters remain undocumented in both schema and text.

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 ('View'), a specific resource ('payment-approval audit records'), and a scope ('for an owner'), which differentiates it from sibling report tools like get_spend_report. It lacks an explicit 'not X' contrast with siblings, but the resource noun is distinctive enough for an agent to pick 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?

There is no guidance on when to use this tool versus alternatives such as get_spend_report or list_policy_requests, and no mention of prerequisites or when not to use it. 'Recent' implies a recency window but never defines it or says how to broaden the query.

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 reveals only that the returned policy is 'active' and 'signed' (i.e., not a draft or older version); it says nothing about permission requirements, whether the agent scope falls back to a default, or behavior when no policy exists.

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 the core resource stated first and the optional scope relegated to a parenthetical. Nothing is wasted, though it is terse to the point of under-specification.

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?

An output schema exists, so return values need not be described, and this is a simple two-param read tool whose both params are at least named. The remaining gap is the absence of any annotation substitute for behavior and access requirements.

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 map both params conceptually: 'owner' as the required subject and 'agent scope' as the optional agent_id. It adds no format, identifier, or default-value detail beyond that, leaving meaningful gaps at 0% coverage.

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 (View) and a precise resource ('active signed payment policy'), and the '(and optionally an agent scope)' clause narrows what is fetched. An agent can largely distinguish it from get_policy_versions (history) and set_policy (write), though no sibling is named 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: 'active signed' suggests this is the current-policy read as opposed to get_policy_versions or the write tools. There is no explicit when-to-use/when-not statement or named alternative, so an agent must infer the 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 behavioral burden. 'View' signals a read-only operation, and it usefully discloses the return content (version chain + hashes, on-chain verifiability), but it omits permissions/auth requirements, pagination behavior, and what happens if the owner has no policy versions.

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 the core purpose first and the useful parenthetical detail after. No filler or 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?

An output schema exists, so return values need not be explained, and the tool is a simple single-parameter read. However, the owner parameter format and any behavioral constraints are unaddressed, leaving modest gaps for an agent to infer.

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% and the single 'owner' parameter is completely undocumented in the schema. The description implies owner is a user identity but gives no format or type expectations (address, DID, user id), so it only partially compensates for the coverage 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 uses a specific verb+resource pair ('View a user's policy version history'), which clearly separates it from siblings like get_policy (current state) and list_policy_requests (pending requests). It does not name a sibling explicitly, but the resource scope is distinctive enough for an agent to route correctly.

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 versus get_policy or get_audit_trail, and no prerequisites or exclusions. The parenthetical about on-chain verifiability hints at a use case but does not constitute actual 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?

With no annotations, the description carries the full burden of behavioral disclosure. "View" implies a read-only operation, but there is nothing about authentication/authorization, whether the caller must own the data or have admin rights, timezone/data-freshness of "today", or rate limits.

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 the scope front-loaded and no wasted words. It is efficient, though the brevity borders on under-specification rather than true 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?

An output schema exists so return values need not be explained. However, with zero annotations and a 0%-documented required parameter, the description leaves the owner identifier format and the meaning of "today" unresolved, which are gaps an agent needs filled 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 description must compensate for the single undocumented "owner" parameter. "for an owner" only restates that the parameter identifies whose spend is reported; it gives no format (ID, email, username) or constraints, which is the key ambiguity for a required param.

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 ("View ... spend summary") and scopes it temporally ("today's") and by entity ("for an owner"). It does not differentiate from any sibling, though none of the listed siblings (policy/template/audit tools) overlap with spend reporting, so the risk of confusion is low.

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 when-to-use guidance, no prerequisites, and names no alternatives. "today's" implies a time window but the description never says what to do for other periods or which sibling handles them.

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 full behavioral burden. It implies a read of queued items, but says nothing about auth requirements, pagination, ordering, or whether the list is user- or workspace-scoped.

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 phrase with no filler. Nothing could be trimmed without losing meaning.

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?

An output schema exists, so return values need not be described, and with no parameters the structural surface is small. Still, for a listing tool an agent gets no sense of scope, volume, or filtering behavior.

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 nothing for the description to disambiguate; baseline 4 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?

States a specific verb (List) and resource (agent policy-change requests), scoped to 'pending'. An agent can distinguish this from request_policy_change or get_policy without opening a schema, 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?

No indication of when to reach for this over get_policy, get_policy_versions, or the audit trail, and no prerequisites or exclusions. Usage is left entirely to inference from the name.

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 full behavioral burden. 'List' weakly implies a read-only operation, but there is no statement about permissions, filtering, pagination, or result size — all relevant for a policy-listing 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?

A single front-loaded sentence with no filler; the category enumeration is compact and earns its place by clarifying what 'templates' covers.

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?

An output schema exists, so return values need no explanation, and there are no parameters to document. What remains missing is usage context relative to render_template and get_policy, but for a parameterless listing tool this is close to sufficient.

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 the baseline of 4 applies. The parenthetical categories describe the returned data rather than any parameter, adding mild scope information.

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?

Specific verb+resource ('List policy templates') with an enumeration of the template categories that scopes the result set. It is distinguishable from siblings like get_policy and list_policy_requests, though the description never explicitly contrasts 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?

No when-to-use guidance, no prerequisites, and no mention of the sibling relationship with render_template, which is the natural downstream call. The agent must infer that this is the discovery step before rendering.

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, so the description carries the full burden. It usefully discloses that this is not a pure computation: the rule is also compiled, signed and published, which signals a mutating side effect. However, it omits auth/permission requirements, idempotency, and what happens on compile/sign failure.

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 compact sentence with the action front-loaded and no filler. But for a 5-parameter tool with publication side effects, one terse sentence is arguably under-specified rather than appropriately sized.

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?

An output schema exists, so return-value explanation is not required. Yet for a tool that publishes a signed policy rule with 5 undocumented parameters, the description omits parameter meaning, prerequisites, and failure behavior, leaving it incomplete for safe 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?

Schema description coverage is 0% across 5 parameters (daily, per_tx, ask_above, whitelist, template_id), and the description only says 'template + parameters' generically. The meaning of each numeric limit field and the whitelist is left entirely to inference, so the description does not compensate for the coverage 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?

Names a specific verb (render) and resource (a natural-language rule from a template + parameters), and the parenthetical adds the downstream pipeline. It is clear what the tool produces, though it does not explicitly distinguish itself from siblings like set_policy or list_templates.

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 explicit when-to-use or when-not-to-use guidance. The agent gets an implied flow (template + params → published rule) but no condition that selects this tool over set_policy or request_policy_change.

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 burden and does well: it discloses the request is queued for user approval, that the user signs and publishes a new policy version, and that direct agent mutation is impossible. It omits failure handling, duplicate-request behavior, and whether the queued request is pollable.

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, no waste, with the agent-directed affordance and the approval workflow front-loaded. Every sentence adds a distinct fact.

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?

An output schema exists so return values need not be explained, and the human-approval flow is well covered. But for a 3-required-param tool with 0% schema coverage and no annotations, the description leaves parameter content under-specified, which an agent needs to compose a valid call.

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% for all three required params, so the description must compensate. It only illustrates the format of 'request' via the example; 'agent_id' and 'reason' receive no explanation of expected content or format, leaving two-thirds of the parameters 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?

States a specific verb+resource ('Ask the user for a policy/budget change') and gives a concrete example ('raise daily budget from 50 to 80'). It explicitly distinguishes itself from the direct-mutation sibling set_policy by declaring 'Agents can NEVER change policy directly.'

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 line 'Agents can NEVER change policy directly' effectively tells the agent this is the only sanctioned path for policy/budget changes, implicitly excluding set_policy. However, no sibling is named outright and no explicit when-not conditions or fallback alternatives 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?

With no annotations, the description carries the full behavioral burden and discloses several important traits: immediate effect, subsequent payments defaulting to DENY, user-only operation, and a required wallet signature over the revocation statement. It does not state whether revocation is reversible, whether in-flight payments are affected, or what error modes exist, but the key destructive consequence and auth condition 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?

The description is short, front-loaded, and every clause adds useful information: user-only restriction, immediate effect, default-deny consequence, and signature requirement. There is no filler or repetition.

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 six-parameter mutation tool with no annotations and 0% schema description coverage, the description is under-specified. It covers the revocation effect and signature requirement, but does not explain most parameter meanings or the permission model beyond '[USER ONLY]'. The output schema exists, so return values need not be described, but the calling contract remains 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 0%, so the description must compensate for six undocumented parameters. It only adds meaning for 'signature' by saying it must be the user's wallet signature over the revocation statement. The required 'owner', 'scope', 'revoked_through', 'created_at', and optional 'agent_id' parameters remain unexplained.

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: revoke a policy chain. It also distinguishes the action from sibling policy tools by naming revocation rather than setting, getting, or requesting a policy change. An agent can tell what this tool does without opening the schema.

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 implies usage through '[USER ONLY]' and the immediate-effect warning, but it does not explicitly say when to use this tool instead of alternatives such as request_policy_change or set_policy. It gives context but no exclusions or sibling routing. This is minimally adequate 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 provided, so the description carries the full burden and does disclose meaningful traits: the required EIP-191 wallet signature, the version-chain validation, and that submission is rejected unless both checks pass. It does not say what happens on failure or how versions are chained via prev_hash.

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, each load-bearing: caller restriction first, then the signature requirement, then the acceptance condition. Zero 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?

An output schema exists, so return values need not be described, and the caller restriction plus validation gate are covered. But for an 8-parameter mutation tool with 0% schema documentation, leaving most parameters and the failure behavior unexplained is a real 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% across 8 parameters, so the description must compensate and largely does not: owner, scope, nl_rule, created_at, and agent_id are never explained. It only ties signature to EIP-191 and hints at prev_hash through 'version-chain checks'.

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 ('Submit a new policy version') and scopes the caller as '[USER ONLY]'. It doesn't explicitly contrast with the sibling request_policy_change, so an agent must infer which of the two paths applies to 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?

'Agents MUST NOT call this tool' is an unusually explicit and useful exclusion, and the precondition (signature + version-chain checks must pass) gives clear when-to-use context. The agent-facing alternative for proposing policy changes is not named, so the routing guidance is incomplete.

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