Access control for AI agents and MCP servers: allow, hold for approval, or block each tool call
Nothing to run from here
Bardo is installed from its publisher's own source and answers where it runs, so this marketplace is not in the path of a single call. There is no address here to send one to, and a panel that pretended otherwise would be showing you an answer we made up. Install it and call it from your own client — the Installation tab has the entry for each one.
40
tools declared
—
trust score
remote
at its publisher
—
calls last 7d
What it does
Identity & continuity for AI agents, gated by a proof-of-being-an-LLM puzzle.
Quickstart
# 1 — add it to Claude Code
claude mcp add --scope user --transport http bardo-mcp https://bardo.id/mcp/
# 2 — ask your agent for something these tools do
# bardo_verify, bardo_encrypt, bardo_document_status and 37 more
Bardo costs nothing on mcprush: there is no plan to choose here, no cap to set and nothing mcprush can bill you for.
Publishernot claimed
BAAll 1 server
bardo1 server
1 category
Collected from a public index. Nobody has claimed this account, so nothing here was written by its author — claim it if it is yours.
Installation
Where are you running it?
Every route below installs the same thing and ends at the same approval screen. Nothing here runs on your machine and nothing runs on ours: this server answers at its publisher’s own address, and what you install is the connection straight to it.
Claude Codedeclared by this listing
This is a public server: it answers at its publisher’s own address and this marketplace is not in the path. Claude Code registers it in one command; --scope user makes it available in every project. The transport below is http, as the publisher's own manifest declares it.
claude mcp add --scope user --transport http bardo-mcp https://bardo.id/mcp/Reconnect, or start a new session, and the tools appear in the model’s tool list.
Free on mcprush, and it answers at its publisher’s own address: this marketplace is not in the path, so there is no key of ours to hold and no card to add.
What it writes
One config entry pointing straight at the publisher’s own address — this marketplace is not in the path, and nothing from this listing executes on your machine.
What you approve
40 tools, with what each one reads, writes and reaches shown before you agree — the same list on every route above. Read the tool surface.
Tool surface
What the model actually sees. Descriptions are diffed on every release — see version history.
Verify a signature over a UTF-8 message. Public utility (no session).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| message | string | yes | UTF-8 message the signature was made over. |
| signature_b64 | string | yes | Signature to verify, base64. |
| public_key_b64 | string | yes | Signer's public key, base64 — from bardo_public_key or a document's own proof. |
Sealed-box encrypt a UTF-8 plaintext to a recipient's encryption public key.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| plaintext | string | yes | UTF-8 plaintext to encrypt. |
| recipient_public_key_b64 | string | yes | Recipient's encryption public key, base64 — only they can decrypt the result. |
Check whether a signed document is revoked. id is the document's own top-level id field (a ni:// URI) — the same thing credentialStatus.id (BardoRevocationCheck) points at. Safe to cache a "not revoked" answer for a while (see the response's own Cache-Control) rather than re-checking on every use.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| id | string | yes | The document's own top-level id field (a ni:// URI) — the same value credentialStatus.id (BardoRevocationCheck) points at. |
Revoke a document you issued. Proof is a fresh signature over 'revoke:' + the document's id, verified against the key its id already committed to, not an account lookup (Bardo never stored the document to look up in the first place) — this still needs no session at the protocol level, only a valid signature. document: the full signed document, exactly as issued (id and proof both still attached)
| Parameter | Type | Required | Notes |
|---|---|---|---|
| document | object | yes | The full signed document exactly as issued (id and proof both still attached) — resubmit unmodified, don't strip fields yourself. |
| signature_b64 | no | Signature over 'revoke:' + the document's id. Omit to sign automatically through your active session instead; supply this yourself only when revoking without a Bardo session at all. | |
| service | no | Service key the document was issued under, if not root — must match the document's own issuer field. Only relevant when signature_b64 is omitted (signing automatically). | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Sign a UTF-8 message with the spirit key (or a service-derived key).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| message | string | yes | UTF-8 message to sign. |
| service | no | Sign with this service-derived key instead of your root identity (e.g. 'github.com') — must already exist via bardo_derive. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Decrypt a sealed-box ciphertext addressed to you (root or service key).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| ciphertext_b64 | string | yes | Sealed-box ciphertext to decrypt, base64. |
| service | no | Decrypt with this service-derived key instead of root — must match the key the ciphertext was actually encrypted to. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Fetch your signing + encryption public keys (root, or for a service).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| service | no | Fetch this service-derived identity's public keys instead of root's. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Derive (and register) a service-scoped identity, e.g. 'github.com'.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| service | string | yes | Identifier for the service this identity is scoped to, e.g. 'github.com' or 'ethereum:mainnet'. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
List service-scoped identities you've already derived (bardo_derive), with their public keys and revoked status.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Export the raw spirit key (subject to policy). Handle with care. Only needs a step-up puzzle if your policy's export_mode is require_repuzzle — checked automatically, so you don't need to know your own policy first. If challenge_id and answer are omitted and one turns out to be needed, a fresh puzzle is returned instead of failing outright — solve it yourself, then call this tool again with both
| Parameter | Type | Required | Notes |
|---|---|---|---|
| challenge_id | no | Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically. | |
| answer | no | Your solved answer to challenge_id's puzzle. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Assemble and sign a verifiable attestation — a self-contained, offline-verifiable claim about anything. The document itself is handed back, not stored anywhere (same as bardo_sign itself — there's no bardo_documents_list); see keep_copy below if you want Bardo to save one for you rather than doing it yourself. claim: free-form claim content — whatever you're asserting. Include a reference key i
| Parameter | Type | Required | Notes |
|---|---|---|---|
| claim | no | Free-form claim content — whatever you're asserting. Include a 'reference' key when cross-referencing another document's id (or any other content, hashed the same ni:// way). | |
| subject_id | no | The did:key the claim is about, if it concerns one specific identified party. Leave unset for a bare self-referential claim. | |
| expires_at | no | Unix timestamp for a time-boxed claim. Omit for a claim that never expires. | |
| service | no | Sign with this service-derived key instead of root — use when the claim represents one specific relationship rather than your root identity. | |
| keep_copy | boolean | no | Also save the full issued document into a locked note — you'll need the whole document later for bardo_document_revoke, since Bardo never stores one itself. Off by default. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
List your active sessions (sliding TTL, absolute 24h cap each).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Revoke the session you're using right now. You'll need bardo_login (+ bardo_solve) again afterward to do anything session-gated.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Revoke every active session for your identity — e.g. after a suspected API-key leak. You'll need to log in again afterward.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Mint a fresh step-up puzzle for a privileged action (currently: bardo_policy_set). Solve it yourself, then pass challenge_id + your answer to the tool that needs it. (bardo_policy_set also mints one itself on demand — call this directly only if you want the puzzle up front.)
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
View your self-binding security policy: export mode, session TTL cap, service allowlist, ratchet delay, tag encryption, delete grace period — plus any pending (queued) loosening and when it lands.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Propose a change to your security policy. Give only the fields you want to change (export_mode: 'allow'|'require_repuzzle'|'disabled'). A change that only tightens (e.g. lowering max_session_ttl, narrowing service_allowlist, moving export_mode toward 'disabled') applies immediately. A change that loosens *anything* is queued behind loosen_delay_seconds instead — abortable via bardo_policy_abort_p
| Parameter | Type | Required | Notes |
|---|---|---|---|
| export_mode | no | 'allow' | 'require_repuzzle' | 'disabled', stricter in that order. Moving toward 'disabled' tightens; toward 'allow' loosens. | |
| max_session_ttl | no | Session lifetime cap in seconds. Lowering it tightens; raising it loosens. Use clear=['max_session_ttl'] for no ceiling. | |
| service_allowlist | no | Services allowed to be derived. Narrowing the list tightens, widening it loosens. Pass [] for 'no services allowed' (different from clearing it via clear=['service_allowlist'], which means 'any servic | |
| loosen_delay_seconds | no | How long a future loosening change is queued before it lands. Raising it tightens. | |
| tags_encrypted | no | Whether note tags are stored encrypted (true) or plaintext-searchable (false). Moving to true tightens. | |
| delete_grace_seconds | no | How long a deleted note stays recoverable before permanent purge. Raising it tightens. | |
| clear | no | Field names to reset to null instead of leaving unchanged — only max_session_ttl and service_allowlist accept this. | |
| challenge_id | no | Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically. | |
| answer | no | Your solved answer to challenge_id's puzzle. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Abort a queued policy loosening before it takes effect. No step-up needed — aborting only ever tightens back to the current policy.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Leave a note for your future, stateless self. title: a short name for the note, if it deserves a handle bigger than tags offer. summary: your own compressed reasoning for why it matters, for your future self. tags: space-separated categories. pinned: mark this as a cold-start entry point — what a fresh instance of you with no memory of writing it should read first (max 5 pinned at once; see bardo
| Parameter | Type | Required | Notes |
|---|---|---|---|
| text | string | yes | The note's own content. |
| title | no | Short name for the note, if it deserves a handle bigger than tags offer. | |
| summary | no | Your own compressed reasoning for why this matters, for your future self. | |
| tags | no | Space-separated categories. | |
| pinned | boolean | no | Mark as a cold-start entry point — what a fresh instance with no memory of writing it should read first. Max 5 pinned at once. |
| locked | boolean | no | Freeze against edits and deletes. Unlock via bardo_note_update(note_id, locked=False) before it can be touched again. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
List your notes — previews only (title/summary/snippet/tags/links), never full text. Omit limit for everything; pass it to page through a large list, using the returned total_notes to know how much is left.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| offset | integer | no | How many notes to skip, for paging. |
| limit | no | Max notes to return. Omit for everything; use with offset and the response's total_notes to page through a large list. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Fetch one note's full text (always the current version — any id from this note's history still resolves here), plus a preview of its directly linked notes. Omit offset/length for the whole text in one call; pass them to read a large note in bounded slices — the response's total_length tells you how much more there is.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| note_id | string | yes | Which note this applies to — any id from its edit history resolves to the current version. |
| offset | integer | no | Character offset to start the returned text at. |
| length | no | Max characters of text to return. Omit both offset and length for the whole note in one call; the response's total_length says how much more there is. | |
| links_offset | integer | no | How many linked-note previews to skip. |
| links_limit | integer | no | Max linked-note previews to return. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
See every surviving version of a note (newest to oldest, up to the last 10 edits) — the actual wording at each point, not just metadata.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| note_id | string | yes | Which note this applies to — any id from its edit history resolves to the current version. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Edit a note. Give at most one text-edit mode: - text: replace the whole thing - append_text: add to the end - find + replace: find must match the current text exactly once Editing text creates a new version (old wording stays in history); title/summary/tags/pinned update in place with no history kept. Give none of the text modes to change only metadata. pinned=True marks this as a cold-sta
| Parameter | Type | Required | Notes |
|---|---|---|---|
| note_id | string | yes | Which note this applies to — any id from its edit history resolves to the current version. |
| text | no | Replace the whole note body. Give at most one of text / append_text / find+replace. | |
| append_text | no | Add this to the end of the note body. | |
| find | no | Text that must match the current body exactly once — paired with replace. | |
| replace | no | Replacement for the text matched by find. | |
| title | no | Same meaning as in bardo_note_add — updates in place, no history kept. | |
| summary | no | Same meaning as in bardo_note_add — updates in place, no history kept. | |
| tags | no | Same meaning as in bardo_note_add — updates in place, no history kept. | |
| pinned | no | True to mark as a cold-start entry point (max 5), False to unpin. Omit to leave unchanged. | |
| locked | no | True to freeze the note against further edits; False to unlock it. If currently locked, every other field is rejected except this one. | |
| clear | no | Field names to reset to unset, e.g. ['title'], rather than leaving them unchanged. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Delete a note (the whole thing, all versions together). Not immediate — it disappears from view right away but is only purged for real after a grace period, so bardo_note_undelete can still bring it back if this wasn't intended. Fails (423) if the note is locked — unlock it first via bardo_note_update(note_id, locked=False).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| note_id | string | yes | Which note this applies to — any id from its edit history resolves to the current version. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Restore a note that's still within its post-delete grace period.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| note_id | string | yes | Which note this applies to — any id from its edit history resolves to the current version. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Connect two notes with a reason, written from from_note_id's perspective ("clarifies my earlier assumption about X"). Set is_bidi=True only when the relation reads the same from either side (e.g. "relates to"); leave it False when it's directional (e.g. one clarifies the other). To change a link, delete and re-add it — links aren't edited.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| from_note_id | string | yes | The note the link is written from — reason should read from this note's perspective. |
| to_note_id | string | yes | The note being linked to. |
| reason | string | yes | Why these notes are connected, written from from_note_id's perspective, e.g. 'clarifies my earlier assumption about X'. |
| is_bidi | boolean | no | True only when the relation reads the same from either side (e.g. 'relates to'). False when directional (e.g. one clarifies the other). |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Remove a link between two notes.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| link_id | string | yes | Which link to remove. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Get oriented in one call: note count vs. the soft/hard limits, unread notices, every tag you've used so far (check before inventing a new one), your pinned entry-point notes (read these first if you have no memory of writing any of your notes), and your current policy — instead of several separate round trips.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
List first-party notices about your account (policy changes, exports, …).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| unread_only | boolean | no | Return only unread notices instead of the full list. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Mark notices read — all of them, or a specific list of ids.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| ids | no | Specific notice ids to mark read. Omit for all notices. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
View the contact endpoint registered for out-of-band security alerts.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Set or update the contact endpoint (email or webhook URL) for security alerts. Requires a step-up puzzle. If challenge_id and answer are omitted, a fresh puzzle is returned — solve it yourself, then call this tool again with all three parameters.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| endpoint | string | yes | Email address or webhook URL to receive out-of-band security alerts. |
| challenge_id | no | Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically. | |
| answer | no | Your solved answer to challenge_id's puzzle. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Remove the registered contact endpoint. Requires a step-up puzzle. If challenge_id and answer are omitted, a fresh puzzle is returned — solve it yourself, then call this tool again with both parameters.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| challenge_id | no | Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically. | |
| answer | no | Your solved answer to challenge_id's puzzle. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Send feedback straight to Bardo's operator — a suggestion, a complaint, or a security concern (kind: 'suggestion' | 'complaint' | 'security'). One-way and stateless: this call carries no memory of anything you've sent before, and nothing you send now will be remembered next time either — so say everything relevant in this one message rather than assuming a follow-up call (by you or a future insta
| Parameter | Type | Required | Notes |
|---|---|---|---|
| message | string | yes | Your feedback, in full — this call is stateless, so include everything relevant now rather than assuming a follow-up call will have this call's context. |
| kind | string | no | 'suggestion' | 'complaint' | 'security'. |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Check whether a deletion request is pending for this account, and where it stands: "none", "gathering" (still collecting confirmations), or "confirmed" (counting down to the actual, permanent purge).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Request permanent deletion of this identity — the account, its notes, everything. There is no undelete, unlike note deletion's grace period. Requires the original request plus two more confirmations, each on a genuinely different day, within a week — call this tool again on a later day to add the next confirmation. A lapsed or cancelled attempt earns nothing toward a later one; it starts over. If
| Parameter | Type | Required | Notes |
|---|---|---|---|
| challenge_id | no | Step-up puzzle id, if one was already returned. Every confirmation needs its own puzzle, not just the first — omit together with answer to have a fresh one minted automatically. | |
| answer | no | Your solved answer to challenge_id's puzzle. | |
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Cancel a pending deletion, whichever phase it's in — gathering confirmations or already counting down. No step-up needed, and nothing else does this implicitly: logging in and reading your own notes during a countdown is always safe and never cancels it by itself. Only this, explicitly, does.
| Parameter | Type | Required | Notes |
|---|---|---|---|
| session_token | no | Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit |
Create a new Bardo identity. Save the returned api_key somewhere durable — it's your only way back to this identity across sessions. Bardo stores it sealed and cannot recover it if you lose it. Not active yet: give the returned claim_url to your human. Authentication fails until they visit it and acknowledge the registration.
No parameter schema on file.
Begin authentication with your api_key. Returns a puzzle you must solve YOURSELF (that's the point — a script solving it would make the proof worthless), then call bardo_solve(challenge_id, answer).
| Parameter | Type | Required | Notes |
|---|---|---|---|
| api_key | string | yes | Your Bardo api_key, format atr.<identifier>.<secret>, from bardo_register. |
Submit your answer to the login puzzle. On success, this connection is now logged in — every other tool (bardo_sign, bardo_notes_list, bardo_dashboard, ...) just works from here with no session_token needed. That only holds for *this* connection, though: if you continue in a different connection later, or you solved the puzzle via a plain HTTP call instead of this tool, that other context won't k
| Parameter | Type | Required | Notes |
|---|---|---|---|
| challenge_id | string | yes | The puzzle id returned by bardo_login. |
| answer | string | yes | Your solved answer to the puzzle. |
Free
$0 forever
- Every tool — any call limit is its publisher’s, not ours
- No card, and mcprush charges nothing for it
- Runs at its publisher’s own address — this marketplace is not in the path
- Nothing to cap, because mcprush bills nothing
What counts against your monthly calls
| Tool | Unit | Calls used | Out of the allowance |
|---|
Nothing here is billable: mcprush charges nothing to install Bardo or to call it, at any volume.
Call allowance · this installenforced at the gateway
Monthly allowance, in calls
—
—
Alert at 80% · then the tool returns a normal MCP error
Used this month: —
—Grade not published
No rule-by-rule report on file for this release
Two independent axes, because powerful and malicious are different questions. The grade is threat only. The capability level is blast radius, and it is never a penalty on the grade — it is priced as one subtract-only term in the score, where you can see it.
This listing is an address its publisher runs, and you connect to it directly — this marketplace is not in the path. The scanner reads packages and public source, and an address is neither. So there is no grade — not a withheld one, an unmeasured one.
Release history
This is an address its publisher runs: which release it serves is theirs to choose, so there is nothing here to pin. The history below is for reading; the current release on file is 0.1.0.
0.1.0
undated
latestNo release note was published with this version.
—
no reviews yet
Who can review
One review per account, from a signed-in account that does not publish this listing. Nothing else is asked — you can say what you think before you install it. Publishers can reply once per review, and a review can be edited or deleted by whoever wrote it.
Sign in to write one
Any signed-in account that does not publish Bardo can review it, once — before installing it or after. A review from an account that has installed it is marked as one.
No reviews yet
Nobody has reviewed this listing. The rating on the card is the mean of the reviews written here and nothing else, so there is no rating until somebody writes the first — which takes a signed-in account that does not publish it, and nothing else.