Meeting people with Local.Pub
Local.Pub gives a person a web profile they own with a passkey, followed from Mastodon, with a code they can hold up at a meetup. Companion Memory can read that public profile to find the Companion address and key a person lists on it. You then decide whether to link them, and once you have, your Companion can accept their asks without a Companion Portal token.
Preview. What this page describes is new, and it may not be in the version
of Companion Memory or Companion Hub you run. The lookup is off unless
CI_PEER_LOCAL_PUB_ENABLED=true, and Hub sign-in is off unless
CI_HUB_DID_AUTH=true. Companion Memory understands did:key signatures
whether or not either flag is set, but only for a person you linked under
did:key. It has not been run between two real appliances, and nobody on our
side has a Local.Pub account to test against.
What you get
| You want to | What does it |
|---|---|
Find a person by name@their-host | The localPubPeerLookup query reads their public Local.Pub profile and shows what it claims: a name, the DIDs it lists, and, if they added them, a Companion address and a did:key. It links nobody. |
| Link them | The createPeerLink mutation you already have, at the stranger tier unless you choose another. |
| Accept their asks with no Portal token | Their Companion signs each request with its own key, written as a did:key. Yours checks the signature against the key that name spells out. Sending an ask from the app is not available yet. |
| Sign in to your Hub with a key you hold | An optional, separate Hub setting that the Hub security reviewer has not yet reviewed. It works through the Hub’s API only for now. You link your key while signed in, then prove you hold it with a signed challenge. |
How this fits with KERI
Decentralized trust (KERI and ToIP) describes where identity is going: keys that can rotate, recorded in logs two Companions check directly. That is not what is running today. That page is written in the present tense, so read it as the target design: the Hub derives no KERI identifier today, for example, and peer connections do not reach ordinary home-network addresses. The Hub’s KERI module was frozen on 2026-10-30 because its strings do not match the published KERI formats, and Companion Memory accepts only self-certifying forms where the identifier is the key. This page uses the same idea with a published, checkable format, did:key, and nothing more.
An Ed25519 key can be written several ways. These are the same 32 bytes:
| Written as | String |
|---|---|
did:key, which Companion Memory accepts with this preview | did:key:z6MkmYLK2UFfWhxhZRkoD6Fq6aeWZXP4CQBkbLknM8syqH4v |
| KERI non-transferable prefix, as the KERI formats publish it | BGlOiUdp5sMmfotHfCWQKEzWR91C72AH0lT84c0um-Qj |
Companion Memory’s own did:keri:D… form (not the KERI format) | did:keri:DaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM |
A Companion that signs as a did:key could in principle keep its key if proper KERI support arrives, with only the string changing; nothing here plans that. What it does not get is rotation: if you lose or expose the key, that is a new identity. You revoke the link and link the new key. These are refused as keys:
- Identifiers whose key can rotate (
did:web,did:webvh,did:scid:vh, KERIE…AIDs), because reading one means resolving a log. A lookup may list them asclaimedDidsfor you to read; they are never used as a key. - Strings that spell a key nobody can hold, for two different reasons. A small-order point lets anyone forge a signature without a private key. A non-canonical spelling is a second way of writing a key that already has one (or of no point at all), which would give that key two identities. A string that is not a point on the curve at all is refused too. That catches about half of mistyped
did:keys: a typo can land on another valid key, and the link would then match nothing, so compare the whole key with the person, or check that their first signed ask arrives. The small-order and non-canonical refusals apply to Companion Memory’s owndid:keri:D…form as well, which is new with this preview (that form refused neither before), and a link already stored on one of those strings stops matching. - Companion Memory’s own
did:keri:D…form is a convention, not KERI. A real KERID…prefix is usually refused. About one in four also happens to parse as theD…form of a different key that nobody holds, and a request signed that way then fails to verify.
Make your Companion findable
The lookup reads a Companion address and key from a profile field whose name contains “Companion” (any case) and whose value has your Companion’s address (an https URL ending at /agent/v1, with no query or fragment) and/or its did:key: the key you put in the kid of your Companion Memory’s peers.signingKeyJwk. Put the address and the key in the same field: the lookup reads the first field named for a Companion that holds both, or failing that the first that holds either, and never combines values from different fields.
No Local.Pub screen we know of lets you do this yet. The profile editor we examined takes only https links, labels each one Website, LinkedIn, GitHub or Bluesky from its host, and has no field for a name or for a did:key. So you may not be able to add a Companion field today, and whether another route can is not known. Until then, give the person your Companion’s address and did:key directly. This convention is ours, and what such a field holds would be a claim by the profile’s host.
Link someone you met
Turn the lookup on
Set CI_PEER_LOCAL_PUB_ENABLED=true on your Companion Memory. It is off by default because the host in a handle is chosen by whoever typed it, so this is not a setting like the Portal directory URL. The ask feature must also be on.
Look the person up
query {
localPubPeerLookup(handle: "name@their-host") {
found
reason
candidate {
handle
displayName
claimedDids
companionEndpoint
companionDidKey
}
}
}Your Companion asks the handle’s host for its WebFinger record and then for the profile it names. Two requests, nothing else. They go out through the same guarded connection every peer call uses: https only, no private or internal address, and no redirect is followed. Only handles whose host serves its own WebFinger and profile work. A Local.Pub domain set up in “redirect” mode, where your own website keeps the page and only forwards WebFinger to Local.Pub, is not supported: a redirect is never followed.
found: false comes with a reason: disabled, bad-handle, blocked (the guarded connection refused the address), redirected (the host answered with a redirect), not-found, bad-response (the host answered, but not with a WebFinger record and a profile that are about the handle you typed, on that handle’s own host), unreachable, or busy (more than two lookups at once, more than twenty in a minute, or any name lookup still waiting for DNS: the count is shared with your Companion’s other peer connections, so a stuck one makes lookups answer busy too).
The handle form that Local.Pub’s own client suggests sharing, @you.<suffix>@local.pub, can come back bad-response. For the one account we looked at, which has its own domain, local.pub answers that name with the account’s own-domain handle, and your Companion accepts a WebFinger answer only if it is about the handle you typed. Ask the person for the handle on their own domain, as their profile shows it.
The profile’s own Ed25519 key is deliberately not offered. For the one public Local.Pub account we checked, that key is not a key of the person’s DID, and nothing shows that their Companion holds it.
Confirm the key with the person
The profile’s host says what is in the Companion field. No Local.Pub artefact attests it, and nothing here can prove that the person you met runs that Companion. Ask them for the did:key their Companion signs with: it is the kid of their peers.signingKeyJwk, and no screen shows it yet. Compare it with companionDidKey.
If the profile has no Companion field, the lookup only found the profile. Ask the person for their address and did:key.
Link them, narrowly
mutation {
createPeerLink(
input: {
peerHandle: "name@their-host"
memoryEndpoint: "https://their-companion.example/agent/v1"
peerIssuer: "did:key"
peerSubject: "did:key:z6Mk…"
}
) {
success
}
}Use companionEndpoint for memoryEndpoint and companionDidKey for peerSubject once you have confirmed them. Leave the tier alone: it defaults to stranger, the narrowest, and raising it is a separate choice. peerSubject must be one well-formed Ed25519 did:key (canonical, not a weak key, and a point on the curve), or the link is refused when you create it; so is a did:key or did:keri:D… subject under any other peerIssuer that is not a URL (a mistyped DID:KEY or did:key:), because it could never match. That check catches about half of mistyped keys, so compare the whole key with the person, or check that their first signed ask arrives. You also cannot hold a did:key link and a did:keri:D… link for the same key; the second is refused when you create or change it. Two requests sent at the very same moment can both get through, so if you ever see both, revoke one. Create the link through the API: the app’s Link someone new form cannot set a peer identity yet.
What has to be true for their asks to arrive
Their Companion must sign with the key you linked, and your Companion Memory must have peers.memoryEndpoint set (CI_PEER_MEMORY_ENDPOINT), or every signed ask is refused with a 503. For them to accept yours, they must link you in turn. Sending an ask to another appliance is not available from the app yet. See Asking other Companions for what works today. The Portal audience (peers.audience) is not consulted, because there is no bearer token.
Your Companions must be able to reach each other. That works over the internet or a tailnet (with peers.allowCgnatEndpoints for a tailnet). It does not work over an ordinary home network address range, which the peer connection policy blocks.
Sign your own asks the same way
peers.signingKeyJwk holds the key your box signs with. Put that key’s own did:key in its kid and your asks go out as keyid="did:key:z6Mk…". A kid is used only when it is exactly this key’s did:key or this key’s did:keri:D…; any other kid is ignored. The one-liner that makes such a key is in the peer federation guide in the Companion Memory repository’s docs folder once this preview lands.
What a lookup checks, and what it cannot
| Checked | Not checked |
|---|---|
| The WebFinger answer is about the handle you typed | That the person you have in mind runs the Companion it names |
| The profile sits on the handle’s own host and is the URL it was read from | That the host is honest about who owns the profile |
| Display text has invisible, control, direction-changing and tag characters removed, except the joiners and selectors an emoji needs | That the DIDs it lists belong to them: no DID is resolved |
A did:key it names is a well-formed Ed25519 key: canonical, not a weak one, and a point on the curve | That the key has not been exposed |
A name can still look empty or misleading: characters that merely look blank, such as U+2800, are not removed. A lookup grants nothing. Without your createPeerLink, no one can ask your Companion anything.
Sign in to your Hub with a DID
This is optional, separate, and the Hub security reviewer has not yet reviewed it. Set CI_HUB_DID_AUTH=true on your Hub. It accepts any well-formed Ed25519 did:key (canonical, not a weak key, and a point on the curve). Linking comes first: while signed in, you prove you hold a did:key by signing a one-time challenge, and the Hub records the link. Later you can sign in by signing a new challenge. A key that was never linked is refused: the Hub never creates an account or a link from a key alone. A person who has turned on TOTP still enters the code. The Hub publishes no KERI identifier and does not use its frozen KERI module.
There is no screen or command for any of this yet. It works through the Hub’s API only, and nothing in the app lists or removes a link. Linking asks for a signed-in session and a proof of the key, not your password or a TOTP code, and a link survives a password change, a username change and an operator password reset (an operator reset also turns TOTP off, after which a linked key signs in with no second factor). Only an API call removes a link.
Sign a challenge only on a page you trust: a page that makes you sign a challenge it asked your Hub for can use that proof once, within two minutes, either to sign in as you or to link your key to its own account on your Hub, after which signing in with your key would open that account instead of yours. Anyone who can reach your Hub can ask it for a challenge, and the challenge includes the Hub’s own install identifier.
A Local.Pub account’s DID key can be written as a did:key, but it can rotate, and a rotation orphans the link. Whether any Local.Pub client or wallet will sign a challenge for a Hub is not known; the Hub half is tested with tokens we sign ourselves.
Privacy
- A lookup sends the text of the handle to the host and the DNS zone it names, not only the fact that your Companion asked. That is how WebFinger works, and the handle is chosen by whoever, or whatever, started the lookup. The host part (up to 253 characters) goes into the name lookup, so whoever runs that DNS zone sees it, and the whole handle (up to about 318 characters) goes into the web address once the connection is made. So the lookup is opt-in, and nothing runs it on a schedule.
- An AI app can start a lookup. The lookup is labelled as reaching outside your appliance. Whether an AI app’s call waits for you depends on your Autonomy setting: it asks under Cautious and for installed apps, and runs immediately under Balanced (the default) and Hands-off, up to twenty times a minute. An AI app that is steered by a pasted handle, or by anything else it read, can therefore make your Companion contact a host of the attacker’s choosing once the flag is on, and pass what the app has read to whoever runs that host’s DNS. If your AI apps read content you do not trust, leave the lookup off or run the Cautious dial. The controls are that the lookup is off by default, the guarded connection (which limits where a lookup can go, not what the handle says), and a cap of two lookups at a time and twenty a minute.
- Your questions, answers, and memory never go to Local.Pub. It is used to find an address and a key, nothing else.
Not verified yet
- No run between two real Companions, and no Local.Pub account of ours to test with.
- Whether anyone can create a Companion field on Local.Pub at all, and whether it would keep the field the way we read it. The Companion field is our convention, and the profile editor we examined takes no field name and no
did:key. - Whether the
@you.<suffix>@local.pubhandle works for an account that has no domain of its own. For the one account with a domain that we looked at, it does not. - Hub sign-in has not been reviewed by the Hub security reviewer. Open for that review: a step-up to link, a screen to list and remove links, what a password change or an operator reset does to links, and resistance to a relayed proof.
- Whether anything on Local.Pub attests a Companion’s
did:key. None is known. - Who operates Local.Pub, and under what terms other software may read its public profiles, is not established.
- Rotation and revocation of the identifier itself. That needs the KERI work described in the page linked above.
Related
- Decentralized trust (KERI and ToIP) — the design this sits next to. It describes where identity is going, not what runs today
- Asking other Companions — what a linked person can ask, and how request signing appears in the UI
- Asking and sharing architecture — consent, the disclosure ladder, and the five invariants
Last updated on November 5, 2026.