Live USDC rates on Base, any address's Obento position, and deposits and withdrawals to sign.
Scored across 6 tools
Each tool targets a distinct purpose: autopilot_journal for history, position for user-specific holdings, vault_status for global state, prepare_deposit/withdrawal for transactions, and read_docs for documentation. The two prepare functions are clearly differentiated by their deposit vs withdrawal actions. Minor overlap exists between position and vault_status regarding deposit/withdrawal information, but descriptions clarify the user-specific vs system-wide scope.
Five tools use snake_case with clear noun or verb_noun patterns (autopilot_journal, position, prepare_deposit, prepare_withdrawal, read_docs, vault_status). The lone exception is 'position', which is a noun while others are verb_noun or adjective_noun. This is a minor deviation in an otherwise consistent naming scheme.
Six tools is a well-scoped set for a DeFi vault management server. Each tool covers a distinct core operation: state inspection, user position, transaction preparation, history, and documentation. No tool appears redundant or unnecessary.
The surface provides complete lifecycle coverage for a deposit/withdrawal system: users can check vault status, prepare both deposit and withdrawal transactions, view their position, review Autopilot's actions, and access documentation. All necessary operations for interacting with the protocol are present.
Every move Autopilot made in the last 30 days: money lent to or taken from each place, queued withdrawals it paid, and any pause, newest first.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=false, destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: the 30-day retention window, the newest-first ordering, and the specific categories of entries returned.
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 that names the resource first, then the window, then the contents, closing with ordering. Every clause carries information; no filler or repetition of the title.
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?
With no parameters, no output schema, and annotations covering safety, the description is nearly self-sufficient for invoking the tool. The only gap is the absence of any note on volume, pagination, or what an empty journal means.
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 to misinterpret and the baseline is 4. No parameter-level detail is needed or missing.
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 concrete resource (Autopilot's activity journal) and enumerates its contents: lending/taking actions, paid queued withdrawals, and pauses. An agent can distinguish it from siblings like position (current state) or vault_status (status vs. history), though the description never names those siblings 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 implied by the content description (an audit trail of past Autopilot actions) rather than stated. There is no explicit guidance on when to prefer this over position or vault_status, nor any mention of the 30-day window being a hard limit or whether older history is available elsewhere.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
What an address put into Obento, took out, holds now and earned, Autopilot's fee in dollars, and its latest deposits and withdrawals with their status.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | A Base address, 0x followed by 40 hex characters |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=false, destructiveHint=false, so the safety profile is covered. The description adds only that it returns historical and current holdings, but says nothing about pagination, ordering, freshness, or auth requirements beyond what the annotations imply.
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 single run-on sentence mixes multiple concepts (holdings, fees, deposits, withdrawals) without front-loading the core action. It is under-specified rather than concise, and the fragmentary phrasing ('What an address put into Obento, took out, holds now and earned') is hard to parse.
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?
With one 100%-covered parameter and read-only annotations, the description should at least state the core purpose clearly. It leaves out what the return looks like, how current vs. historical data is structured, and any relationship to sibling tools, making it inadequate for reliable selection.
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% and the address parameter is fully described in the schema. The description does not add syntax or format details, but with complete schema coverage the baseline is 3.
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 names the resource ('an address') and enumerates several data categories (deposits, withdrawals, Autopilot fee, earnings), implying a status/position query. However, it never states a clear verb like 'retrieve' or 'get'; 'What an address ... holds now' is indirect and the tool could be confused with vault_status or autopilot_journal among siblings. Purpose is vaguely discernible but not crisp.
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 indication of when to use this tool versus autopilot_journal, vault_status, or the prepare_* tools. No context or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deposits are closed while Obento is paused, so this returns an error. Builds the two calls that deposit USDC into Obento for an address: approve the gateway, then deposit with a 0.5% minimum out and partner ID 2. The address signs and sends them in order on Base. Sends nothing itself.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | Yes | USDC to deposit, in dollars, such as "100" or "25.50" | |
| address | Yes | The address that holds the USDC and receives the obUSD |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover safety (readOnlyHint=true, destructiveHint=false) and the description is consistent with them ('sends nothing itself'). Beyond that, it discloses real behavioral detail: the exact two-step sequence (approve gateway, then deposit), the hardcoded 0.5% minimum out, partner ID 2, the Base chain, and that the address must sign and send in order.
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?
Four sentences, each carrying unique information (availability caveat, construction, parameters/chain, non-sending guarantee), with no filler. The leading error caveat is front-loaded but slightly delays the core purpose statement.
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?
With no output schema, the description should ideally sketch the return payload (two unsigned transactions); it implies this via 'builds the two calls' but never states the response shape or any expiry/deadline. Otherwise it gives everything needed for a preparation tool: inputs, chain, sequence, and hardcoded values.
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 'address' and 'amount' are already documented in the schema. The description only alludes to 'an address' and 'deposit USDC' without adding format, units, or constraint detail, 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 a specific action on a specific resource: it builds the two calls that deposit USDC into Obento for an address, and explicitly notes it 'sends nothing itself.' That contrast with prepare_withdrawal is clear enough for an agent to pick the right sibling without opening a 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 opening line gives an explicit when-not-to-use condition ('Deposits are closed while Obento is paused, so this returns an error'), which is genuinely actionable. It does not name an alternative tool or describe a route to take while paused, so it falls short of the 5-level routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Withdrawals are closed while Obento is paused, so this returns an error. Builds the two calls that withdraw from Obento: approve the gateway to take the obUSD, then redeem with a 0.5% minimum out and partner ID 2. Leave out the amount to withdraw everything. Says whether the USDC arrives at once or on Autopilot's next pass. Sends nothing itself.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | USDC to withdraw, in dollars; leave out to withdraw everything | |
| address | Yes | The address that holds the obUSD | |
| receiver | No | Where the USDC goes; the address itself if left out |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnly/non-destructive/closed-world, and the description adds substantial context beyond them: the paused-state failure mode, that it constructs exactly two calls (approve then redeem) with a 0.5% minimum out and partner ID 2, and that it 'sends nothing itself.' The lack of side effects is confirmed and even explained.
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?
Five short sentences, each carrying distinct information: failure condition, construction steps, default behavior, output nature, and side-effect disclaimer. The important caveat is front-loaded rather than buried.
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?
With no output schema, the description does cover the side-effect profile ('Sends nothing itself') and the nature of the returned information (whether USDC arrives at once or on Autopilot's next pass). It could still clarify the shape/contents of the two calls it returns, which 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?
Schema description coverage is 100%, so the schema already documents amount, address, and receiver. The description's only parameter note ('Leave out the amount to withdraw everything') simply restates the amount schema description, adding no new syntax or format detail.
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 names a specific action ('Builds the two calls that withdraw from Obento') and the exact resources involved (obUSD approval, gateway redeem to USDC). It is clearly distinguishable from the sibling prepare_deposit and the read-only siblings like position or vault_status.
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 states a concrete condition under which the tool is unusable ('Withdrawals are closed while Obento is paused, so this returns an error') and a default behavior ('Leave out the amount to withdraw everything'). It gives clear context but never names an alternative path or what to do instead when paused.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One page of Obento's docs as Markdown: how it works, fees, risks, security, contracts, withdrawals, the agent guide and more.
| Name | Required | Description | Default |
|---|---|---|---|
| page | Yes | The page, such as "risks", "fees" or "agents" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered by structured data. The description adds that the result is a single page rendered as Markdown, which is useful since no output schema exists, but it says nothing about freshness, auth requirements, or pagination (none needed for a single page).
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 naming the resource, the return format, and the content scope. No filler, no repetition of the tool name.
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 one-parameter read tool with annotations covering safety and a complete enum in the schema, the description is sufficient: it clarifies the returned format and content. It could go slightly further by noting the page list is enumerated in the parameter, but nothing an agent needs to call it correctly is missing.
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% and the single 'page' parameter carries a full 14-value enum with its own description, so the schema does the heavy lifting. The description echoes three enum values (risks, fees, agents) without adding syntax or selection guidance 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?
States a specific resource (one page of Obento's docs) and a specific output format (Markdown), and enumerates the covered topics, so the agent knows exactly what it gets back. No sibling differentiation is stated, but the siblings are unrelated action tools, so confusion risk 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?
Usage is only implied: an agent can infer it should call this to look up how Obento works, fees, risks, security, or the agent guide. There is no explicit when-to-use condition, no statement of when it is unnecessary, and no alternative named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Obento's live state: whether deposits and withdrawals are open, the yearly rate after the fee, the obUSD share price, deposits, ready cash for instant withdrawals, and where the money is.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. With no output schema, the description carries the burden of disclosing returned content, and it does list the reported values (open flags, post-fee rate, share price, deposits, ready cash, fund location) — useful, though it does not specify units, formatting, or freshness/latency of the 'live' data.
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 sentence with the key noun phrase 'Obento's live state' front-loaded and the rest of the sentence spent enumerating the returned fields. It is a long colon-list, but every item earns its place by naming data the agent cannot otherwise discover.
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, annotation-covered read tool with no output schema, the description supplies the one thing missing from structured data: what state gets returned. Only minor gaps remain (units, snapshot timing, and how it relates to the 'position' sibling).
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 and no schema semantics to supplement. Baseline of 4 applies for a no-argument tool.
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 resource ('Obento's live state') and enumerates the concrete fields it reports: deposit/withdrawal open flags, fee-adjusted yearly rate, obUSD share price, deposits, ready cash, and fund location. It is clearly a protocol-level status read, though it never explicitly distinguishes itself from the sibling 'position' tool, which an agent could easily confuse with 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 when-to-use guidance, no prerequisites, and no mention of alternatives such as 'position' (user-level holdings) or 'read_docs'. An agent must infer on its own that this is the pre-deposit/pre-withdrawal health check.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
autopilot_journalpositionprepare_depositprepare_withdrawalread_docsvault_statusBase token facts and ERC-20 allowance checks. Per-call USDC on Base; x402 wallet required.
DeFi pool yield+security intelligence & token/contract risk scanner. USDC on Base via x402.
Live Base Mainnet on-chain data (gas, DEX, Aave, token risk, prices). Pay per call in USDC via x402.
Live Base Mainnet on-chain data (gas, DEX, Aave, token risk, prices). Pay per call in USDC via x402.
Add one secure layer between your agents and this server.
