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.
flowchart LR
Peer["Peer Companion"]
subgraph Doors["Two ways in"]
A["POST /agent/v1/ask<br/>RFC 9421 HTTP signature"]
B["POST /agent/v1/trust-tasks<br/>Trust Task document<br/>with an in-band proof"]
end
subgraph Gates["The four gates (unchanged)"]
direction TB
G1["1. Identity"] --> G2["2. Peer link"] --> G3["3. Grant"] --> G4["4. Disclosure ceiling"]
end
Peer --> A --> G1
Peer --> B --> G1
G4 --> Answer["Answer, or the one uninformative reply"]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.
| Member | Meaning |
|---|---|
id | A fresh, unguessable identifier for this one document (a random UUID) |
type | The name of the task specification and version, such as …/spec/ask/request/0.1 |
issuer | Who produced it: the sender’s did:keri:D… identifier |
recipient | Who it is for: the receiving Companion’s identifier. Because the proof covers it, a captured document cannot be replayed at a different Companion |
issuedAt | When it was produced. Documents more than five minutes old, or from the future, are refused |
threadId | Ties a reply to its request |
payload | The task itself. For an ask, exactly the ask body Companions already exchange |
proof | A 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
| Specification | Carries | Reply |
|---|---|---|
ask/request 0.1 | An ask (POST /agent/v1/ask) | The answer, or pending |
ask/collect 0.1 | Collecting an approved answer (GET /agent/v1/ask/:askId) | The same answer, or pending |
trust-task-discovery 0.1–0.4 | Which tasks this Companion acts on, and its time window | A 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).
Link the peer
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
pendinginstead, the carried protocol’s own answer.
Related
- trusttasks.org : the registry and the framework specification
- Trust Tasks framework source : the Working Draft this page was written against (0.7.0)