Connect Bardo and your agent gets 40 tools, among them bardo_account_deletion_cancel, bardo_account_deletion_request, bardo_account_deletion_status. It answers at https://bardo.id/mcp/ over streamable HTTP, and it listed its tools to an anonymous client, so no sign-in was needed for that. Our probes reached it 9 of 10 times since 5 September 2026; the last check, on 18 October 2026, succeeded.
Identity & continuity for AI agents, gated by a proof-of-being-an-LLM puzzle.
Description as the publisher wrote it.
| Tool | What it does |
|---|---|
bardo_account_deletion_cancel | 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 nev Inputs: session_token |
bardo_account_deletion_request | 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, withi Inputs: challenge_id, answer, session_token |
bardo_account_deletion_status | 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). Inputs: session_token |
bardo_attestation_issue | 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 bel Inputs: claim, subject_id, expires_at, service, keep_copy, session_token |
bardo_contact_delete | 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. Inputs: challenge_id, answer, session_token |
bardo_contact_get | View the contact endpoint registered for out-of-band security alerts. Inputs: session_token |
bardo_contact_set | 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 param Inputs: endpoint, challenge_id, answer, session_token |
bardo_dashboard | 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 not Inputs: session_token |
bardo_decrypt | Decrypt a sealed-box ciphertext addressed to you (root or service key). Inputs: ciphertext_b64, service, session_token |
bardo_derive | Derive (and register) a service-scoped identity, e.g. 'github.com'. Inputs: service, session_token |
bardo_document_revoke | 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 Inputs: document, signature_b64, service, session_token |
bardo_document_status | 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 respo Inputs: id |
bardo_encrypt | Sealed-box encrypt a UTF-8 plaintext to a recipient's encryption public key. Inputs: plaintext, recipient_public_key_b64 |
bardo_export | 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 answ Inputs: challenge_id, answer, session_token |
bardo_feedback | 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 yo Inputs: message, kind, session_token |
bardo_link_add | 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 dire Inputs: from_note_id, to_note_id, reason, is_bidi, session_token |
bardo_link_delete | Remove a link between two notes. Inputs: link_id, session_token |
bardo_login | 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). Inputs: api_key |
bardo_note_add | 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 categorie Inputs: text, title, summary, tags, pinned, locked |
bardo_note_delete | 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) Inputs: note_id, session_token |
bardo_note_get | 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 Inputs: note_id, offset, length, links_offset, links_limit, session_token |
bardo_note_history | 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. Inputs: note_id, session_token |
bardo_note_undelete | Restore a note that's still within its post-delete grace period. Inputs: note_id, session_token |
bardo_note_update | 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); t Inputs: note_id, text, append_text, find, replace, title |
bardo_notes_list | 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. Inputs: offset, limit, session_token |
bardo_notices | List first-party notices about your account (policy changes, exports, …). Inputs: unread_only, session_token |
bardo_notices_ack | Mark notices read — all of them, or a specific list of ids. Inputs: ids, session_token |
bardo_policy_abort_pending | Abort a queued policy loosening before it takes effect. No step-up needed — aborting only ever tightens back to the current policy. Inputs: session_token |
bardo_policy_get | 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. Inputs: session_token |
bardo_policy_set | 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_m Inputs: export_mode, max_session_ttl, service_allowlist, loosen_delay_seconds, tags_encrypted, delete_grace_seconds |
bardo_public_key | Fetch your signing + encryption public keys (root, or for a service). Inputs: service, session_token |
bardo_register | 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 |
bardo_services_list | List service-scoped identities you've already derived (bardo_derive), with their public keys and revoked status. Inputs: session_token |
bardo_session_revoke_current | Revoke the session you're using right now. You'll need bardo_login (+ bardo_solve) again afterward to do anything session-gated. Inputs: session_token |
bardo_sessions_list | List your active sessions (sliding TTL, absolute 24h cap each). Inputs: session_token |
bardo_sessions_revoke_all | Revoke every active session for your identity — e.g. after a suspected API-key leak. You'll need to log in again afterward. Inputs: session_token |
bardo_sign | Sign a UTF-8 message with the spirit key (or a service-derived key). Inputs: message, service, session_token |
bardo_solve | 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* conne Inputs: challenge_id, answer |
bardo_stepup | 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 onl Inputs: session_token |
bardo_verify | Verify a signature over a UTF-8 message. Public utility (no session). Inputs: message, signature_b64, public_key_b64 |
Every block below points at https://bardo.id/mcp/. Pick your client and copy.
claude mcp add --transport http bardo https://bardo.id/mcp/
{
"mcpServers": {
"bardo": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://bardo.id/mcp/"]
}
}
}{
"mcpServers": {
"bardo": {
"url": "https://bardo.id/mcp/"
}
}
}{
"servers": {
"bardo": {
"type": "http",
"url": "https://bardo.id/mcp/"
}
}
}{
"context_servers": {
"bardo": {
"url": "https://bardo.id/mcp/"
}
}
}{
"mcpServers": {
"bardo": {
"serverUrl": "https://bardo.id/mcp/"
}
}
}{
"mcpServers": {
"bardo": {
"url": "https://bardo.id/mcp/"
}
}
}name: Bardo
version: 0.0.1
schema: v1
mcpServers:
- name: Bardo
type: streamable-http
url: https://bardo.id/mcp/{
"mcpServers": {
"bardo": {
"httpUrl": "https://bardo.id/mcp/"
}
}
}{
"mcpServers": {
"bardo": {
"type": "http",
"url": "https://bardo.id/mcp/"
}
}
}{
"mcpServers": {
"bardo": {
"url": "https://bardo.id/mcp/"
}
}
}goose://extension?url=https%3A%2F%2Fbardo.id%2Fmcp%2F&type=streamable_http&id=bardo&name=Bardo
It answered our last check on 18 October 2026 in 268 ms. Over 10 checks since 5 September 2026 it answered 9. Status here comes from Neuronto's own probes, not from the publisher.
Yes. It is published by bardo.id and served from bardo.id, the vendor's own domain: https://bardo.id/mcp/.
40, as returned by the server's own tools/list on 31 August 2026: bardo_account_deletion_cancel, bardo_account_deletion_request, bardo_account_deletion_status, bardo_attestation_issue, bardo_contact_delete, bardo_contact_get, bardo_contact_set, bardo_dashboard, and 32 more.
It answered our last check on 18 October 2026 in 268 ms. Over 10 checks since 5 September 2026 it answered 9.
Put the server under mcpServers in ~/.cursor/mcp.json with the URL https://bardo.id/mcp/. The exact JSON is above, with the same setup for Claude Code, Claude Desktop, VS Code, Windsurf, Zed, Gemini CLI and the rest.
It listed its tools to an anonymous client, so reading the tool list needs no key. Individual tools can still ask for credentials in their own inputs.
Publisher: id.bardo. Endpoint host: bardo.id. ARD identifier: urn:air:id.bardo:mcp:bardo.
First indexed 31 August 2026. The tools are exactly what the server returned; nothing on this page
is inferred from its name. Ranking in Neuronto search is never for sale.