Skip to Content
DocumentationCompanion MemoryTrust Tasks alongside KERI

Trust Tasks alongside KERI

Trust Tasks  is a Trust Over IP  framework (Decentralized Trust Graph Working Group) for the verifiable work two parties do together. A Trust Task is one self-contained JSON document that names its type, its two parties, its freshness and its proof, independent of whatever transport delivers it. A public registry publishes the task specifications and a small set of transport bindings.

Companion Memory already lets one Companion ask another a bounded question, authenticated by a KERI-shaped key. Trust Tasks adds a second, standards-shaped way to send the same ask: as a signed document whose proof travels inside it.

Status. Companion Memory can receive signed Trust Task asks. It cannot yet send them, and it has been tested in-process and against the reference library, not yet between two live Companions. The feature is off by default (ENABLE_TRUST_TASKS) and ships with the Companion Memory server. The identity is Companion Memory’s own self-certifying did:keri:D… key convention, not full KERI: there is no Key Event Log, no CESR encoding and no key rotation. See what it does not do yet.


Two doors, one pipeline

Nothing about who may be told what changes. A Trust Task ask passes through the same four gates as an HTTP-signed ask: identity, peer link, grant, and disclosure ceiling. Only the way the sender proves who they are differs.

The difference is where the proof lives. An HTTP message signature covers the request and is gone when the request is over. A Trust Task’s proof is part of the document, so the document is evidence on its own: it can be stored, forwarded and audited by someone who never saw the connection.


A Trust Task, concretely

A document has a handful of members. Everything task-specific is in payload.

MemberMeaning
idA fresh, unguessable identifier for this one document (a random UUID)
typeThe name of the task specification and version, such as …/spec/ask/request/0.1
issuerWho produced it: the sender’s did:keri:D… identifier
recipientWho it is for: the receiving Companion’s identifier. Because the proof covers it, a captured document cannot be replayed at a different Companion
issuedAtWhen it was produced. Documents more than five minutes old, or from the future, are refused
threadIdTies a reply to its request
payloadThe task itself. For an ask, exactly the ask body Companions already exchange
proofA W3C Data Integrity eddsa-jcs-2022 signature over everything else
{ "id": "urn:uuid:5b0a8c9e-2c1f-4f7e-9d2a-6f1e0a4b7c10", "type": "https://ci.computer/trust-tasks/spec/ask/request/0.1", "issuer": "did:keri:D…asker…", "recipient": "did:keri:D…responder…", "issuedAt": "2026-11-05T12:00:00Z", "payload": { "askId": "ask-2026-11-05-0001", "askerHandle": "alice", "prompt": "Are you free for lunch on Friday?", "request": { "archetype": "availability", "from": "2026-11-06T11:00:00Z", "to": "2026-11-06T14:00:00Z" } }, "proof": { "type": "DataIntegrityProof", "cryptosuite": "eddsa-jcs-2022", "created": "2026-11-05T12:00:00Z", "verificationMethod": "did:keri:D…asker…#D…asker…", "proofPurpose": "authentication", "proofValue": "z…" } }

The reply is the same type with #response appended, signed by the responding Companion and addressed back to the asker.

What Companion Memory defines

SpecificationCarriesReply
ask/request 0.1An ask (POST /agent/v1/ask)The answer, or pending
ask/collect 0.1Collecting an approved answer (GET /agent/v1/ask/:askId)The same answer, or pending
trust-task-discovery 0.1–0.4Which tasks this Companion acts on, and its time windowA list of task types

The two ask specifications are private: they live under a Companion-controlled name, not the public registry’s, so they can never be mistaken for a registry task. A task type is a name and is compared as one; nothing downloads it.


The identity behind the proof

The issuer is the same self-certifying identifier a peer link already uses: did:keri:D followed by the sender’s Ed25519 public key. The proof’s verificationMethod is derived from it, so the receiver needs no network lookup and no directory to check the signature: the identifier is the key. It is the same key that signs HTTP-signed asks, so a Companion has one identity across both doors.

A key that nobody could be held to, such as the all-zero key or any of the other small-order points, under which a signature can be forged without the private key, is never admitted, even if an owner links it.

