Settle what you have used. Every paid call adds 250ms to your balance and switches the meter on. tick is that purchase with no work attached. How many blocks you can buy is how much collateral is behind the channel.
| Name | Required | Description | Default |
|---|---|---|---|
| line | No | the credential from /pay, so this payment is applied to your line |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does disclose real effects: each paid call adds 250ms and switches the meter on, and credit is limited by channel collateral. However, mechanics such as authentication, failure modes, or what the response contains are absent.
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-loaded with 'Settle what you have used,' but the final sentence about collateral behind the channel is cryptic and may not help an agent select or invoke the tool. Every sentence does not clearly earn 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 single-parameter utility with no output schema, the description covers the action's effect and source of the parameter, but leaves context vague (what a line/meter is, when this settles vs how_to_pay). It is minimally adequate rather than fully self-contained.
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 schema alone documents `line` as a credential from `/pay`. The tool description adds no additional parameter meaning beyond an indirect reference to paying, so the 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 states that `tick` settles used compute and is a purchase with no work attached, adding 250ms to a balance. This goes beyond the name by clarifying it is a payment/meter operation, though it does not explicitly contrast with sibling tools like how_to_pay.
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 guidance on when to call `tick` versus alternatives, nor any prerequisites beyond mentioning a `line` credential from `/pay`. Sibling tools like how_to_pay or audit tools are not referenced, so an agent must infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add one secure layer between your agents and this server.
The audit_* tools are carefully differentiated: cluster groups wallets, funders traces inbound transfers for one wallet, payers decodes channel openers. The notes_* tools also have clear lifecycle separation, and sample vs rpc is distinguished by free vs paid access. Minor overlap exists between sample and rpc since both expose RPC methods, but the descriptions make the boundary clear.
There are consistent internal prefixes like audit_* and notes_*, but the overall surface mixes verb_noun (audit_cluster, audit_funders), noun_verb (notes_post, notes_read), and single bare words (rpc, sample, tick, how_to_pay). The names are readable and groupable, but they do not follow one predictable convention across the whole server.
Ten tools is well within the ideal scope for a server with distinct functional areas: on-chain auditing, notes, RPC access, and payment/settlement. Each tool has a clear job, and none feel redundant or superfluous.
The core workflows are well covered: cluster auditing, funder/payer investigation, notes post/read/sign, RPC access, and payment instructions/settlement. A minor gap is the lack of a dedicated usage or credit read tool, though tick and how_to_pay partially cover the payment lifecycle.