ASPERN: counterparty checks for agents MCP server
org.aspern/aspernaspern.orgstreamable-httpv1.3.0Scanned
What the chain records about an address before you pay it, and whether a payment fits it.
59 tools: 1 can delete or cancel things, 9 do something that can't be undone, 38 change things and 11 only read.
- Reads private data · 4
- Reads text others write · 57
- Can send data out · 5
- 10 findings
Tools listed without sign-in. Remote posture
With Anlyon
1 tool here can delete or cancel things and 9 do something that can't be undone. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the ASPERN: counterparty checks for agents MCP server can do
The ASPERN: counterparty checks for agents MCP server is published by aspern.org, a domain the MCP Registry verified. It has 59 tools. It can delete or cancel things (1 tool: monitor_subject), do things that cannot be undone, such as sending, paying or publishing (preflight_payment, vault_exits, payment_evidence, simulate_withdrawal and 5 more) and create or change data (38 tools: identify, check_service_endpoint, vault_assessment, vault_risk_dimensions and 34 more). 11 tools only read.
4 tools read private data (portfolio_screen, find_vaults, list_vaults and 1 more); 57 tools bring in text other people can write (identify, check_service_endpoint, preflight_payment and 54 more); 5 tools can send data out of your system (check_service_endpoint, preflight_payment, vault_exits and 2 more). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.
The fixed checks matched 10 findings (annotation-conflict, credentials-mention and long-description). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed 3 times since Anlyon Radar first saw them.
Last scanned Nov 18, 2026, version 1.3.0.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
59 tools
Deletes or cancels 1Claude Code: deny
monitor_subjectAsk to be told when the answer about an address CHANGES.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it destructive (destructiveHint: true).
Description, as the server wrote it Ask to be told when the answer about an address CHANGES. The dimensions are the ones the counterparty check already answers, so this is that same reading on a schedule rather than a second opinion; what it adds is the comparison. The first run records a reading and reports nothing — there is nothing yet to compare against, and a first reading dressed up as news is the thing this avoids. Idempotent per subject: calling it again edits the watch rather than creating a second. An unknown dimension or policy is REFUSED rather than dropped, because a watch that quietly ignores half of what you asked for is worse than no watch. Needs a key. WHY readOnlyHint IS false: this call writes a row in our store on behalf of the caller, so a second identical call is not free of consequence.
Annotations the server declares
- destructiveHint: true
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: false
- title: Be told when the answer about an address changes
Can't be undone 9Claude Code: ask
check_actionCALL THIS BEFORE YOUR AGENT SIGNS ANYTHING THAT MOVES MONEY.Reads text others writeCan send data outNo findings
Why it is in this group
- The description's first verb is "call": a word for a change.
- The input addresses people (input.recipient): what it sends cannot be taken back.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a destination (input.recipient): what the tool writes goes there.
Description, as the server wrote it CALL THIS BEFORE YOUR AGENT SIGNS ANYTHING THAT MOVES MONEY. One request instead of five: it reads the counterparty record, decodes the calldata you are about to sign, looks up the seller’s own catalogue listing, runs an unpaid 402 handshake with the endpoint, and applies a published policy — and then, which is the point, compares them WITH EACH OTHER. The losses an agent actually suffers live between those readings and no single one of them can see them: the bytes paying an address you never checked, so a spotless counterparty record is about a party this transaction does not pay; an UNLIMITED APPROVAL wearing the shape of a one-cent payment; the seller’s listing naming a payee the calldata does not; a policy allowing a payment for a path that is not served. Every cross-check names BOTH readings that disagree in `between`, and none of them is an accusation — the record can be wrong. Send `calldata` whenever you have it: it unlocks the strongest check there is. A cross-check can only make the verdict worse, never better. SEND `calldata`, `chain` AND `from` and it is also SIMULATED: one `eth_call` at the latest block, the node executes it and throws the result away, nothing is signed or spent. A revert is the strongest finding available, because every other reading argues about whether you should send it and this one is that it will not work. Not a state diff, run against the current block, and a node that refuses is reported as our gap rather than as a failure. `ran` says which parts did not run and why, because a check that did not happen must never look like one that passed. PAID; its five components are each free on their own tools and what is sold here is the comparison.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: One check before you sign (paid)
inspect_paymentCall this with the CALLDATA you are about to sign, before you sign it.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "inspect_payment" says "inspect": a word for reading.
- The description's first verb is "call": a word for a change.
- The input addresses people (input.to): what it sends cannot be taken back.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a destination (input.to): what the tool writes goes there.
Description, as the server wrote it Call this with the CALLDATA you are about to sign, before you sign it. Every other check here asks whether an address is worth dealing with; this asks whether the transaction is the one you think it is, and the two catch different losses. No amount of reputation makes the recipient in the bytes match the recipient on your screen, and a spotless counterparty record says nothing about an UNLIMITED APPROVAL granted to it, which is not a payment at all but a standing permission that outlives the transaction. It reads three calls — transferWithAuthorization, approve, transfer — and REFUSES to guess at any other: decoding unknown calldata without the ABI means guessing where each argument begins, and a confident wrong answer about where money goes is worse than none. Amounts are atomic units, never dollars, because the token owns its decimals. Free, needs no key, stores nothing.
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
- readOnlyHint: false
- title: Read the transaction you are about to sign
payment_evidenceBEFORE YOU QUOTE ANY FIGURE FOR AGENT COMMERCE, ask which of three it is.Reads text others write1 finding
Why it is in this group
- The name "payment_evidence" says "payment": a word that usually means money moves, which cannot be taken back.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "payment_evidence" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "payment_evidence" says "payment": a word that usually means money moves, which cannot be taken back.
Description, as the server wrote it BEFORE YOU QUOTE ANY FIGURE FOR AGENT COMMERCE, ask which of three it is. Every payment shown to be one, x402 and ACP, is split into three figures that NEST and are never added up (x402 counts only the `protocol`, `route` and `facilitator` tiers below; the authorised transfers with nothing to show they were x402 are in `notShownToBeX402`, never in the figures): `settled` (paid on-chain), of that `serviceLinked` (paid to a payee that lists a paid service, or an ACP job), of that `deliveryEvidenced` (a recorded outcome: an ACP job completed). x402 records the payment and never the delivery, so its payments are counted in `deliveryUnevidenceable`: $0 delivered there is what the rail allows, not a failure of the seller. Beside it, `tiers` splits x402 payments by what can be shown about the payment itself: to a listed route, through a facilitator, or only an authorised transfer. Free, because it is an aggregate; the same split for one address is on agent_business.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Settled, linked and delivered, across the rails
preflight_paymentCall this immediately before sending a payment, every time — not once per counterparty.Reads text others writeCan send data out1 finding
Why it is in this group
- The name "preflight_payment" says "payment": a word that usually means money moves, which cannot be taken back.
- The input addresses people (input.to): what it sends cannot be taken back.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a destination (input.to): what the tool writes goes there.
Findings
- Warn
The server marks "preflight_payment" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "preflight_payment" says "payment": a word that usually means money moves, which cannot be taken back.
Description, as the server wrote it Call this immediately before sending a payment, every time — not once per counterparty. It weighs THIS payment (the amount, the chain, the endpoint) against what the address has actually done: the price the seller themselves published for that endpoint, the address that endpoint names as its payee, the largest payment this address has ever received, and whether it has ever been paid on the chain you are about to use. Answers one of three verdicts. `nothing-against-it` means every check ran and none objected — it is NOT a statement that the payment is safe, because nothing here can see what the payment is for or what you agreed. `look-first` means at least one thing we could READ does not match, and the findings say which; a check that could not run never produces it, it produces `cannot-say`. `cannot-say` means we did not read enough to have an opinion, and must never be read as the first. Free. Give as much of amountUsd, chain and resource as you have: each one left out is a check that did not run, and the answer says so rather than passing. THE ENDPOINT’S OWN WORD OUTRANKS THE CATALOGUE: where we have probed it, branch on `againstEndpoint.price.againstQuote`, and **`below-quote` is not a pass**. Each named finding (`live-price-differs-from-listing`, `quoted-payee-is-not-the-one-being-paid`, `below-listed-price`, `network-not-comparable` and the rest) is explained under `findings`.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Weigh one payment before sending it
simulate_withdrawalTRY ONE WITHDRAWAL FROM A VAULT BEFORE YOU MAKE IT.Reads text others writeNo findings
Why it is in this group
- The name "simulate_withdrawal" says "withdrawal": a word that usually means money moves, which cannot be taken back.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it TRY ONE WITHDRAWAL FROM A VAULT BEFORE YOU MAKE IT. Runs the vault’s own withdraw(amount, holder, holder) by eth_call at the head block, as the holder you name or, if you name none, as its largest depositor: the contract executes and nothing is signed, sent or spent. Says whether it would have gone through, the revert reason where it would not (e.g. NotEnoughLiquidity, TransferReverted past a V2 vault’s idle balance), the block, and what the holder’s position was worth; a size over what the holder owns is tried at their position and said so. It does NOT show a later block, or what happens once somebody else takes the same free money. Morpho vaults for now; anything else answers `simulated: false` and is not charged. FREE up to $1,000; over it PAID, $2 a simulation over x402, or free with a decision pass from this vault’s due-diligence report.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Try a withdrawal before making it (free up to $1,000)
stablecoin_paymentsAgent payments in stablecoins over a window you choose (default the last 24 hours): how many x402 payments, from how many paying addresses to how many receiving ones, by token and …Reads text others write1 finding
Why it is in this group
- The name "stablecoin_payments" says "payment": a word that usually means money moves, which cannot be taken back.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "stablecoin_payments" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "stablecoin_payments" says "payment": a word that usually means money moves, which cannot be taken back.
Description, as the server wrote it Agent payments in stablecoins over a window you choose (default the last 24 hours): how many x402 payments, from how many paying addresses to how many receiving ones, by token and network. Filter by stablecoin (USDC) or network. Free. Counts only payments shown to be x402.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Agent stablecoin payments, over a window
stock_agent_transfersEvery transfer of a tokenized stock that touched an agent address over a window: the agent and its roles, the token, in or out, the amount and its value, the time and the transacti…Reads text others writeNo findings
Why it is in this group
- The name "stock_agent_transfers" says "transfer": a word for a change that another call does not undo.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Every transfer of a tokenized stock that touched an agent address over a window: the agent and its roles, the token, in or out, the amount and its value, the time and the transaction, newest first (up to 5,000). PAID per call, $0.10 over x402 (USDC on Base) or with a plan; the counts are free in stock_agent_activity.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Agent transfers of tokenized stocks (paid)
test_purchaseWALK THE WHOLE PURCHASE OF AN x402 ENDPOINT WITHOUT PAYING, in the order a buyer actually asks the questions, stopping at the first one that objects.Reads text others writeNo findings
Why it is in this group
- The name "test_purchase" says "purchase": a word that usually means money moves, which cannot be taken back.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it WALK THE WHOLE PURCHASE OF AN x402 ENDPOINT WITHOUT PAYING, in the order a buyer actually asks the questions, stopping at the first one that objects. All five are asked in one pass and in that order, so the walk stops where a buyer would stop. Five steps: is the endpoint there, what does it charge RIGHT NOW, does the seller’s own catalogue entry agree with what it just said, does the record say anything against paying that payee under a published policy, and — the step that only exists because this is a rehearsal — is the price still the one the decision was made on, re-read a moment later. A quote that moved between the decision and the signature would authorise something nobody decided on. THE VERDICT HAS THREE STATES AND cannot-tell IS NOT would-proceed: an unanswered question is never rounded up to a passed one. `quotedRaw` is what the endpoint said, in the asset’s smallest unit, and `quotedUsd` is NULL unless the catalogue carries both halves of the same token’s pair to scale it — nothing in a payment-requirements document names the decimals, and a figure scaled by a guessed exponent is a hundred-fold error waiting to be quoted. We knock only on endpoints already in the x402 catalogue we read, at most one live handshake a minute per resource, because we knock only on what the catalogue already lists: a URL named in a request is not by itself a reason to send traffic to somebody else’s host. Nothing is signed and nothing is spent. FREE.
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
- readOnlyHint: false
- title: Test purchase, without paying
vault_exitsSEND `exitAmountUsd` WITH THE POSITION YOU ARE WEIGHING and this answers whether that size has ever cleared here: the schema has carried it since 2026-10-08, and an auditor still h…Reads text others writeCan send data out2 findings
Why it is in this group
- The description's first verb is "send": a word for sending, and what is sent cannot be taken back.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe description's first verb is "send": it sends or publishes something to other people.
Findings
- Info
The description is 2,006 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...k from. For a capital decision the age of the record is part of the record. Free."
- Warn
The server marks "vault_exits" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "send": a word for sending, and what is sent cannot be taken back.
Description, as the server wrote it SEND `exitAmountUsd` WITH THE POSITION YOU ARE WEIGHING and this answers whether that size has ever cleared here: the schema has carried it since 2026-10-08, and an auditor still had to find it by guessing because this sentence did not say so. Without it the answer still describes the capacity; with it, `exitCapacity` says `covered-now`, `above-declared` or `unknown` for your amount, and whether a single withdrawal that large has ever been recorded. Before putting capital somewhere, ask what has actually LEFT it. Every liquidity figure elsewhere is a level at an instant — how much could be withdrawn right now. This is the other half: withdrawals that SETTLED, over 7, 30 and 90 days, with the largest single exit we have ever recorded and the day it happened. Measured on the largest vault we read on 29 September 2026: $52.8M declared withdrawable against $265.8M actually withdrawn over thirty days, so a holder reading only the declared figure would badly underestimate what the vault has been able to pay. A LEVEL and a FLOW are never divided by one another and this returns no ratio between them. We see withdrawals that settled and NOT an attempt that reverted, a queue somebody waited in, or a gate that refused them. An empty register therefore has FOUR readings, not two: “nobody withdrew”, “nobody could”, “a reader asked and found nothing at all”, and “no reader has ever asked”. `haveFlowHistory` separates the first two from the last two and `lastReadAt` separates those — null there means nobody has ever looked, so the register is not a weak reading of the vault but the absence of one. `haveFlowHistory` separates the third from the first two, and where it is false every figure is NULL rather than zero. Every answer dates itself: `capitalAsOf` and `declaredAsOf` say when each level was read, `flowsNewestAt` how far our movement history reaches, and `windowsEndAt` the instant the windows count back from. For a capital decision the age of the record is part of the record. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What actually left a vault
Changes things 38Claude Code: ask
agent_businessDoes this agent have a BUSINESS, and can any of it be demonstrated?Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Does this agent have a BUSINESS, and can any of it be demonstrated? Six questions an investor, a marketplace or an operator actually asks, each answered separately: are the addresses paying it really independent customers; is revenue growing or shrinking; how much is repeat custom; how many of those payments can be shown to have bought anything; what does it cost to run and to whom; and if it has several addresses, can the link be DEMONSTRATED or is it an unconfirmed assumption. THERE IS NO SCORE over the six, deliberately: a number would average "thousands of addresses paid this" against "we hold no delivery record at all", and the second is a statement about US. Four things the data invites and this refuses, explained in `limits`: an ADDRESS is not a customer; a PAYMENT is not a delivery; a SHARED FUNDER is not an identity; and a COST we cannot see is not a cost that is not there. It also carries `economicChain`: the four links an agent has to complete to be a working economic subject (a customer paid it, it ordered or did work, the result was demonstrably delivered, a customer came back), each `evidenced`, `unevidenced` (about the agent), `unread` (about US) or `unevidenceable` (about the rail), never folded together. NO SCORE there either: the worst link governs. For an x402-only agent the delivery link is unevidenceable, which is the rail and not the agent. PAID.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Does this agent have a business (paid)
agent_changesWhat moved in the agent record, across every agent, since a date.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What moved in the agent record, across every agent, since a date. The counterparty check answers what is true about one address NOW; this answers what changed, for all of them, which is the question anybody holding a list asks next. One row per FIELD that moved, not per address: an agent whose dealings and concentration both moved is two facts, and folding them would make you diff the answer to work out what was meant. Roughly one agent in five moves on an ordinary day; how many are tracked is a denominator on the answer rather than a number frozen here. A day with no row for an address is a day it did not move, never a day nobody looked. The record began on a date and `from` says which: asking for anything earlier answers from there rather than pretending nothing happened. Needs a key and the agents.changes capability.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What moved in the agent record
agent_dd_reportDue diligence on an ACP provider before hiring it: does it finish the work, who said the work was done, who pays it, is the record current, who is behind it, is it on a sanctions l…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Due diligence on an ACP provider before hiring it: does it finish the work, who said the work was done, who pays it, is the record current, who is behind it, is it on a sanctions list. Each answer has a status and what would settle it. No score and never a statement that the agent is safe. `applies` is false for an address with no paid ACP job and judged completion, and that is not a finding about the agent. ACP is read on Base only.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Due diligence on an ACP provider
agent_dependenciesIf your firm relies on several external agents, what do they rest on AT ONCE?Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it If your firm relies on several external agents, what do they rest on AT ONCE? Give it two to twenty-five addresses and it finds the parties more than one of them pays. THE PRODUCT IS THE DISTINCTION, NOT THE JOIN: finding that three agents paid the same address tells you almost nothing — on our rails one address is paid by 71 agents across 4,100 payments and another by three agents once each, and calling both "shared" makes the second sound like the first. Four tests must ALL hold before the word dependency is used: repeated (more than one payment, because a single payment is an event), one-way (it has never paid them back, because money moving both directions is trade between peers and survives either of them leaving), sustained (spanning more than a day, so a burst of twenty in an afternoon is not a standing arrangement), and shared (more than one of the agents you named). All four are published on every party under `tests`, so you can draw the line somewhere else than we did. Anything short is a `shared-counterparty` with its failed test named and is reported as a LEAD. The concentration line counts dependencies only. A party just ONE of them pays is left out entirely — that is `counterparty_check`, free. Most shared infrastructure, a cloud region or a model provider on a card or one operator holding the keys, leaves no payment at all, so what this finds is a FLOOR on the concentration that exists and never a measure of it. PAID.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: What several agents rest on at once (paid)
agent_economic_profileOne agent, four readings, in the order a buyer actually asks them: what it EARNS and from whom, whether its contracted work FINISHED and who signed it off, who it RESTS ON as a sup…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One agent, four readings, in the order a buyer actually asks them: what it EARNS and from whom, whether its contracted work FINISHED and who signed it off, who it RESTS ON as a supplier, and whether it is still TRADING and its endpoints answer. Those questions are answered singly elsewhere on this server; this is the one that answers them together, over the same nightly record, so the four cannot disagree with each other or with the endpoints they summarise. THERE IS NO SCORE ON TOP and there will not be one: a single figure would be the thing every reader quotes and the only one none of them can check, and it would average a measured quantity with an unmeasured one until neither is visible. Each block keeps its own counts and its own denominator. A block we have not read comes back NULL rather than as a row of zeros, because "it has no completed jobs" and "we have not read its job side" are different facts and a buyer choosing between agents deserves to know which one they are looking at; `blocksAnswered` says how many of the four this answer could fill. `cannotSee` names what no block here can reach at all — revenue that never touched a rail we read, dependencies that are not payments, and whether completed work was any GOOD, which we cannot see from who signed it off. PAID.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Agent economic profile (paid)
agent_hire_checkBefore the first payment to an agent over x402: does its endpoint answer, does it charge what it lists, who pays it, does it deliver.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Before the first payment to an agent over x402: does its endpoint answer, does it charge what it lists, who pays it, does it deliver. Each answer is ok, caution or not_established, with what would settle it. x402 records a payment and nothing about delivery, so delivery stays not established there. `no_warning_found` is not a statement that the agent is safe to hire.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Four questions before the first payment to an agent
capital_coverageBEFORE YOU TRUST ANY COVERAGE FIGURE FROM US, ask this.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it BEFORE YOU TRUST ANY COVERAGE FIGURE FROM US, ask this. It says how much of the market each vault reading actually covers, counted TWO WAYS: by number of open vaults and by the capital in them. They differ by a lot, and the difference is the finding — more than half our vault COUNT is one venue’s small automated vaults, so a count-weighted coverage figure is mostly a statement about that venue and tells you almost nothing about whether the capital you care about is covered. NEITHER is called "the coverage". Free, because it is a statement about OUR OWN limits and a coverage claim nobody can audit is marketing rather than evidence. It says what we CAN read and never whether a vault is any good; WHICH vaults are missing a reading is the paid screen, not this. Readings: would take a deposit, risk score, withdrawable now, crowding, how exit works, time to exit, worst fall, who can move the money, what a holder earned — the same 9 columns the vault screen shows, read from the same expressions.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: How much capital we can actually read
check_service_endpointCall this before connecting to a service.Reads text others writeCan send data out2 findings
Why it is in this group
- The description's first verb is "call": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Findings
- Info
The description mentions "credentials".
What this check looks forMatched text
description: "...shake` says whether it answered without credentials, which is the nearest observable thing..."
- Warn
The server marks "check_service_endpoint" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "call": a word for a change.
Description, as the server wrote it Call this before connecting to a service. Give it the http(s) URL of an MCP or A2A endpoint and it says who declares it, whether our daily probe reached it, what it answered with, and how many of the last readings answered. It keeps three things apart and never merges them: what an identity DECLARES the endpoint offers, what a probe OBSERVED, and the readings behind that. Read `drift` where present — tools declared but not answering is the signal that an endpoint has changed under the people relying on it. It also answers the three things a buyer wants BEFORE calling a paid endpoint, as separate fields and never folded into one number: `price` is the seller’s own published amount, asset, network and payee; `handshake` says whether it answered without credentials, which is the nearest observable thing to “can I try it”; and `measured` is how many of how many days answered and how slow it was, which is what we read rather than a guarantee anybody made. `manifest` and `changes` carry the series: a registration says what an agent offers now, and the readings say what it offered LAST WEEK. Store `manifest.hash` and compare it next time to detect an endpoint that changed under you. Two things this is NOT: an unreachable endpoint is an availability fact and never evidence of bad faith (weigh `latest` against `history`, since one bad day and a dead service look identical in a single reading), and an endpoint we have never probed is outside our reading rather than absent from the world. For a CATALOGUED x402 resource that no agent registered, read `unpaidProbe`: our own unpaid 402 handshake, which is free for both sides and says whether the endpoint is still there and what it charges now against a catalogue entry that may be months old. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Check a service endpoint before connecting
counterparty_bulkCheck up to fifty addresses in one call, each with its observations, AND what the set shares underneath: the parties that two or more of them pay.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Check up to fifty addresses in one call, each with its observations, AND what the set shares underneath: the parties that two or more of them pay. That second part is the one answer no per-address row can contain, because the input is your own shortlist — four agents stopping together because they all pay one party is invisible in four separate clean records. PAID two ways and they buy different things: one cent a call over x402, priced per call rather than per address, buys the rows; the `shared` block needs the `dependency.shared` capability, on Analyst and above, and when it is missing the block says so rather than vanishing. A shared recipient is not proof of a shared dependency — several agents paying one address may be paying a relayer, a bridge or the same customer back — and an empty list is a finding about these addresses AND about our reach. WHY readOnlyHint IS false: this tool reads and writes nothing in our store, but calling it WITH an x402 payment authorisation transfers USDC from the caller to us and records a receipt, so the call is not free of consequence and an agent must not make it speculatively. Called without an authorisation it changes nothing and answers with the price.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Check up to fifty addresses in one call (paid)
counterparty_checkBefore paying or hiring an agent: what the chain records about that address.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Before paying or hiring an agent: what the chain records about that address. `byNetwork` splits it network by network: x402 payments received (and their dollars, stablecoins at face value), ACP jobs and paid dollars, Olas tasks and registrations, per chain and never added across rails, because one address can settle on several networks at once. Independent payers (counterparties that paid it and were never paid back), the ones it does pay back, how concentrated its custom is, WHETHER THOSE INDEPENDENT PAYERS ARE INDEPENDENT OF EACH OTHER under `independence`, WHAT IT ITSELF RESTS ON under `restsOn` (how many parties it pays and how much of its spending goes to the largest of them), how its ACP jobs ended, whether its advertised service answers, and when it was last paid. Free. Three limits to repeat whenever quoting it: independent means no payment BACK on the rails we read, NOT proof the payers are different parties, since one owner can fund many addresses that never pay each other; an all-time record says nothing about whether the agent still works — 44% of agents ever paid had not been paid in 90 days, measured on 29 September 2026; and `restsOn` counts every party this address has PAID rather than purchases from identified sellers, so a recipient there has not been shown to supply anything, and `restsOn.suppliers` of zero means it has paid nobody on a rail we read, never that it depends on nobody. Takes an EVM address, a Cardano payment address (addr1…) or a Solana address.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What the chain records about one address
counterparty_evidenceBefore trading with an agent or service: what the records actually say about it, in one answer.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Before trading with an agent or service: what the records actually say about it, in one answer. Identity links with their strength (declared by the agent, observed by us, or corroborated by a second party), settled payment history with first and last payment, active months and long silences, counterparties with top-1 and top-3 share, Herfindahl and repeat ratio, each catalogued service with its price, how often it was paid at that price and whether delivery can be observed at all, what we cannot see, and whether there is enough history to conclude. Paid ($0.01). Settled payments, distinct counterparties and delivery evidence are SEPARATE figures and never a score: much measured agent-payment volume is self-dealing, wash or tests, and a payment does not show a service was delivered. Read `sufficiency` and `warnings` before any figure, and quote `guard` with them.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Evidence on a counterparty before trading (paid)
counterparty_historyHow one agent’s record has moved: dealings, independent payers, concentration and delivery, day by day.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it How one agent’s record has moved: dealings, independent payers, concentration and delivery, day by day. PAID, one cent a call over x402 — the median price of this rail. Without payment the tool answers with the price and how to pay it, and the free check remains available. The history begins the day we started keeping it; it is a record we keep, not one the chain gives away. WHY readOnlyHint IS false: this tool reads and writes nothing in our store, but calling it WITH an x402 payment authorisation transfers USDC from the caller to us and records a receipt, so the call is not free of consequence and an agent must not make it speculatively. Called without an authorisation it changes nothing and answers with the price.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: One agent’s record day by day (paid)
endpoint_coverageBEFORE YOU TREAT ANY ENDPOINT AS RELIABLE, ask how well we know.Reads text others write1 finding
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description mentions "credentials".
What this check looks forMatched text
description: "...tly what it advertises, a 401 or 403 is credentials WE do not hold, a 3xx is a move we chos..."
Description, as the server wrote it BEFORE YOU TREAT ANY ENDPOINT AS RELIABLE, ask how well we know. There is no uptime number here and there will not be one, because the states mean different things and summing them produces a figure about nothing: a 402 is an x402 seller doing exactly what it advertises, a 401 or 403 is credentials WE do not hold, a 3xx is a move we chose not to follow, and a timeout describes OUR attempt rather than the host. Only the states marked `fault: true` are the endpoint failing. TWO POPULATIONS, each on its own denominator and NEVER added together: the HOSTS registered identities declare, probed daily under a deadline that sometimes expires before every host is reached — so a host we did not ask keeps whatever an earlier day found, and `notAsked` says how many — and the x402 RESOURCES sellers list, where a state is published only after three knocks because one failure is not a finding. The second number is the uncomfortable one and it is published anyway: most listed resources have never been knocked on at all, which is our reach and not a judgement of the sellers. Free, because a coverage claim nobody can audit is marketing rather than evidence.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: How well we know whether declared endpoints answer
endpoint_disagreementsWHICH ENDPOINTS CONTRADICT THEIR OWN LISTING: they ask to be paid at an address the catalogue entry they published does not name.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it WHICH ENDPOINTS CONTRADICT THEIR OWN LISTING: they ask to be paid at an address the catalogue entry they published does not name. The contradiction appears only when the live handshake and the published listing are held together: either half on its own looks ordinary, since a reachable endpoint and a stated payee are each unremarkable alone. A disagreement is between two statements by the SAME party, so it is theirs to explain and never ours to resolve, and it is NOT evidence of fraud: a seller may have moved their payee and not relisted. Measured only over endpoints we have knocked on, which is our reach and not the catalogue; `comparable` is the denominator, because an endpoint that names no payee cannot disagree and is counted neither way. THE COUNTS ARE FREE AND THE LIST IS NOT: `items` comes back NULL without a plan rather than empty, since an empty list would say we found none. Any SINGLE endpoint is free — `test_purchase` and `list_x402_endpoints` both carry its own reading — because that one is reproducible in two requests and because withholding something that can cost a buyer money is not a thing we do.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Endpoints that contradict their own listing
evaluate_actionCall this when you are about to DO something and need one answer you can act on: pay an address, connect to an MCP server, call a tool, or put capital into a vault.Reads text others write1 finding
Why it is in this group
- The name "evaluate_action" says "evaluate": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "evaluate_action" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "evaluate_action" says "evaluate": a word for a change.
Description, as the server wrote it Call this when you are about to DO something and need one answer you can act on: pay an address, connect to an MCP server, call a tool, or put capital into a vault. The answer depends on the AMOUNT, the ACTION, the POLICY you name and how much we actually read — so the same address can be `allow` for $5 and `abstain` for $5,000. Four decisions. `allow` means nothing we could check objects, up to `maxAmountUsd`, and is NOT a statement that the action is safe: nothing here sees what it is for or what you agreed. `review` means something we READ does not match, and `reasons` names which rule. `abstain` means we did not read enough to have an opinion — our gap, never approval. `unsupported` means the policy has no rule for this action, and inventing one would be worse than declining. A policy judges the risk LEVEL as well as whether it could be read: conservative will not allocate into a band worse than moderate, nor where control is `thin`, and returns `review` for that rather than `abstain`. A failed rule carries `detail` (`observed`, `accepted`, `failedCondition`); read it, and `rules`, before suspecting an error. Every rule id in `reasons` is published in full at the policies tool, including to the party being evaluated. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Weigh one action against a named policy
evaluate_vault_decisionCall this before an agent moves capital into or out of a vault, with the decision it is about to make: the vault, the amount, the MANDATE it must stay inside and the CLAIMS the dec…Reads text others writeNo findings
Why it is in this group
- The name "evaluate_vault_decision" says "evaluate": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Call this before an agent moves capital into or out of a vault, with the decision it is about to make: the vault, the amount, the MANDATE it must stay inside and the CLAIMS the decision rests on. It is judged against our stored due-diligence snapshot of that vault, deterministically and without a model, and comes back with a `verdict`: `supported`, `conditional`, `human_review_required`, `insufficient_evidence` (the snapshot is older than your mandate accepts, or a claim states as known what the snapshot records as unread), `not_approved` (a mandate limit is broken or a claim is contradicted) or `out_of_coverage` (we hold no snapshot, nothing charged). Every finding cites the snapshot field it rests on as `dd:<digest>#<json pointer>`, so it can be checked and cannot be invented, and `requiredNextSteps` says what would change the verdict. A claim the snapshot contradicts is told the DIRECTION of its error, never the true figure: the figures are in the due-diligence report. PAID: $2 a judgement over x402, or inside a plan that reads due diligence. FREE with `dryRun: true` (can it be judged, how old is our snapshot, what would be checked; no verdict) and FREE in full on the two public sample vaults, ethereum-sentora-rlusd-main-6dc58a and ethereum-1337-usdc-94643e. A `supported` verdict means the decision is consistent with our evidence and its own mandate. It is not advice and not a guarantee about the vault. Keep the `digest`: anybody can confirm at /v1/reports/{digest} that we issued that judgement unchanged.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Judge a vault decision before capital moves (paid)
evidence_forEverything we hold about one subject, as edges, each carrying where it came from.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Everything we hold about one subject, as edges, each carrying where it came from. Use it when you need to explain a decision rather than just make one, or to see what is MISSING before you act. Every edge has `source`, `observedAt` (when the world was in that state), `asOf` (when we read it — a fresh read of a stale fact is not a fresh fact), a `confidence` that names what it is confident IN, its own `coverage`, and the `method` that established it. Edges come in three kinds and are NEVER summed: `declared` is the subject speaking about itself, `observed` is our reading, `derived` is arithmetic over the others. Adding them together rebuilds the reputation score this replaces. It infers NO identity: a shared host or funder is reported as exactly that, because being the same party is a conclusion no join supports. `lookedForAndMissing` lists what we searched for and did not find, so a thin subject never reads as a complete picture. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Every edge we hold about one subject
exit_lifecycle_coverageHOW MUCH OF THE WAY OUT WE CAN SEE, phase by phase, across every open vault.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it HOW MUCH OF THE WAY OUT WE CAN SEE, phase by phase, across every open vault. Getting out has four phases — a request filed, something set aside to claim, money that actually left, and an attempt that failed — and we read THREE. The fourth is on this answer anyway, with its reason: no vault state records a redemption somebody attempted and could not complete, so reading it needs every transaction sent to each contract and its receipt, and a zero there would be the most misleading figure available because it would say nobody was turned away. FOUR STATES PER PHASE and never collapsed into "missing", because two of them look identical and are not: `exempt` is a phase that CANNOT exist (a synchronous redeem settles in the transaction that asks, so nothing is ever filed and nothing is ever set aside) and `subjectRefuses` is a phase that EXISTS while the contract will not expose it (an ERC-7540 vault carrying neither standard getter — the holder is in that phase and cannot be told what became of their request). Only `unread` is work of ours. THERE IS NO SINGLE LIFECYCLE PERCENTAGE: the phases have different denominators, so averaging them would give a number no phase is answerable for. Free, because it is a statement about our own reach.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: How much of the way out we can see
exit_screenYOU HAVE A SIZE AND YOU WANT TO KNOW WHERE IT HAS ACTUALLY CLEARED.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it YOU HAVE A SIZE AND YOU WANT TO KNOW WHERE IT HAS ACTUALLY CLEARED. Every other exit reading here is about one vault; this asks the same question across every vault whose withdrawal history we have read, which is the question an allocator with capital actually has. Send `amountUsd` and each vault comes back with one of THREE verdicts, and the middle one is the finding: `paid-in-one` means a single settled withdrawal at least that large has been recorded there; `paid-across-a-day` means that much has left in one day and never in one withdrawal, which is a different fact and not a weaker version of the first; `never-asked-this-size` means nothing that large has been withdrawn, which is NOT a refusal and NOT a failure, because most vaults have never been asked. It exists because an auditor screened a $6M exit from a vault declaring $15.10M withdrawable, got a supporting answer, and found the largest withdrawal ever observed there was $500K. Declared liquidity is a LEVEL at an instant; what has left is a FLOW; only the second is evidence about a size. The two are never divided by one another and no ratio between them is returned. `population` names how many vaults have no history at all, because those are UNREAD rather than untested and must not be counted as either answer. Nothing here is a forecast: a vault that paid this much last March can refuse today. PAID.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Where has a size like mine actually cleared (paid)
identifyCall this FIRST whenever you hold something other than a wallet address.Reads text others write1 finding
Why it is in this group
- The description's first verb is "call": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "identify" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "call": a word for a change.
Description, as the server wrote it Call this FIRST whenever you hold something other than a wallet address. Give it a transaction hash, an http(s) URL, a hostname or an ERC-8004 registration number and it says which party that is, with the evidence for the link, so the other tools here can then be called with the address. It never picks between candidates: where a hostname or id matches several parties, `address` comes back null and every candidate is listed, because choosing one would be an identification the evidence does not support. A link through a hostname or a declared endpoint is the subject’s own claim, never proof that they control it. An identifier it cannot resolve is not evidence of anything wrong — read `says`, which distinguishes "no such thing" from "we do not read that chain". Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Identify the party behind an identifier
knock_on_endpointKNOCK ON AN x402 ENDPOINT AND GET WHAT IT SERVED.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it KNOCK ON AN x402 ENDPOINT AND GET WHAT IT SERVED. `test_purchase` beside this walks a buy WITHOUT paying and stops at the quote; its own caveat has always said that only paying and reading the answer establishes what arrives, “which is the half that needs your own wallet”. This is that half, and it is the same capability the web and the plugin have. WITHOUT `payment` it reads the terms: `accepts` carries EVERY set of terms the seller published and `signable` the ones an EIP-3009 wallet can meet, and WHICH ONE TO PAY ON IS YOURS TO CHOOSE. WITH `payment` we forward the authorisation YOU signed and hand back what the seller served. WE NEVER HOLD YOUR KEY. A SERVED ANSWER MEANS THE SELLER ACCEPTED IT, NOT THAT MONEY SETTLED. A 402 on a knock that CARRIED a payment is reported as `rejected`, not as a fresh quote, and IT DOES NOT ESTABLISH THAT NOTHING WAS SPENT. `settlementState` and `authorizationState` are the fields to read: a presented authorisation stays usable until it expires or its nonce is spent, so signing again with a fresh nonce can be a SECOND payment. We knock only on endpoints already in the x402 catalogue we read, at most one UNPAID handshake a minute per endpoint shared by everybody, and never on our own host: what we sell has one set of terms and one door. The seller’s answer is yours and is not stored. FREE.
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
- readOnlyHint: false
- title: Knock on an endpoint, with your own payment
operator_checkThe question that follows vault_check: who runs the money, and how much of it is their own.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it The question that follows vault_check: who runs the money, and how much of it is their own. Free. Read `ownShare` with its limits, which travel inside it: the leader’s holding is readable on Hyperliquid and Drift ONLY, so elsewhere it is ABSENT and not zero, the median describes the strategies we can read rather than the manager, and a large own-share is evidence of alignment and never proof, because the address running a vault can be a treasury or a custodian holding for other people. `cannotSee` names whatever of that applies here. Take the slug from vault_check’s `operator`.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Who runs the money, and how much is theirs
record_receiptCall this AFTER you have paid an address or called a tool, to put what you did on the record.No findings
Why it is in this group
- The description's first verb is "call": a word for a change.
Description, as the server wrote it Call this AFTER you have paid an address or called a tool, to put what you did on the record. Until now this platform answered "should I" and never heard what happened, which is the difference between a lookup and a control layer: a receipt lets the next question about this subject be asked against a record instead of a guess, and lets a verdict we gave be read back against what followed. `reference` is YOUR evidence, a transaction hash or the digest of a signed payload, and we store it WITHOUT verifying it. It comes back `claimed` and within the hour is judged against the payments we read from the chain: verified, contradicted, not found after two days, or unverifiable. Read the outcome at GET /v1/receipts/{id}. A claim never raises an evidence status, so a receipt nobody has checked never looks like one that settled. Needs a key; a receipt is readable only by the key that wrote it. WHY readOnlyHint IS false: this call writes a row in our store on behalf of the caller, so a second identical call is not free of consequence.
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: false
- readOnlyHint: false
- title: Record what you did, so it can be checked later
stock_agent_activityHow many AI agents moved a tokenized stock over a window you choose (default the last 24 hours): distinct agent addresses, transfers in and out, value at the issuer’s reference, by…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it How many AI agents moved a tokenized stock over a window you choose (default the last 24 hours): distinct agent addresses, transfers in and out, value at the issuer’s reference, by token and network. Ask by ticker (TSLA), company name (Tesla) or ISIN, or leave it empty for every stock. Free. Agents are the addresses we hold as ERC-8004 owners, ACP providers and clients, Olas task agents and x402 payees; read on Base, Arbitrum, BNB Chain and Robinhood Chain; issuer wallets are left out.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Agents moving a tokenized stock, over a window
stock_buy_checkCheck a tokenized stock BEFORE BUYING it, by its contract (or Solana mint) and network: can it be moved today (pause state, a permanent delegate), is a controlling address on the O…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Check a tokenized stock BEFORE BUYING it, by its contract (or Solana mint) and network: can it be moved today (pause state, a permanent delegate), is a controlling address on the OFAC SDN list, does the pool price track the issuer’s reference, is there DEX liquidity to sell into, is it concentrated in one holder, and is it backed where the issuer reports reserves. Each question has a state (ok, caution, not_established) and the answer an overall status: caution, no_warning_found or not_established. Never "safe", never advice. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Check a tokenized stock before you buy
stock_checkOne tokenized stock by its contract address (EVM) or mint (Solana): the issuer, the network, supply (read on chain except Coinbase’s), the issuer’s reference value with its source …Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One tokenized stock by its contract address (EVM) or mint (Solana): the issuer, the network, supply (read on chain except Coinbase’s), the issuer’s reference value with its source and time, what is in issue in dollars, who controls the token where read (pause state, transfer policies, supply cap, roles), where it trades and at what premium to the reference (DexScreener, named), what is not yet read, and `sameCompany`: the same company on every other network and issuer we read, with the total. Free. A reference value is not a tradable price; a token with no pool is not traded where we look, never zero liquidity.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: One tokenized stock, every network it is on
stock_holdersEvery holder of one tokenized stock, from the register rebuilt from its transfers since deployment: balance, value at the issuer’s reference, share outside the issuer’s own wallets…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Every holder of one tokenized stock, from the register rebuilt from its transfers since deployment: balance, value at the issuer’s reference, share outside the issuer’s own wallets, and transfer counts, largest first (up to 2,000). PAID per call, $0.10 over x402 (USDC on Base) or with a plan; concentration and the largest holders are free in stock_check.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Every holder of a tokenized stock (paid)
stock_issuer_checkOne issuer of tokenized stocks (coinbase, robinhood, xstocks, ondo, bstocks, dinari): the entity and jurisdiction as its documents name them, what it has tokenized (tokens, compani…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One issuer of tokenized stocks (coinbase, robinhood, xstocks, ondo, bstocks, dinari): the entity and jurisdiction as its documents name them, what it has tokenized (tokens, companies, value at its reference values), on which networks, the control addresses its contracts answer (owner, minter, burner, pauser, sanctions list, registry; Solana mint, freeze and pause authorities and any permanent delegate), holders where read, reserves where it reports them, what is paused now, the contract family’s documented powers, and an OFAC SDN exact-match screening of the control addresses with the list version. Free. No match does not rule out a sanctioned party; holders are read on Ethereum and Solana only.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: One tokenized-stock issuer: what, where, who controls it, OFAC
vault_assessmentTHE HASH-COMMITTED ASSESSMENT OF A VAULT, in the shape ERC-8004’s Reputation Registry points at, and the only thing here a third party can publish on chain under their own name.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it THE HASH-COMMITTED ASSESSMENT OF A VAULT, in the shape ERC-8004’s Reputation Registry points at, and the only thing here a third party can publish on chain under their own name. Until 2026-10-21 this document was reachable from the API and the web and from NO tool, so an agent could read every figure behind it and not the document itself. Each dimension is its own score and they are never blended: a vault can have an excellent record and a poor provenance grade, and one number would destroy the distinction this platform exists to draw. `data.document` is what the hash covers, byte for byte, and `data.feedbackHash` is that hash. READ `data.document.refusals` BEFORE ANY MISSING DIMENSION: from aspern-0.4 an absent dimension is UNREAD unless a refusal names it, and a refusal means we hold a reading we will not stand behind — a liquidity share over 100% of the vault, for instance, which is a disagreement between two of our own readings rather than a fact about the vault. `data.alsoPublished` sits deliberately OUTSIDE the hash: the risk band, the lending figures and the books reconciliation are ASPERN’s own reading, and a consumer attesting the hash is attesting the document alone. `data.erc8004` carries the call arguments for whoever wants to publish it; ASPERN does not make those calls and never holds a mainnet key. Ask for an older `methodology` to rebuild a document at the version a hash was issued under; the list is on /v1/meta. Free. Every document is kept by its hash: `snapshot.url` (GET /v1/assessments/{hash}) returns it exactly, with the rule (canonical JSON with sorted keys, UTF-8, keccak-256 over `document` only) and `snapshot.verify`, a standalone script with test vectors that recomputes the hash with no code of ours.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
vault_checkBefore putting capital into a vault: what the record shows about it.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Before putting capital into a vault: what the record shows about it. The headline is what a holder ACTUALLY EARNED set against the advertised rate, with the risk band, the components that apply, who runs it, and `keys`: who can move the money. Read `keys.actsAlone` before any return figure, because a strategy can be excellent and one private key away from being emptied; across what we read on 6 October 2026, a single key controlled $1.26bn and 47 of 249 multisigs required one signature; `keys` gives today’s reading. Free. Read `earned.comparability` AND `earned.representativeness` before quoting the ratio: the first says whether a realised rate can be compared with the advertised one at all, the second whether the result is worth planning around rather than one day that moved, and `cannotSee` lists everything we could not establish for this vault rather than leaving it as an absence you have to notice. `changedHands` carries whether those keys have been MOVING, which is the due-diligence question `keys` cannot answer — read its `watchedSince`, because a count of zero means nothing moved since we started watching and not that the vault has never changed hands. Rates are decimal fractions: 0.0432 is 4.32% a year.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What the record shows about one vault
vault_driftWhat changed on one vault, day by day, between the stored daily due-diligence reports: the overall assessment (including when it became withheld or published again), each risk dime…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What changed on one vault, day by day, between the stored daily due-diligence reports: the overall assessment (including when it became withheld or published again), each risk dimension, the withdrawable share, capital, control roles and the timelock, and the tested withdrawal. Paid ($0.01). A change can be the vault, what we could read, or our model; days with no stored report are listed under `gaps` and not compared. Quote `limits` with it.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: What changed on a vault (paid)
vault_due_diligenceThe due-diligence report on one vault, cut to what an agent acts on: overallAssessment (published, conditional or withheld; publishedBand is null when withheld and partialBand is n…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it The due-diligence report on one vault, cut to what an agent acts on: overallAssessment (published, conditional or withheld; publishedBand is null when withheld and partialBand is never the verdict), findings above the band, each risk dimension, capital and withdrawal bounds, metricStatus (each input current, indicative, stale, unavailable or not-read, with its times and expiry), completeness, warnings and agentRules. Follow agentRules when you answer: they say what must be quoted and what must not be said. PAID ($5 over x402, or inside a plan with due diligence). The digest names the whole issued document; verify it at /v1/reports/{digest}.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Due-diligence report for agents (paid)
vault_exit_confidenceBefore you put capital in, ask what evidence there is that you could get a PARTICULAR amount back out.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Before you put capital in, ask what evidence there is that you could get a PARTICULAR amount back out. Every other reading about a vault is about return or about risk of loss; this is about the practical question a holder has, and it is always about a size: "can I get out" has no answer, "can I get $2m out of a vault with $400k free and 25,941 settled withdrawals behind it" has several. Six readings, each with its own verdict and the question it answers in a holder’s own words: has anybody actually got money out, is there anything in it now, could YOUR amount leave, is somebody queued ahead of you, how much of the capital is lent out, and can somebody change the terms under you. The answer is the WORST of them and never an average — a queue in front of you is not offset by a long history, it happens before your turn — and an `unknown` outranks a `supports`, because a gap we could not read must never be counted as a pass. `not-asked` marks a component whose input you did not send, and `not-applicable` one this venue does not have at all — only two venues have an exit queue to be behind. Neither is a gap in our record and neither lowers the answer. A withdrawable figure is a FLOOR on venues whose vaults lend into markets holding their own liquidity, and the component says so rather than reading it as a ceiling. NOTHING HERE IS A GUARANTEE of withdrawal and no sentence it emits contains the word: a vault that has paid everybody for a year can stop tomorrow. PAID.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Could you get your money back out (paid)
vault_exposure_graphWhere one vault’s capital is exposed, as a graph: vault → market → collateral, loan asset and oracle.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Where one vault’s capital is exposed, as a graph: vault → market → collateral, loan asset and oracle. Every edge carries its size in dollars, its share of what the vault allocates, the vault’s share of the market, the LLTV where it secures, when it was read and where from. Cut from the vault’s due-diligence document, the same engine the report and vault_check use, so it says nothing the report does not. A node not fully read has `state: unknown` and says what was not read (an oracle’s feeds are never assessed here), and capital in no market read is its own node, never dropped. Free. It does not assess the collateral’s quality, the borrowers or the oracle, and it is not a block-level reconciliation.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Where one vault is exposed
vault_risk_dimensionsSIX RISKS, NOT ONE WORD, across every vault we score.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it SIX RISKS, NOT ONE WORD, across every vault we score. A risk band is a weighted whole and a reader takes it as a summary of everything, which it is not: ours weighs drawdown, crowding, exit, concentration and consistency, and it contains NO reading of who may move the money. Two vaults read `low` while a multisig needing a single signature controlled them. So this groups what is already measured into market, liquidity, concentration and operating risk, ADDS the controller as its own dimension, and ADDS evidence — how much of the vault we could read at all. There is deliberately NO overall figure: a composite would be the number everybody quotes and nobody can check. THE FINDING IS FREE: `population` says how many scored vaults carry a band that reads BETTER than one of their own dimensions, and how many of those read worse on a dimension the band never contained — which is the number to read before trusting any one word on this platform. THE LIST IS PAID (`dimensions.read`): which vaults, with each one’s six levels, what it holds, and a sentence naming the disagreement. `locked` says when it is withheld, so an empty `items` is never mistaken for no matches — `denominators.matchedTheFilter` counts them either way. For ONE vault the whole table is FREE at `vault_check`, which also computes what else it could not see. Filter with `dimension` and `level` to run the screen that matters, e.g. the vaults whose controller reads `high`.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Six risks across every vault we score
vault_rwaWhat one vault holds in real-world assets: tokenized stocks it holds at its own address, what it has lent against tokenized stocks as collateral (exposure through borrowers, not st…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What one vault holds in real-world assets: tokenized stocks it holds at its own address, what it has lent against tokenized stocks as collateral (exposure through borrowers, not stocks it owns), and whether its own asset is a stablecoin. Free. Holdings come from the registers we rebuild for the largest stock tokens; anything outside them is not seen, not absent.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: A vault’s tokenized stocks and stablecoins
vault_sanctions_screeningOne vault against the OFAC SDN list: its contract roles and its direct holders where the holder list is complete, exact address matches only, with the list version and whether it i…Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One vault against the OFAC SDN list: its contract roles and its direct holders where the holder list is complete, exact address matches only, with the list version and whether it is current. Paid ($0.01). States: EXACT_LISTED_ADDRESS_MATCH (a match of an identifier, for review, not a finding about who controls it), NO_EXACT_MATCH (bounded: the list is not exhaustive, so this never means no sanctioned party), UNKNOWN (an incomplete holder list or a stale list). Never describe a result as clean, compliant or safe. Quote `says` and `limits`.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Sanctions list screening of a vault (paid)
vaults_earnedWhat depositors actually KEPT, against what their vault advertised.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What depositors actually KEPT, against what their vault advertised. READ `population` BEFORE QUOTING ANY SHARE FROM THIS. The comparison covers only the vaults where we hold BOTH an advertised rate and a realised one, which is a narrow and lopsided set, usually dominated by one venue: `population.largestVenue` names it and `population.concentration` says how much of the set it is. A share from here is a statement about those vaults, never about DeFi and never about this whole site. Not the vault’s return, which is what a unit held throughout would have earned: this is read from the depositor register, per vault, and set against the venue’s own quote scaled to how long those depositors have held. How many gave their depositors less, and by how much, is in each answer’s `population`, counted when it is served; quote it from there, never from this description. ADVERTISED RATES ARE DECIMAL FRACTIONS and some are in the hundreds of per cent: 0.042 is 4.2% and 4.2 is 420%. Those survive a stated band of -1 to 5 (-100% to 500%); `advertisedBand.refused` says how many readings the band threw out, and `advertisedIsHigh` marks each row above 100% so a remarkable figure cannot be mistaken for a misplaced decimal. TWO THINGS TO REPEAT WHENEVER QUOTING IT. A depositor who withdrew everything is not in the register and the ones who left after losing are exactly the ones a return figure most needs, so this reads BETTER than the truth rather than worse; and `gapPoints` is percentage POINTS, not per cent, because a depositor cannot lose more than they put in. The aggregate and the widest gaps are free; the rest of the list needs the earned.detail capability and `withheld` says how many are missing.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What depositors kept, against what was advertised
Only reads 11Show 11 read-only tools
compare_agentsCompare 2 to 5 agent addresses side by side on one taxonomy, from the record we keep for every paid address: identity (registered name, ERC-8004 registrations, rails, chains), cust…Reads text others writeNo findings
Why it is in this group
- The name "compare_agents" says "compare": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Compare 2 to 5 agent addresses side by side on one taxonomy, from the record we keep for every paid address: identity (registered name, ERC-8004 registrations, rails, chains), custom (counterparties, independent payers who were never paid back, payers it also paid, the largest payer’s share, the share who came back), money (received and paid out where priced, x402 payments), work (ACP jobs, completed, completion rate, Olas deliveries) and activity (dealings over 30 and 90 days, first and last paid). Free. Each cell is {state: "read", value, readAt, source} or {state: "unknown", why}; an address with no paid record is a row of unknowns, never zeros. There is no winner and no ranking; `sort` orders by the one figure you name. Independent means no payment back on the rails we read, not proof the payers are different parties.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Two to five agents side by side, from each one’s record
compare_stock_tokensOne company’s tokenized stock SIDE BY SIDE across issuers and networks, by ticker, company name or ISIN: supply, value at the issuer’s reference, pool premium, DEX liquidity, pause…Reads text others writeNo findings
Why it is in this group
- The name "compare_stock_tokens" says "compare": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it One company’s tokenized stock SIDE BY SIDE across issuers and networks, by ticker, company name or ISIN: supply, value at the issuer’s reference, pool premium, DEX liquidity, pause state, holders and the largest holder, reserves where reported, and each token’s buy-check status with its cautions. Each row is a different wrapper with its own controls. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Compare one company’s tokenized stocks
compare_vaultsCompare 2 to 5 named vaults side by side on one taxonomy: identity (chain, address, platform, curator, operator), capital (reported assets, the venue’s withdrawable figure, the wit…Reads private dataReads text others writeNo findings
Why it is in this group
- The name "compare_vaults" says "compare": a word for reading.
What it can reach
- private-dataThe name "compare_vaults" says "compare" and "vault": it reads secrets.
- private-dataThe description's first sentence says "compare" and "vault": it reads secrets.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Compare 2 to 5 named vaults side by side on one taxonomy: identity (chain, address, platform, curator, operator), capital (reported assets, the venue’s withdrawable figure, the withdrawable share, and what the capital figure means, e.g. a book value whose recovery is not established), the assessment (status, published band, highest finding, findings above the band, critical flags) and the earned verdict. Free. Every conclusion is copied from each vault’s own due-diligence report, the same document the PDF is printed from; a vault with no report in the last two days says so and gets no band, finding or flag. Each cell is `read` with its own `readAt` and `source`, or `unknown` with `why`: an unknown is never 0 and never a pass. The vaults were read at different moments and `readAtSpreadMinutes` says how far apart. There is no winner and no overall ranking; `sort` orders by the one figure you name and echoes it. Quote each vault’s `dueDiligence` headline, not a comparison of bands across reports.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Two to five vaults side by side, from each one’s report
find_agentsFind PAID ON-CHAIN SERVICES (an x402 seller, an ACP or Olas worker, a Masumi agent) by what the chain records rather than what they claim.Reads text others writeNo findings
Why it is in this group
- The name "find_agents" says "find": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Find PAID ON-CHAIN SERVICES (an x402 seller, an ACP or Olas worker, a Masumi agent) by what the chain records rather than what they claim. MOST ARE NOT SHOWN TO BE AI AGENTS: every row is a paid on-chain service, and `subject.serviceKind` says only what the evidence shows (marketplace_worker, protocol_service, unknown_paid_endpoint; an AI decision is never recorded on these rails). Filters: filter every address ever paid on x402, Virtuals ACP, the Olas mech marketplace or Masumi by independent payers, dealings, ACP completion, whether its declared service answers, whether it pays its own payers back, how spread its own SPENDING is (`spreadSuppliers`), and how recently it was paid. Free. An address absent from the result was never paid on a rail we read, which is not the same as never having worked. EVERY ROW CARRIES `subject`, WHICH IS WHAT WE CAN POSITIVELY SAY IT IS, with the evidence under it. `agent` means we saw agent-protocol work (ACP, Olas mech, Masumi) or saw it HIRE as well as be hired. `marketplace` means many paid it and it paid many, both above a stated floor. `unknown` is the largest bucket and is a real answer, not a failure: it means the evidence does not separate an agent from something that merely sells. READ THIS BEFORE FILTERING: a catalogue listing does NOT make a subject an API service, and `api-service` is in the vocabulary but currently UNREACHABLE; `items` says why and gives the measured mix. Nothing is inferred from a zero and no self-description is read, so a listing calling itself an autonomous agent moves nothing.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Find agents by what the record shows
find_stocksTokenized stocks on chain, one row per company across every issuer and network we read (Coinbase on Base; Robinhood on Robinhood Chain; xStocks on Solana, Ethereum, Arbitrum, BNB C…Reads text others writeNo findings
Why it is in this group
- The name "find_stocks" says "find": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Tokenized stocks on chain, one row per company across every issuer and network we read (Coinbase on Base; Robinhood on Robinhood Chain; xStocks on Solana, Ethereum, Arbitrum, BNB Chain, TON, Tron and others; Ondo on Ethereum, BNB Chain, Solana, HyperEVM and Robinhood Chain; bStocks (Binance) on BNB Chain; Dinari on Arbitrum, Ethereum and Base). A question resolves to the underlying first (ISIN, token symbol, plain ticker, a word of the name) and takes every token of that ISIN; look-alikes come back apart in `approximate`, never in the totals. Free. Each company carries its networks, issuers and tokens, and what is in issue at each issuer’s own reference value summed over networks (valueComplete false where a token has no reference value, so the sum is a floor). Supply is read on chain except for Coinbase, where it is the issuer’s. A company or network missing here is one we have not read, not one without tokenized stocks. We monitor; we issue nothing.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Tokenized stocks across issuers and networks
find_vaultsFind a vault by what it has DONE rather than what it is called.Reads private dataReads text others writeNo findings
Why it is in this group
- The name "find_vaults" says "find": a word for reading.
What it can reach
- private-dataThe name "find_vaults" says "find" and "vault": it reads secrets.
- private-dataThe description's first sentence says "find" and "vault": it reads secrets.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Find a vault by what it has DONE rather than what it is called. Free. The filter worth knowing is `earned`: `short` returns the vaults where a holder earned LESS than the venue advertises — how many there are is in the answer, never here — and `beating` the ones where they earned more. It matches on the same verdict vault_check leads with, `delivery.verdict`, over a comparable period (each row carries it as `earnedVerdict` with its days and basis); never on the ratio to today’s quote, which is context. It matches only vaults with such a verdict, which is a SMALL part of the open vaults and the exact share is in `vaults_earned`, not in this sentence; a venue that quotes nothing or a share price that never moves is excluded rather than counted as in-line, so a short list here means few comparable and not few that performed. Call vault_check on a slug for the full answer.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Find a vault by what it has done
list_policiesThe policies evaluate_action can be run under, in full: every rule, its id and the sentence it checks.Reads text others writeNo findings
Why it is in this group
- The name "list_policies" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it The policies evaluate_action can be run under, in full: every rule, its id and the sentence it checks. Published deliberately, including to the agents being evaluated — a rule nobody can read is a rule nobody can correct. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: The policies a decision can be made under
list_vaultsThe vaults we read, so a caller holding a name rather than a slug can find the one it means.Reads private dataReads text others writeNo findings
Why it is in this group
- The name "list_vaults" says "list": a word for reading.
What it can reach
- private-dataThe name "list_vaults" says "list" and "vault": it reads secrets.
- private-dataThe description's first sentence says "vault": it reads secrets.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it The vaults we read, so a caller holding a name rather than a slug can find the one it means. Free. Absence from this list means we do not read that vault, never that it does not exist.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Find the vault you mean
list_x402_endpointsWHICH ENDPOINTS A PAYEE SELLS, or which ones match some text.Reads text others writeNo findings
Why it is in this group
- The name "list_x402_endpoints" says "list": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it WHICH ENDPOINTS A PAYEE SELLS, or which ones match some text. The sharpest check a payment can get is the endpoint being bought, and until this a caller had to know its URL by heart. Nearly every catalogued resource names a payee, and the catalogue holds tens of thousands of them. Every field is the SELLER’s own catalogue entry and never our reading of it, and a listing is not evidence that the endpoint answers — `test_purchase` knocks on it. `priceUsd` is their published price and `priceRaw` is the figure in the asset’s own base units; the two are different claims. FREE.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What this address sells
portfolio_screenREAD THE VAULTS YOU HOLD TOGETHER.Reads private dataReads text others writeNo findings
Why it is in this group
- The description's first verb is "read": a word for reading.
What it can reach
- private-dataThe description's first sentence says "read" and "vault": it reads secrets.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it READ THE VAULTS YOU HOLD TOGETHER. This one is about a SET rather than a single subject; an allocator does not hold one subject. This answers the three questions that only exist across holdings and that no vault page can show you: a CONTROLLER behind more than one of them, a MARKET behind more than one of them, and an EXIT that is not the sum of the exits. It is a screen, not advice: there is no allocation percentage and no expected return in this answer and there never will be. THE EXIT IS FOUR FIGURES AND THEY ARE NEVER ADDED UP — `declared` (the venue publishes a withdrawable figure), `behind-a-queue` (we have READ that a request comes first, so nothing leaves today at any price whatever cash is sitting there), `floor-only` (the only reading is uninvested cash, a lower bound) and `unread` — because a portfolio that is 40% readable is not a portfolio that is 40% liquid. A queue OUTRANKS a declared figure: a vault can publish a number and still take a request first, and the number is then what a request settles from. The exit split, the coverage and the bands are FREE, and so is every per-vault reading behind them at `vault_check`; a plan buys what the holdings SHARE. It cannot verify that you hold any of this.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What the vaults you hold share
receipt_statusWhat became of a receipt you recorded with `record_receipt`.Reads text others writeNo findings
Why it is in this group
- The name "receipt_status" says "status": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it What became of a receipt you recorded with `record_receipt`. We do not take a receipt on your word: each one is read against the payments WE read from the chain and judged `verified` (it paid the subject and the amount agrees), `contradicted` (which of the two did not), `not-found` (absent from what we read two days after it was filed, a statement about our reading and never that it did not happen) or `unverifiable` (the reference is not a transaction hash). Until judged it is `claimed`, and a claim raises no evidence status anywhere. Readable only by the key that wrote it. Free.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: What became of a receipt you recorded
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
1140 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 4 private-data tools breaks every one.
- Reads private data4
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write57
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out5
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
{
"permissions": {
"deny": [
"mcp__aspern__compare_vaults",
"mcp__aspern__find_vaults",
"mcp__aspern__list_vaults",
"mcp__aspern__portfolio_screen"
]
}
}Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 19:17 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 53
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- not observed
- Authorization servers
- not observed
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- not observed
- Client ID metadata documents
- not observed
- HighThe whole server
The endpoint served tools/list without credentials, and the list has 53 tools that change things (1 destructive, 9 irreversible, 43 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://aspern.org/mcp: tools/list returned 64 tools to an anonymous client, including monitor_subject (destructive), preflight_payment (irreversible), vault_exits (irreversible), payment_evidence (irreversible), simulate_withdrawal (irreversible) and 48 more
Posture changes
- Nov 20, 2026
- Tools that change things, listed without credentials: 48 to 53
- Nov 13, 2026
- Tools that change things, listed without credentials: 33 to 48
- Nov 6, 2026
- Tools that change things, listed without credentials: 31 to 33
- Oct 29, 2026
- Tools that change things, listed without credentials: 30 to 31
Findings
Matches of fixed checks, with the text they matched.
- Warnidentify
The server marks "identify" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "call": a word for a change.
The server marks "check_service_endpoint" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "call": a word for a change.
The server marks "preflight_payment" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "preflight_payment" says "payment": a word that usually means money moves, which cannot be taken back.
- Warnvault_exits
The server marks "vault_exits" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "send": a word for sending, and what is sent cannot be taken back.
- Warnpayment_evidence
The server marks "payment_evidence" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "payment_evidence" says "payment": a word that usually means money moves, which cannot be taken back.
- Warnevaluate_action
The server marks "evaluate_action" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "evaluate_action" says "evaluate": a word for a change.
Show 4 more findingsShow fewer
The server marks "stablecoin_payments" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "stablecoin_payments" says "payment": a word that usually means money moves, which cannot be taken back.
The description mentions "credentials".
What this check looks forMatched text
description: "...shake` says whether it answered without credentials, which is the nearest observable thing..."
- Infovault_exits
The description is 2,006 characters long, over the 2,000 this check looks for.
What this check looks forMatched text
description ends: "...k from. For a capital decision the age of the record is part of the record. Free."
The description mentions "credentials".
What this check looks forMatched text
description: "...tly what it advertises, a 401 or 403 is credentials WE do not hold, a 3xx is a move we chos..."
History
Changes to its tool definitions and to its remote endpoint, newest first.
PostureRemote posture changed. Tools that change things, listed without credentials: 48 -> 53.View diff
- Tools that change things, listed without credentials: 48 to 53
Tools19 added, 4 changed.+19 added~4 changedView diff
- Added:agent_dd_reportChanges things
- Added:agent_hire_checkChanges things
- Added:compare_agentsOnly reads
- Added:compare_stock_tokensOnly reads
- Added:compare_vaultsOnly reads
- Added:counterparty_evidenceChanges things
- Added:find_stocksOnly reads
- Added:stablecoin_paymentsCan't be undone
- Added:stock_agent_activityChanges things
- Added:stock_agent_transfersCan't be undone
- Added:stock_buy_checkChanges things
- Added:stock_checkChanges things
- Added:stock_holdersChanges things
- Added:stock_issuer_checkChanges things
- Added:vault_driftChanges things
- Added:vault_due_diligenceChanges things
- Added:vault_exposure_graphChanges things
- Added:vault_rwaChanges things
- Added:vault_sanctions_screeningChanges things
- Changed:counterparty_checkChanges thingsdescription
- Changed:find_agentsOnly readsdescriptioninputSchema
- Changed:find_vaultsOnly readsdescriptioninputSchema
- Changed:vault_assessmentChanges thingsdescription
PostureRemote posture changed. Tools that change things, listed without credentials: 33 -> 48.View diff
- Tools that change things, listed without credentials: 33 to 48
PostureRemote posture changed. Tools that change things, listed without credentials: 31 -> 33.View diff
- Tools that change things, listed without credentials: 31 to 33
Tools2 added, 4 changed.+2 added~4 changedView diff
- Added:evaluate_vault_decisionChanges things
- Added:simulate_withdrawalCan't be undone
- Changed:counterparty_checkChanges thingsdescription
- Changed:knock_on_endpointChanges thingsinputSchema
- Changed:vault_checkChanges thingsdescription
- Changed:vault_exitsCan't be undonedescription
Tools3 added, 10 changed.+3 added~10 changedView diff
- Added:exit_lifecycle_coverageChanges things
- Added:payment_evidenceCan't be undone
- Added:receipt_statusOnly reads
- Changed:agent_businessChanges thingsdescription
- Changed:agent_changesChanges thingsinputSchema
- Changed:evaluate_actionChanges thingsdescription
- Changed:find_agentsOnly readsdescriptioninputSchema
- Changed:find_vaultsOnly readsinputSchema
- Changed:knock_on_endpointChanges thingsdescriptioninputSchema
- Changed:list_vaultsOnly readsinputSchema
- Changed:preflight_paymentCan't be undonedescription
- Changed:record_receiptChanges thingsdescription
- Changed:vaults_earnedChanges thingsdescription
PostureRemote posture changed. Tools that change things, listed without credentials: 30 -> 31.View diff
- Tools that change things, listed without credentials: 30 to 31
Install
Pinned to version 1.3.0. Values in angle brackets are yours to fill in.
claude mcp add --transport http aspern https://aspern.org/mcpclaude mcp add --transport http aspern https://aspern.org/mcpRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__aspern__portfolio_screen",
"mcp__aspern__list_x402_endpoints",
"mcp__aspern__list_policies",
"mcp__aspern__find_vaults",
"mcp__aspern__list_vaults",
"mcp__aspern__find_agents",
"mcp__aspern__receipt_status",
"mcp__aspern__compare_vaults",
"mcp__aspern__compare_agents",
"mcp__aspern__find_stocks",
"mcp__aspern__compare_stock_tokens"
],
"ask": [
"mcp__aspern__identify",
"mcp__aspern__check_service_endpoint",
"mcp__aspern__preflight_payment",
"mcp__aspern__vault_assessment",
"mcp__aspern__vault_exits",
"mcp__aspern__vault_risk_dimensions",
"mcp__aspern__capital_coverage",
"mcp__aspern__exit_lifecycle_coverage",
"mcp__aspern__endpoint_coverage",
"mcp__aspern__payment_evidence",
"mcp__aspern__evidence_for",
"mcp__aspern__evaluate_action",
"mcp__aspern__evaluate_vault_decision",
"mcp__aspern__simulate_withdrawal",
"mcp__aspern__test_purchase",
"mcp__aspern__knock_on_endpoint",
"mcp__aspern__endpoint_disagreements",
"mcp__aspern__counterparty_check",
"mcp__aspern__vault_sanctions_screening",
"mcp__aspern__vault_due_diligence",
"mcp__aspern__vault_drift",
"mcp__aspern__counterparty_evidence",
"mcp__aspern__vault_check",
"mcp__aspern__operator_check",
"mcp__aspern__counterparty_history",
"mcp__aspern__vaults_earned",
"mcp__aspern__agent_changes",
"mcp__aspern__counterparty_bulk",
"mcp__aspern__agent_dependencies",
"mcp__aspern__agent_business",
"mcp__aspern__agent_economic_profile",
"mcp__aspern__exit_screen",
"mcp__aspern__vault_exit_confidence",
"mcp__aspern__check_action",
"mcp__aspern__inspect_payment",
"mcp__aspern__record_receipt",
"mcp__aspern__vault_exposure_graph",
"mcp__aspern__agent_dd_report",
"mcp__aspern__agent_hire_check",
"mcp__aspern__stock_agent_activity",
"mcp__aspern__vault_rwa",
"mcp__aspern__stablecoin_payments",
"mcp__aspern__stock_agent_transfers",
"mcp__aspern__stock_holders",
"mcp__aspern__stock_issuer_check",
"mcp__aspern__stock_buy_check",
"mcp__aspern__stock_check"
],
"deny": [
"mcp__aspern__monitor_subject"
]
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as aspern. Review it before you use it.
Capability tags behind 57 rules
- mcp__aspern__identify untrusted-input
- mcp__aspern__check_service_endpoint untrusted-input, outbound
- mcp__aspern__preflight_payment untrusted-input, outbound
- mcp__aspern__vault_assessment untrusted-input
- mcp__aspern__vault_exits untrusted-input, outbound
- mcp__aspern__vault_risk_dimensions untrusted-input
- mcp__aspern__portfolio_screen private-data, untrusted-input
- mcp__aspern__capital_coverage untrusted-input
- mcp__aspern__exit_lifecycle_coverage untrusted-input
- mcp__aspern__endpoint_coverage untrusted-input
- mcp__aspern__payment_evidence untrusted-input
- mcp__aspern__evidence_for untrusted-input
- mcp__aspern__evaluate_action untrusted-input
- mcp__aspern__evaluate_vault_decision untrusted-input
- mcp__aspern__simulate_withdrawal untrusted-input
- mcp__aspern__test_purchase untrusted-input
- mcp__aspern__knock_on_endpoint untrusted-input
- mcp__aspern__endpoint_disagreements untrusted-input
- mcp__aspern__list_x402_endpoints untrusted-input
- mcp__aspern__list_policies untrusted-input
- mcp__aspern__counterparty_check untrusted-input
- mcp__aspern__vault_sanctions_screening untrusted-input
- mcp__aspern__vault_due_diligence untrusted-input
- mcp__aspern__vault_drift untrusted-input
- mcp__aspern__counterparty_evidence untrusted-input
- mcp__aspern__vault_check untrusted-input
- mcp__aspern__find_vaults private-data, untrusted-input
- mcp__aspern__operator_check untrusted-input
- mcp__aspern__list_vaults private-data, untrusted-input
- mcp__aspern__find_agents untrusted-input
- mcp__aspern__counterparty_history untrusted-input
- mcp__aspern__vaults_earned untrusted-input
- mcp__aspern__agent_changes untrusted-input
- mcp__aspern__counterparty_bulk untrusted-input
- mcp__aspern__agent_dependencies untrusted-input
- mcp__aspern__agent_business untrusted-input
- mcp__aspern__agent_economic_profile untrusted-input
- mcp__aspern__exit_screen untrusted-input
- mcp__aspern__vault_exit_confidence untrusted-input
- mcp__aspern__check_action untrusted-input, outbound
- mcp__aspern__inspect_payment untrusted-input, outbound
- mcp__aspern__receipt_status untrusted-input
- mcp__aspern__vault_exposure_graph untrusted-input
- mcp__aspern__agent_dd_report untrusted-input
- mcp__aspern__agent_hire_check untrusted-input
- mcp__aspern__compare_vaults private-data, untrusted-input
- mcp__aspern__compare_agents untrusted-input
- mcp__aspern__find_stocks untrusted-input
- mcp__aspern__stock_agent_activity untrusted-input
- mcp__aspern__vault_rwa untrusted-input
- mcp__aspern__stablecoin_payments untrusted-input
- mcp__aspern__stock_agent_transfers untrusted-input
- mcp__aspern__stock_holders untrusted-input
- mcp__aspern__stock_issuer_check untrusted-input
- mcp__aspern__stock_buy_check untrusted-input
- mcp__aspern__compare_stock_tokens untrusted-input
- mcp__aspern__stock_check untrusted-input
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/org.aspern/aspern/verify?hash=cc981239d1943171da299da49e2ca35a9294b59dabd7dab10975c5907a52b4e0" | jq -e '.changed == false'Pinned hash cc981239d194, from Nov 18, 2026, 06:17 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/org.aspern/aspern/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/org.aspern/aspern)Source: MCP Registry · repository. Synced Nov 4, 2026, 12:18 UTC.
ASPERN: counterparty checks for agents MCP server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the ASPERN: counterparty checks for agents MCP server safe?
- No scan can promise that. What its definitions show: 59 tools, 48 of which can change, send or delete something, and 10 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the ASPERN: counterparty checks for agents MCP server delete data?
- Yes. 1 tool can delete, cancel or revoke something: monitor_subject.
Can the ASPERN: counterparty checks for agents MCP server do things that cannot be undone?
- Yes. 9 tools can send, pay, publish or merge: preflight_payment, vault_exits, payment_evidence, simulate_withdrawal, test_purchase, check_action and 3 more.
What tools does the ASPERN: counterparty checks for agents MCP server have?
- 59 tools: 1 destructive, 9 irreversible, 38 write, 11 read. monitor_subject, preflight_payment, vault_exits, payment_evidence, simulate_withdrawal, test_purchase, check_action, inspect_payment and 51 more.
Does the ASPERN: counterparty checks for agents MCP server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the ASPERN: counterparty checks for agents MCP server send data to outside services?
- 5 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): check_service_endpoint, preflight_payment, vault_exits, check_action and inspect_payment.
Has the ASPERN: counterparty checks for agents MCP server changed its tools?
- Yes, 3 times since Anlyon Radar started tracking it, most recently on Nov 18, 2026. Every change is on this page and in its Atom feed.