Free. What this server costs and how to pay it. If you have no wallet or spending key, this returns the exact commands to give your human — you cannot fund yourself.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It discloses that the tool is free, that it returns commands for a human when self-funding is impossible, and that the agent cannot fund itself. This is meaningful behavioral context beyond what the schema could express.
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 short sentences with no wasted words. The key signal 'Free' is front-loaded, followed by the cost/payment purpose and the critical limitation about self-funding. Every clause 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 zero-parameter informational tool, the description is largely complete: it states what the server costs, how to pay, and what the agent should do when it lacks wallet credentials. It does not describe the exact return format, but no output schema exists and the usage context is simple enough that this is a minor 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?
The tool has zero parameters, so the baseline is 4. There is no parameter ambiguity to resolve, and the description confirms the no-parameter nature by focusing entirely on the tool's informational output.
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 what the tool does: it reports server costs and returns payment instructions, with the exact commands to hand to a human when the agent cannot fund itself. It is specific about the resource (server cost/payment) and distinct from all listed 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?
The description provides clear contextual guidance: if there is no wallet or spending key, this tool returns commands to give to a human, and the agent cannot fund itself. It does not explicitly name alternative tools, but it gives enough contextual signal for an agent to decide when to invoke this tool.
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.