The decentralized trust page describes where identity is heading: CESR-encoded identifiers resolved through a Key Event Log, so keys can rotate. What runs today is narrower. The identifier is did:keri:D plus the key’s 43 base64url characters, not a CESR string, so an identifier from another KERI implementation will not resolve here. If a key is compromised, the remedy is to link again under a new identifier.


How a request is checked

Shape and type

The document must be well formed and name a task this Companion serves, at a version it serves.

Size

No larger than its task allows: 16 KiB for an ask, 4 KiB for a collect. This is checked before anything is hashed.

Freshness

Issued within the last five minutes (allowing thirty seconds of clock skew), not in the future, and not past its own expiresAt.

Parties

recipient must be this Companion. A document that carries a proof must name its recipient.

Admission

The sender’s identifier must belong to a Companion the owner has linked, under the key the link records. This is one database look-up, made before the signature is examined, so a stranger costs this Companion a look-up and not a signature check.

Proof

The signature is checked over the document exactly as received. An unsupported signature suite is a failure, never “treat it as unsigned”. Passing this proves who is asking, not that they may ask for anything.

Budget

The same per-peer rate limits as the HTTP-signed door (ten asks a minute, thirty polls a minute) are spent now that the sender is known.

The payload

Only then is the payload checked against the task’s closed schema. A stranger never reaches this step.

Once only

The same document arriving twice is not executed twice. A different document under the same id, including a re-signed copy, is refused.

Then the ask goes to the ordinary pipeline: grant, disclosure ceiling, and the owner’s review inbox when nothing matches.

Every document is used once

An identical document arriving again, whether a retry or a replay, gets an empty 204 and nothing is run or handed back. Answering it from a record would give the owner’s released answer to anyone who captured the bytes. To collect an answer, the asker sends a new ask/collect document, which is the same poll the HTTP-signed door offers. A failure after a document was accepted is likewise reported as not retryable: send a new document.

A stranger is told nothing

If the sender cannot be proved and admitted, the answer is the same bare 401 every other authentication failure gets. The framework suggests answering a rejection with an error document; for an unknown sender that would tell them which of this Companion’s links and keys exist. Once a sender is proved and admitted, refusals are signed trust-task-error documents whose text comes from a fixed table and never echoes what was sent. Only four can still arise by then: busy (with a time to try again), malformed payload, id conflict and internal error.

A decision is not a failure

A grant that blocks the ask, a person who declines it, an expiry and an askId this Companion has never seen all produce the identical reply: pending. Trust Tasks draws the same line (a decision is an outcome, not an error), which is why the ask specifications have no way to say “denied”. The asker can learn only whether an answer exists.


Turning it on

Keep the signing key

Set peers.signingKeyJwk to an Ed25519 private JWK, in a configuration file or in NODE_CONFIG (it has no environment variable of its own). This is the key that already signs outbound HTTP-signed asks, and every Trust Task response is signed with it.

Enable the feature

Set ENABLE_TRUST_TASKS=true. The ask feature must also be on (it is by default).

Create a peer link with peerIssuer did:keri and peerSubject set to the peer’s full did:keri:D… identifier. Your Companion’s own identifier, which peers put in recipient, is did:keri:D plus the x value of your signing key.

Until all three hold, the route answers 404 exactly as it would on a Companion without it. Peers post to your Companion’s peer endpoint followed by /trust-tasks.


What it does not do yet

  • Send. Receiving is implemented; an outbound Trust Task client, and choosing between the two doors by discovery, are not.
  • Full KERI. No Key Event Log, no CESR, no rotation, no witnesses, and no ACDC or TEL grants. The design in decentralized trust is larger than what runs.
  • Other identifiers and bindings. Only did:keri:D… identifiers, and only the HTTPS binding. did:key, the Trust Spanning Protocol and DIDComm are not served.
  • The rest of the framework. Extension namespaces, ceremonies, task control (cancel, suspend, resume) and streamed replies are not implemented; documents that depend on them are refused or ignored as the framework requires.
  • Pairwise identifiers. The framework prefers a different identifier for every relationship. A peer link is keyed by the peer’s single identifier, so this is a stated trade-off, not a feature.
  • The framework’s “held for approval” reply. The framework says a task held for a person’s approval should be answered with a “next step” document. An ask queued for the owner is such a hold, but saying so would let the asker tell it from a refusal. Companion Memory answers pending instead, the carried protocol’s own answer.

Last updated on