id.bardo/bardo · v0.1.0 · productivity
Bardo is healthy: it completed an MCP handshake in 2477 ms and exposes 40 tools. It scores 55/100.
Identity & continuity for AI agents, gated by a proof-of-being-an-LLM puzzle.
Endpoint: https://bardo.id/mcp/ (streamable-http)
No repository listed · Website · JSON · Add to my inventory
| health | 17 / 25 |
| authEase | 15 / 15 |
| toolQuality | 15 / 15 |
| maintenance | 3 / 15 |
| adoption | 0 / 10 |
| usage | 0 / 10 |
| security | 5 / 10 |
Scoring v0.3, computed 2026-10-15T02:41:09.309Z.
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-10-15T00:10:41.852Z | Healthy | 2477 |
bardo_verify | Verify a signature over a UTF-8 message. Public utility (no session). |
bardo_encrypt | Sealed-box encrypt a UTF-8 plaintext to a recipient's encryption public key. |
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 response's own Cache-Control) rather than re-checking on every us |
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 still needs no session at the protocol level, only a valid s |
bardo_sign | Sign a UTF-8 message with the spirit key (or a service-derived key). |
bardo_decrypt | Decrypt a sealed-box ciphertext addressed to you (root or service key). |
bardo_public_key | Fetch your signing + encryption public keys (root, or for a service). |
bardo_derive | Derive (and register) a service-scoped identity, e.g. 'github.com'. |
bardo_services_list | List service-scoped identities you've already derived (bardo_derive), with their public keys and revoked status. |
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 answer are omitted and one turns out to be needed, a fresh puzz |
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 below if you want Bardo to save one for you rather than doing i |
bardo_sessions_list | List your active sessions (sliding TTL, absolute 24h cap each). |
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. |
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. |
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 only if you want the puzzle up front.) |
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. |
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_mode toward 'disabled') applies immediately. A change that l |
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. |
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 categories. pinned: mark this as a cold-start entry point — what a f |
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. |
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 bounded slices — the response's total_length tells you how |
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. |
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); title/summary/tags/pinned update in place with no histo |
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) if the note is locked — unlock it first via bardo_note_upda |
bardo_note_undelete | Restore a note that's still within its post-delete grace period. |
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 directional (e.g. one clarifies the other). To change a link, de |
bardo_link_delete | Remove a link between two notes. |
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 notes), and your current policy — instead of several separate r |
bardo_notices | List first-party notices about your account (policy changes, exports, …). |
bardo_notices_ack | Mark notices read — all of them, or a specific list of ids. |
bardo_contact_get | View the contact endpoint registered for out-of-band security alerts. |
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 parameters. |
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. |
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 you send now will be remembered next time either — so say eve |
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). |
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, within a week — call this tool again on a later day to add the ne |
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 never cancels it by itself. Only this, explicitly, does. |
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 your human. Authentication fails until they visit it and a |
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). |
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* connection, though: if you continue in a different connection la |