In ActivityPub today, a reply to a “followers-only” post is delivered only to the replier’s followers. Everyone else in the conversation - including people who follow the original author - never sees it, so the thread fragments into inconsistent partial views.
This proposal fixes that by giving every restricted thread a single coordinating server: the Context Authority, which is the server that hosts the thread’s root post. All replies, reactions, edits, and deletes for the thread are sent to that one server, which validates them and fans them out to everyone currently allowed to see the thread. Because all traffic flows through one authority, every participant converges on the same view.
contextHistory value
carried on the thread’s posts. Each post also carries an ordinary context value referencing the thread’s
[FEP-f228] collection of posts.to/cc addressing (e.g. the author and their followers) and
set contextHistory (and context). They do not put those URIs in to/cc. They deliver the reply to the
root author’s inbox.contextHistory, validates the reply (authorization + addressing rules + integrity), stores it in the Context
Object, and forwards it to everyone currently authorized.to/cc of the root post as the Context Authority last
published it. If the author later tightens or loosens visibility, the Context Authority republishes the root object
via Update, and future activities are routed to the new audience.When the Context Authority forwards a reply, it may need to rewrite the reply’s to/cc so that delivery matches
the current Thread Policy (for example, the audience changed since the reply was written). Plain HTTP Signatures only
prove who delivered a message, not who wrote it, and they break the moment an intermediary touches the payload.
So each sender attaches an Author Proof: a Data Integrity proof (FEP-8b32) computed over the activity with
to/cc removed. This applies to every kind of context activity - a reply, a like, a reaction, an announce, an edit,
a delete - not just posts. Excluding the addressing lets the Context Authority rewrite delivery without invalidating the
author’s signature over the content, while recipients can still verify that the content was written by the claimed
author and not altered in transit. An optional Forwarding Proof lets the Context Authority additionally sign the
addressing it chose, so recipients can verify the routing offline instead of trusting only the transport.
The contextHistory field and the proofs are additive: servers that don’t understand them ignore them harmlessly,
while FEP-f228 servers obtain a usable thread from context. Such legacy servers can still receive forwarded replies and
reply into a thread (their reply reaches the directly addressed author), but they cannot originate or relay
integrity-protected context fan-out.
The same machinery serves every conversation visibility. For direct threads (addressed to explicit actors) and followers-only / private-group threads, the audience is bounded and the Context Authority forwards to it directly. For public threads the audience is unbounded, so the Context Authority pushes to the thread’s participants (everyone who has replied or reacted) plus the root author’s followers, and serves all other readers by letting them pull the thread from the Context Object. In every class the participants - including legacy servers - converge on the same complete reply tree. See Thread Visibility Classes.
In current ActivityPub deployments, followers-only conversations fragment:
HTTP Signatures authenticate transport, not content. When inbox forwarding is used, recipients cannot verify that the object content they receive was authored by the claimed actor and was not modified by an intermediate server. FEP-8b32 introduces per-object integrity proofs that decouple content verification from transport; this proposal builds on them.
A server that does not implement FEP-8b32 cannot participate in context fan-out as a sender (its activities will not be forwarded), but may still receive forwarded activities and reply as a legacy endpoint.
FEP-1b12 (Group Federation) established the pattern of a central actor (the Group) receiving activities and redistributing them to members, which inspired the Context Authority model. FEP-1b12 targets explicit group membership rather than ad-hoc conversations.
FEP-171b (Conversation Containers) defines a model where a single conversation owner distributes approved activities to participants via wrapper activities. That approach and this proposal address the same class of problems with different authority and delivery semantics.
| Dimension | FEP-8c13 (Context Authority Routing) | FEP-171b (Conversation Containers) |
|---|---|---|
| Core mechanism | Native activities routed via contextHistory field |
Owner republishes activities via Add wrapper |
| Authority model | Context Authority validates and forwards eligible replies | Conversation owner explicitly approves and commits events |
| Commit semantics | Rule-based inclusion (authorization + integrity) | Explicit owner approval (Add) |
| Wire format | Standard ActivityPub activities | Add(Activity) wrapper required |
| Integrity model | Mandatory Data Integrity proof for context fan-out | Proof optional; origin-fetch fallback allowed |
| Mixed environments | Designed to degrade safely with legacy servers | Assumes shared container semantics |
| Adoption surface | Requires FEP-8b32; reuses existing AP fields | Higher: introduces new behavioral contract |
Update activities for the root
object. If a contextHistory IRI resolves but violates Root Authority Alignment, it is not a valid Context Object
under this FEP.OrderedCollection holding the stream of Context Activities for a thread - its
integrity-protected event log and the target of the contextHistory property (the collection of activities of
[FEP-f228]). It is the container the Context Authority ingests into, fans out from, and serves for backfill.OrderedCollection of a thread’s attributed objects (Note, Article,
…), identified by the ordinary context property. context resolves to the Posts Collection; contextHistory
resolves to the Context Object.Create, Update, Delete, Like, EmojiReact, Announce, and Undo.to/cc) as most recently published
by the Context Authority via Update. It is not a one-time snapshot: it changes whenever the root object’s
addressing is updated. The Thread Policy determines who may receive thread content.to/cc) plus local policy (e.g. blocks, mutes). It may
include collections (e.g. followers) and is not necessarily enumerable. It defines who may receive content
(authorization), which is distinct from the Delivery Target (who is actively pushed to).to/cc.Create activities
(excluding mere reactors) to limit fan-out amplification. It is the push Delivery Target for public threads.to/cc, Effective Addressing is taken from the embedded object; otherwise from the activity’s
to/cc. A missing to or cc is treated as an empty array.actor, computed after removing to and cc from the activity
and any embedded object, and carried in a dedicated authorProof field. It binds the content to its author while
letting the Context Authority rewire delivery addressing to match the current Thread Policy. It applies to every
Context Activity (replies, likes, reactions, announces, edits, deletes), not only to posts. (See
Relationship to FEP-8b32.)to/cc), referencing the
Context Authority’s instance-actor verification method. It binds the forwarded addressing (including any rewiring) to
the activity, providing payload-level verification as an alternative to transport-level trust.id. “Same instance” as the root object means it can publish
authoritative Update for that object and sign as the instance actor.id).
Recipients MUST confirm that the verification method used for transport authentication and for any Forwarding Proof
is controlled by that instance.The contextHistory property of an ActivityPub object MUST be an IRI identifying a dereferenceable Context Object
(the thread’s collection of activities): an authorized GET returns an ActivityPub representation, while unauthorized
requests MAY receive 401/403 under the access control below. The ordinary context property separately identifies
the [FEP-f228] collection of posts (see Posts Collection); it is not the Context Object.
The contextHistory property MUST be treated as a first-class payload reference, not an opaque identifier. The
Context Authority MUST resolve it to obtain authoritative metadata about the thread; other servers SHOULD
resolve it when they need backfill or authorization decisions.
The Context Object is authoritative for thread history indexing and backfill discovery only. Authorization
(“who may receive content”) is defined separately by the root object’s current to/cc (the Thread Policy) plus local
policy. The Context Object does not encode membership; it indexes the thread’s Context Activities for backfill and
convergence.
A Context Object URI MUST be stable and SHOULD be derivable. A simple, recommended construction is
https://{context-authority}/history/{topLevelPostId} for the Context Object (contextHistory) and
https://{context-authority}/contexts/{topLevelPostId} for the Posts Collection (context), allowing deterministic
discovery of both given the root object.
For a context to be valid under this FEP, the Context Authority MUST be the same instance that hosts the root
object (the object whose id is the canonical top-level post for the thread), and MUST be able to authoritatively
publish Update activities for that root object.
This ensures that the entity controlling the Context Object is the same entity that can change the Thread Policy via root object updates.
The Context Object:
OrderedCollection.Example:
{
"id": "https://alice.example/history/12345",
"type": "OrderedCollection",
"totalItems": 5,
"first": "https://alice.example/history/12345?page=1"
}
When the contextHistory (Context Object) resolves to an OrderedCollection, that collection:
A Context Authority SHOULD also expose the thread as an [FEP-f228] collection of posts, identified by the ordinary
context property, for interoperability with servers that consume context as a collection of posts (Mastodon,
NodeBB, WordPress, Discourse, Lemmy, and others). When present, this collection MUST be an
OrderedCollection whose items are the thread’s attributed objects (Note, Article, …) rather than activities, per
[FEP-f228], and SHOULD be ordered chronologically. It carries no integrity or routing semantics; all routing,
ingestion, and fan-out operate on the Context Object identified by contextHistory.
For restricted conversations (followers-only, direct, etc.), the Context Authority MAY allow dereferencing of the Context Object, the Posts Collection, and their collection pages, subject to strict access control. Authorization for such dereferencing MUST be evaluated by the Context Authority using the current Thread Policy plus local policy.
A Context Authority MAY decline remote dereferencing entirely (always returning 401/403) and rely exclusively on inbox delivery and forwarding for propagation, while still satisfying the dereferenceability requirement for local processing and authorized local actors.
These access controls apply to the Context Object, the Posts Collection, and any collection pages or backfill endpoints that enumerate their contents.
Dereferencing a restricted Context Object or Posts Collection MUST be authenticated by an actor-bound signature (authorized fetch); instance-only signatures MUST be rejected. Because federation trust is instance-mediated this cannot guarantee user-scoped enforcement - a server may proxy access to its own users - so a Context Authority MAY additionally require an actor authorized under the current Thread Policy, with logging, rate limits, and auditing. This is distinct from the instance-actor authentication used for forwarded deliveries.
When a Context Activity is ingested, its contextHistory reference MUST be resolved to the Context Object and
associated with it, not with the immediate parent (inReplyTo) alone. Servers MUST NOT treat contextHistory as
purely informational; it defines the authoritative thread context for history and lifecycle. (The activity’s context,
when present, identifies only the Posts Collection.)
This applies to every activity type that participates in the thread - Create, Update, Delete, Like,
EmojiReact, Announce, Undo, etc. - not only to reply posts. In all cases contextHistory and the Author Proof are
carried on the activity itself (many activities, e.g. Like, EmojiReact, Announce, carry their target as an IRI
in object and have no embedded object).
When generating a Context Activity for a thread with a resolvable Context Object, implementations:
contextHistory on the activity; this is the routing anchor.context on any embedded object (Note, Article, …) so the post
joins the thread’s collection of posts.contextHistory on the embedded object and on the thread’s top-level post.to/cc addressing as currently deployed (e.g. Mastodon-style), regardless of whether
context routing is desired.contextHistory or context URIs in to/cc.inReplyTo.The routing anchor is the contextHistory value, determined as follows:
contextHistory, the activity’s value is the Effective Context History IRI.contextHistory, that value is the Effective Context
History IRI.The context property is never the routing anchor and does not participate in this determination.
If both a legacy Linked Data signature and a Data Integrity proof are present, implementations MUST ignore the
legacy signature for object integrity.
All Context Activities intended for context fan-out MUST carry a valid Author Proof.
authorProof, forwardingProof, and contextHistory are not defined by the ActivityStreams 2.0 context. Activities
carrying them SHOULD include an @context defining them, alongside the Data Integrity context from the deployment’s
FEP-8b32 profile, so JSON-LD processors do not drop them:
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://w3id.org/security/data-integrity/v1",
"https://w3id.org/fep/8c13"
]
The https://w3id.org/fep/8c13 term context (provisional; to be assigned on publication) defines authorProof and
forwardingProof as DataIntegrityProof containers and contextHistory as an @id reference to the Context Object. The Data Integrity context MUST match the one used by the deployment’s FEP-8b32 profile.
Because eddsa-jcs-2022 canonicalizes the JSON document with JCS - including @context - signers and verifiers
MUST use the same @context; it is part of the Author Proof signed input and is not among the excluded fields.
Implementations that do not perform JSON-LD processing MAY treat authorProof/forwardingProof as plain JSON
members but MUST still reproduce the exact @context for canonicalization. The wire examples elsewhere in this
document show only the ActivityStreams context for brevity; conforming activities include the full @context above.
The Author Proof uses the canonicalization and verification rules of FEP-8b32, with one addition defined here: certain
addressing and forwarding fields are excluded from the signed input. The Author Proof is carried in a dedicated
authorProof field (not proof); for the FEP-8b32 process, authorProof is the proof container.
Before canonicalization, the signer and all verifiers MUST remove the following fields from the activity and from
any embedded object: to, cc, and forwardingProof. The legacy Linked Data signature field MUST also be
excluded if present. No other fields may be excluded for Author Proof verification under this FEP. The removed fields
are treated as not part of the signed input.
The proof being verified is excluded as defined by FEP-8b32 (verifiers canonicalize the document without the
authorProof value they are verifying, and process its proof options without proofValue); this FEP does not alter
that base rule, only the field name.
The Author Proof reuses the FEP-8b32 proof envelope and cryptosuite (e.g. eddsa-jcs-2022), but it is computed over a
transformed input: the activity with to, cc, and forwardingProof removed. This exclusion is deliberate - it
is precisely what lets the Context Authority rewrite delivery addressing to match the current Thread Policy without
invalidating the author’s signature over the content.
FEP-8b32 and the eddsa-jcs-2022 cryptosuite sign the whole document (minus the proof being verified) and have no
field-exclusion step. So an Author Proof is intentionally not a whole-document FEP-8b32 proof. To keep the two from
being confused, the Author Proof is carried in a dedicated authorProof field rather than the standard proof
field. This is what keeps the design compatible with FEP-8b32:
authorProof, ignores it as an unknown field, and never tries to verify
it over the full payload. The standard proof field is left untouched and remains available for ordinary
whole-document FEP-8b32 proofs on the object or activity.authorProof using the exclusion transform defined above.In short, authorProof and proof are independent layers: authorProof provides author-authenticity that survives
address rewiring, while proof (if present) provides ordinary whole-document integrity. A deployment may use either or
both.
Because a whole-document proof signs to/cc (which the Author Proof deliberately excludes), such a proof is
invalidated whenever the Context Authority rewires addressing during forwarding. For context-routed activities the
Author Proof is therefore the authoritative content-integrity check. A whole-document proof on a context-routed
activity or its embedded object MUST NOT be relied upon to survive forwarding, and recipients MUST NOT reject a
context-routed activity solely because such a proof fails to verify; rejection is governed by the Author Proof and the
Routing Decision Matrix. Senders that need content to remain verifiable across
forwarding SHOULD rely on the Author Proof rather than a whole-document proof.
The Forwarding Proof input MUST be a JSON object with exactly these keys:
id: forwarded activity id (string)type: forwarded activity type (string)actor: forwarded activity actor (string IRI)contextHistory: Effective Context History IRI (string IRI)object: forwarded activity object (string IRI)to: forwarded to list, normalized as belowcc: forwarded cc list, normalized as belowauthorProofValue: the proofValue of the verified Author Proof (string)If the activity embeds its object, object is the embedded object’s id; if object is an IRI, object is that
IRI; if neither is available, a Forwarding Proof MUST NOT be generated.
Absent to/cc are treated as empty arrays. If present, they MUST be arrays of IRI strings; any other form
(string singleton, object, non-IRI value) MUST cause Forwarding Proof generation or verification to fail. The to
and cc arrays MUST be normalized by removing duplicates (set semantics) and sorting lexicographically by Unicode
code points of the IRI string.
The resulting JSON object MUST be serialized using JSON Canonicalization Scheme (JCS, RFC 8785) before generating the Data Integrity proof.
authorProof field on the activity, with
proofPurpose: "assertionMethod" and a verificationMethod belonging to the activity actor. It MUST NOT be
placed in the standard proof field, which is reserved for ordinary whole-document FEP-8b32 proofs.forwardingProof field, with
proofPurpose: "assertionMethod" and a verificationMethod belonging to the Context Authority’s instance actor.Create and Update activities that embed an object, the activity actor MUST equal the embedded object’s
attributedTo; the Context Authority MUST reject context routing for activities that violate this, since the
Author Proof binds content to the activity actor. Delegated-authoring models are out of scope for this FEP.The sender addresses the reply to match the Thread Policy (followers-only here). The Author Proof is computed with
to/cc excluded from the canonicalized input.
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://bob.example/activities/98765",
"type": "Create",
"actor": "https://bob.example/u/bob",
"contextHistory": "https://alice.example/history/12345",
"to": ["https://alice.example/u/alice/followers"],
"cc": ["https://alice.example/u/alice"],
"object": {
"id": "https://bob.example/posts/98765",
"type": "Note",
"attributedTo": "https://bob.example/u/bob",
"inReplyTo": "https://alice.example/posts/12345",
"context": "https://alice.example/contexts/12345",
"content": "Hi Alice, I saw your followers-only post.",
"to": ["https://alice.example/u/alice/followers"],
"cc": ["https://alice.example/u/alice"]
},
"authorProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T15:20:45Z",
"verificationMethod": "https://bob.example/u/bob#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z3FXQjecWuf..."
}
}
The Context Authority forwards the activity (no rewiring needed in this example). The Author Proof is unchanged (it was computed without addressing fields). The optional Forwarding Proof is shown, signed by the Context Authority’s instance actor.
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://bob.example/activities/98765",
"type": "Create",
"actor": "https://bob.example/u/bob",
"contextHistory": "https://alice.example/history/12345",
"to": ["https://alice.example/u/alice/followers"],
"cc": ["https://alice.example/u/alice"],
"object": {
"id": "https://bob.example/posts/98765",
"type": "Note",
"attributedTo": "https://bob.example/u/bob",
"inReplyTo": "https://alice.example/posts/12345",
"context": "https://alice.example/contexts/12345",
"content": "Hi Alice, I saw your followers-only post.",
"to": ["https://alice.example/u/alice/followers"],
"cc": ["https://alice.example/u/alice"]
},
"authorProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T15:20:45Z",
"verificationMethod": "https://bob.example/u/bob#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z3FXQjecWuf..."
},
"forwardingProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T15:21:00Z",
"verificationMethod": "https://alice.example/actor#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z4HYRkemXvg..."
}
}
Create activity)Context routing is not limited to posts. Likes, reactions, announces, edits, and deletes are Context Activities too. A
Like carries its target as an IRI in object (no embedded object), so context and the authorProof are carried on
the activity. The Author Proof is still computed with to/cc excluded.
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://bob.example/activities/55512",
"type": "Like",
"actor": "https://bob.example/u/bob",
"to": ["https://alice.example/u/alice/followers"],
"cc": ["https://alice.example/u/alice"],
"contextHistory": "https://alice.example/history/12345",
"object": "https://alice.example/posts/12345",
"authorProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T15:25:10Z",
"verificationMethod": "https://bob.example/u/bob#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z5KZ8nQ2tps..."
}
}
When constructing a Context Activity for context-audience routing, the sender:
to/cc addressing as currently deployed for that activity/object type (e.g. deliver replies
to the root author and the followers collection where applicable per existing practice).to/cc of the object being replied to or reacted to (to
preserve legacy safety). Senders MAY narrow by addressing a strict subset (e.g. explicit actor IRIs).to/cc of the object being responded to (the root object for a
direct reply to root, the immediate parent for a nested reply, the target object for a reaction) onto the new object.contextHistory on the activity, and context on the embedded object when the activity embeds one.contextHistory or context URIs in to/cc.When requesting context routing, senders MUST deliver the Context Activity to the inbox (or
endpoints.sharedInbox) of the root object’s author - i.e. the Context Authority instance per Root Authority Alignment.
The root object’s attributedTo actor’s inbox is the discovery target.
A receiving server treats an activity as requesting context routing only when both:
This specification requires no capability discovery or negotiation. Routing intent is expressed solely by the presence of an Effective Context History IRI in the payload; whether routing occurs additionally depends on the receiver being the Context Authority and on the validation requirements below.
If an activity carries an Effective Context History IRI and the receiving server is the Context Authority for it, the activity is requesting (a) ingestion into the thread as a Context Activity, and (b) potential forwarding to authorized recipients, subject to the validation and integrity requirements below.
The presence of an Effective Context History IRI is necessary but not sufficient for context routing. Eligibility is determined exclusively by a valid Author Proof and authorization checks - never by the perceived capabilities of the sender’s server.
No capability negotiation (normative):
The Context Authority stores the Thread Policy as the root object’s to/cc. An activity’s effective visibility is
determined by comparing its Effective Addressing against the root object’s current to/cc.
These rules are written in terms of replies for readability, but apply to all Context Activities (replies, reactions, edits, deletes, etc.).
Inherited (“follow-post”) addressing: Effective Addressing exactly equal (set-equality, order-insensitive) to the
root object’s current to/cc. This signals “same visibility as thread.” Inherited activities are forwarded with the
Thread Policy addressing.
Narrowed addressing: An activity MAY narrow visibility using any addressing forms permitted by ActivityPub (individual actor IRIs and/or collections), provided every entry of its Effective Addressing is authorized under the current Thread Policy and local policy.
Address Filtering: The Context Authority MUST compute the filtered addressing of every Context Activity: the Effective Addressing with every entry removed that the Context Authority cannot verify as authorized under the current Thread Policy and local policy. Verification uses locally available state for collections the Context Authority controls (e.g. followers) and string-level comparison against the Thread Policy for all other entries; entries whose authorization cannot be established (e.g. collections with unknown semantics, or the public sentinel when the Thread Policy does not include it) MUST be removed.
The forwarded addressing MUST NOT contain any entry absent from the sender’s Effective Addressing (no widening) and MUST NOT be more permissive than the current Thread Policy. A Context Authority MAY additionally reject an activity by local policy (for example, one whose Effective Addressing includes the public sentinel in a direct thread). Filtering, not rejection, is the interoperable default for over-broad addressing: rejection does not prevent the sender’s own server from delivering the activity to the addressed audience, it only removes the activity from the thread.
Recipient set equality: Two addressing fields are equal if they contain the same IRIs as a set, ignoring order and duplicates. Implementations MUST canonicalize lists before comparison by removing duplicates and sorting lexicographically by Unicode code points. Comparison is string-based only: implementations MUST NOT dereference IRIs or apply semantic equivalence when comparing recipients.
This FEP applies to conversations of any visibility, but it separates two notions that the rest of this document treats together for restricted threads:
to/cc)
plus local policy. It governs the Reply Visibility Rules and access control.The Delivery Target is a set of delivery inboxes, not an addressing instruction. Forwarded to/cc continue to
follow the Thread Policy and the Address Rewiring rules; the Context Authority
MUST NOT enumerate the Delivery Target into the forwarded to/cc (see
Security Considerations).
Three visibility classes are distinguished by the root object’s addressing:
| Class | Thread Policy (root to/cc) |
Authorized Recipient Set | Delivery Target (push) | Backfill (pull) |
|---|---|---|---|---|
| Direct | Explicit actor IRIs | The listed actors (enumerable) | = Authorized Recipient Set | Authorized actors |
| Followers-only / private group | A collection (e.g. followers) |
Collection members (may be non-enumerable) | = Authorized Recipient Set | Authorized actors |
| Public | Includes as:Public |
Everyone (unbounded) | Participation Set + root author’s followers | Anyone (public Context Object) |
Followers-only and private-group threads are the default case described throughout this document: authorization and delivery coincide, and the Context Authority forwards to the Authorized Recipient Set, expanding collections it controls. The two subsections below add the rules for the direct and public classes.
When the Thread Policy is a set of explicit actor IRIs (a direct message or an enumerated private group), the
Authorized Recipient Set and the Delivery Target are both that explicit actor set, so Address Filtering under the
Reply Visibility Rules is exact: any actor outside the set - and as:Public - is removed
from the forwarded addressing, and a reply retaining no member of the set is rejected. The Context Authority thus never
amplifies an over-broad reply beyond the member set; whether the sender’s own server delivers that reply elsewhere is
outside the Context Authority’s control, as in ordinary ActivityPub federation. Membership is changed by the root
author updating the root object’s to/cc, propagated via
Root Policy Update Propagation.
The Author Proof is the primary defense against the Context Authority fabricating a message attributed to another
participant; recipients MUST reject forwarded activities whose Author Proof does not verify against the activity
actor. Routing through one instance still lets it withhold or reorder messages (forgery is prevented, censorship is
not), and this FEP provides no end-to-end confidentiality - direct content is visible to the Context Authority in
cleartext, as with ordinary ActivityPub direct messages.
Alice’s root post is addressed to the explicit member set {bob, carol} (the Thread Policy). Bob replies; his Effective
Addressing {alice, carol} is a subset, so the Context Authority forwards it to Alice and Carol. Adding a member later
is just an Update to the root to/cc, after which the new actor’s server backfills from the Context Object.
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://bob.example/activities/3002",
"type": "Create",
"actor": "https://bob.example/u/bob",
"contextHistory": "https://alice.example/history/3001",
"to": [
"https://alice.example/u/alice",
"https://carol.example/u/carol"
],
"object": {
"id": "https://bob.example/posts/3002",
"type": "Note",
"attributedTo": "https://bob.example/u/bob",
"inReplyTo": "https://alice.example/posts/3001",
"context": "https://alice.example/contexts/3001",
"content": "Works for me.",
"to": [
"https://alice.example/u/alice",
"https://carol.example/u/carol"
]
},
"authorProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T17:02:11Z",
"verificationMethod": "https://bob.example/u/bob#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z6PkR2mWq8t..."
}
}
When the Thread Policy includes the public sentinel (https://www.w3.org/ns/activitystreams#Public, as:Public), every
actor is authorized, so the Reply Visibility Rules permit any addressing. A reply MAY
still narrow its own visibility (e.g. a followers-only reply to a public post), which the Context Authority MUST
preserve and MUST NOT broaden back to Public.
Because the audience is unbounded, delivery is split between push and pull. The Context Authority maintains a
Participation Set - the root author plus every actor whose Context Activity it has ingested (optionally limited to
authors of Create activities, to curb amplification) - and SHOULD forward each ingested activity to the other
participants and to the root author’s followers, deduplicated by sharedInbox. The forwarded to/cc stay as the
Thread Policy addressing (as:Public plus followers); the Participation Set only selects inboxes and MUST NOT be
enumerated into the addressing. Everyone else - readers who never engage - obtains the thread by pull, dereferencing
the (publicly readable) Context Object; a new participant backfills the same way on its first reply, then receives the
rest by push. On large threads the Context Authority MAY rate-limit, drop high-volume reactions from push, or fall
back to pull-only, provided the Context Object stays dereferenceable for backfill.
Because forwarded activities are native (Create, Like, etc.) with ordinary addressing, legacy servers among the
participants receive them as normal federated replies and gain a more complete thread with no code changes - which is
how this FEP closes the well-known fragmentation of public reply trees. (informative)
Bob and Carol have already replied to Alice’s public post, so the Participation Set is {alice, bob, carol}. Dave
replies publicly, delivering to Alice’s inbox:
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://dave.example/activities/4004",
"type": "Create",
"actor": "https://dave.example/u/dave",
"contextHistory": "https://alice.example/history/4000",
"to": ["https://www.w3.org/ns/activitystreams#Public"],
"cc": [
"https://alice.example/u/alice/followers",
"https://alice.example/u/alice"
],
"object": {
"id": "https://dave.example/posts/4004",
"type": "Note",
"attributedTo": "https://dave.example/u/dave",
"inReplyTo": "https://alice.example/posts/4000",
"context": "https://alice.example/contexts/4000",
"content": "Jumping in late - great thread.",
"to": ["https://www.w3.org/ns/activitystreams#Public"],
"cc": [
"https://alice.example/u/alice/followers",
"https://alice.example/u/alice"
]
},
"authorProof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-01-16T18:40:03Z",
"verificationMethod": "https://dave.example/u/dave#main-key",
"proofPurpose": "assertionMethod",
"proofValue": "z7QmN4rXc9v..."
}
}
When a Context Authority receives an activity whose Effective Context History IRI references a local Context Object, it MUST
process it per the steps below. Authorization to submit and to deliver is decided by the Context Authority using the
current Thread Policy (root to/cc) plus local rules (blocks, mutes).
The Context Authority MUST:
actor). An Author Proof is verified iff present
and successfully verified.The Context Authority then applies the Routing Decision Matrix. In particular:
Context-audience routing MUST be integrity-protected: the Context Authority MUST NOT forward any Context Activity unless it carries a verified Author Proof. This is absolute and independent of the sender’s implementation or perceived capabilities. The Context Authority MUST determine routing solely from the activity payload and local authorization policy:
| Effective Context History IRI | Author Proof | Sender Authorized | Required Behavior |
|---|---|---|---|
| No | Any | Any | Treat as ordinary ActivityPub delivery |
| Yes | Absent | Any | MAY deliver to directly addressed local recipients; MUST NOT ingest; MUST NOT forward |
| Yes | Present but invalid | Any | MUST reject |
| Yes | Present and verified | No | MUST reject |
| Yes | Present and verified | Yes | MUST ingest and MUST forward (rewiring as needed; MAY add a Forwarding Proof) |
No additional server capability checks or negotiations are permitted or required.
For Context Activities from authorized senders with a verified Author Proof, the Context Authority MUST persist the
activity/object and MUST add the activity ID to the Context Object’s collection (contextHistory). When the
activity creates or updates a post, the Context Authority SHOULD also reflect that post in the Posts
Collection (context).
Activities lacking a valid Author Proof MAY be delivered to directly addressed local recipients (subject to local policy) but MUST NOT be added to the Context Object’s collection and are ineligible for context-audience routing.
For Context Activities eligible for context-audience routing, the Context Authority:
Forwarding MUST NOT depend on the perceived compliance or capabilities of recipient servers. Expanding a local follower collection to its remote inboxes does not require rewriting the activity’s addressing.
The Context Authority MUST NOT rewrite to/cc to enumerate individual actor IRIs solely to target specific
recipients.
The Context Authority MAY rewrite to/cc to make forwarded deliveries conform to the current Thread Policy,
including when the Thread Policy changed since the sender last observed the root object.
If the sender’s Effective Addressing contains entries not authorized under the current Thread Policy, the Context Authority MUST forward the activity with its filtered addressing, or reject it if the filtered addressing is empty, per Address Filtering in the Reply Visibility Rules.
When forwarding an embedded-object activity, rewiring MUST be applied consistently:
to/cc, the forwarded activity MUST set the embedded object’s to/cc to the
forwarded addressing.to/cc to the same sets as the embedded object’s (set
equality), to avoid recipient divergence.to/cc only if it also omits them on the embedded object and relies
exclusively on activity-level addressing; if the embedded object includes to/cc, omission is NOT RECOMMENDED.The Context Authority MUST NOT modify any field included in the Author Proof input. Any forwarder mutation MUST
be limited to the excluded fields (to, cc, forwardingProof). If any other modification would be required, the
Context Authority MUST reject the activity for context routing (it MAY still deliver it locally to directly
addressed recipients per legacy behavior).
A recipient implementing this FEP MUST authenticate forwarded deliveries via HTTP Signatures (or equivalent) and MUST confirm the request is verifiable using a verification method controlled by the Context Authority’s instance actor for the referenced Context Object. This transport-level check is the baseline for accepting forwarded activities: it ensures any addressing updates were performed by the Context Authority without requiring payload-level proofs.
Recipients SHOULD require a request signature profile that binds the request body (e.g. via the Digest header, or
Content-Digest/Repr-Digest per RFC 9530) when available. If body binding is unavailable, recipients MAY accept forwarded deliveries but MUST treat addressing
updates as transport-trusted rather than payload-verifiable.
Implementations MAY attach and verify a Forwarding Proof that cryptographically binds the forwarded to/cc to the
Context Authority, enabling offline verification and reducing reliance on transport-layer body binding. It provides
defense-in-depth: even if transport authentication is compromised, the payload-level proof shows the addressing was
authorized by the Context Authority.
When a Context Authority attaches a Forwarding Proof, it MUST be computed per
Forwarding Proof Canonicalization and placed in the
forwardingProof field.
When a recipient receives a Forwarding Proof, it SHOULD verify it and MAY treat success as a stronger signal than transport authentication alone. On failure, it SHOULD fall back to transport authentication and MAY log the failure.
When a server implementing this FEP receives a context-routed activity, it MUST:
id (Root Authority Alignment). A forwarded delivery whose signer is not controlled by that
origin MUST be rejected. On failure, MUST reject.authorProof against the
activity actor’s verification method. On failure, MUST reject.authorProofValue). On success, treat addressing updates as payload-verified; on failure, MAY fall back to
transport-authenticated delivery (and MAY log).No additional recipient-side authorization checks are required: the Context Authority’s transport-authenticated delivery implies the recipient is in the authorized audience. Recipients treat the Context Authority as the policy oracle for delivery authorization, and MUST evaluate visibility/presentation using Effective Addressing.
When the root object’s addressing (to/cc) changes, the Context Authority MUST publish an Update activity whose
object is the full updated root object (same id), and MUST deliver it per ordinary ActivityPub delivery.
Receiving servers implementing this FEP MUST update their stored copy of the root object upon accepting the
Update, and MUST treat the updated addressing as the current Thread Policy for the context.
An Update cannot make servers that do not implement this FEP stop displaying the root object (see
Visibility Changes and Retroactive Tightening). When a
Thread Policy change leaves a server with no authorized recipients, deletion is the correct end state for that server’s
copy whether or not it implements this FEP.
When the root object’s addressing is updated, the Context Authority MAY deliver a Delete activity for the root
object to each known server that previously received the root object but hosts no actor authorized under the current
Thread Policy. For servers implementing this FEP, the Delete is an explicit trigger for the purge described in
Context Retention and Deletion; for other servers, it is the only signal
that removes the object from display.
The Context Authority MUST NOT deliver such a Delete to a server that hosts at least one actor authorized under
the current Thread Policy.
This mechanism is best-effort. The set of servers holding a copy is approximated from the Context Authority’s delivery
and interaction records; for threads whose Thread Policy previously included as:Public, copies obtained through
relays, third-party announces, or ad-hoc fetches may reside on servers unknown to the Context Authority. After the
policy change, the access controls of
Access Control for Limited-Visibility Contexts prevent unauthorized
re-fetching of the root object, so such copies cannot be refreshed.
Upon learning an updated root object addressing for a context (via Update), a receiving server implementing this FEP
SHOULD re-evaluate which local users are authorized under the current Thread Policy, and SHOULD restrict
presentation of previously stored context items accordingly. It MAY retain stored objects for legal, abuse, or
operational reasons, but MUST treat them as not visible to unauthorized local users. For contexts that have become
unauthorized for all local users, servers SHOULD minimize retention duration and metadata exposure, consistent with
the deletion guidance in Context Retention and Deletion.
When a server begins hosting an actor that becomes part of the Context Audience after a conversation has started (e.g. Bob follows Alice mid-thread), the server SHOULD attempt to discover and backfill the context, subject to local policy, resource limits, and authorization constraints.
Discovery trigger: Discovery SHOULD be triggered when a server learns it hosts an actor authorized under the current Thread Policy for a context and has learned one or more Context Object URIs for it.
Discovery procedure:
Consistent with [FEP-f228], a server backfilling a thread SHOULD prefer contextHistory, MAY fall back to context
when it only needs the posts, and MAY fall back to recursive replies traversal when neither is
available.
Fallback (normative): If the Context Authority does not permit remote dereferencing, or dereferencing fails due to authorization or network constraints, the server MUST treat backfill as unavailable and rely solely on delivered activities. Full history convergence is then not guaranteed.
Suggested limits (non-normative): apply paging, caps on pages/items per context, and/or incremental (“newest first”) backfill to reduce amplification risk and allow partial convergence under load.
Alice creates a followers-only thread. Bob follows Alice after 5 Context Activities already exist. Bob’s server performs
GET https://alice.example/history/12345, receives an OrderedCollection with 5 items, and backfills all 5 (including
non-reply events such as reactions or edits) to present a complete conversation view.
If a server reasonably determines (from locally observable state) that it no longer hosts any actor authorized under the current Thread Policy for a Context Object, it SHOULD delete its entire local copy of that context - the Context Object, the Posts Collection, and all Context Activities associated exclusively with it - subject to local policy and legal/operational constraints. Implementations SHOULD apply a grace period to avoid thrash from transient authorization changes.
This prevents indefinite retention of private or restricted conversations by unrelated servers.
Bob and Carol both unfollow Alice; no local actors remain in Alice’s Context Audience. Bob’s server SHOULD delete
https://alice.example/history/12345 (and the Posts Collection https://alice.example/contexts/12345) and all Context
Activities belonging solely to that context. If Bob later re-follows Alice, the context is rediscovered and backfilled
per the previous section.
When resolving a contextHistory URI, the receiving server MUST resolve it to a Context Object and associate
Context Activities with that object. The contextHistory MUST NOT be resolved to the root Note object, an
inReplyTo chain, or a transient/inferred thread identifier. The Context Object is the sole authoritative container
for the conversation’s activity history, ensuring consistent backfill, authorization checks, and lifecycle management
across servers. The context URI resolves separately to the Posts Collection and MUST NOT be treated as
the Context Object.
This mechanism intentionally avoids explicit capability discovery. Compliance is inferred per activity from payload semantics: an Effective Context History IRI signals routing intent; a valid Author Proof signals eligibility; transport authentication (HTTP Signatures) is the baseline for trusting context-forwarded delivery; and an optional Forwarding Proof provides enhanced payload-level verification. This eliminates downgrade attacks via mixed-compliance networks and allows gradual adoption without coordination.
contextHistory Field (Informative)Servers that do not implement this FEP ignore the contextHistory field and the proofs, so including them is safe: they
cause no extra fetches and no effect on access control. FEP-f228 servers understand the ordinary context property
and obtain a usable collection of posts from it.
A Context Authority MAY accept legacy objects (objects lacking a valid Author Proof) from legacy peers if the activity is directly addressed to a local actor and local federation policy permits. Acceptance does not imply eligibility for context routing.
Legacy activities:
This ensures recipients relying on integrity guarantees never receive unverifiable content through protected channels.
When a legacy server replies to a restricted thread, the reply MAY be visible to the directly addressed recipient (e.g. the root author) and MAY be associated with that recipient’s local thread view, but MUST NOT be forwarded to the Context Audience. This reflects the limited guarantees of legacy federation while preserving conversation integrity for protected participants.
Example legacy reply (delivered as a Create):
{
"@context": "https://www.w3.org/ns/activitystreams",
"id": "https://legacy.example/activities/55555",
"type": "Create",
"actor": "https://legacy.example/u/charlie",
"to": ["https://alice.example/u/alice"],
"object": {
"id": "https://legacy.example/posts/55555",
"type": "Note",
"attributedTo": "https://legacy.example/u/charlie",
"inReplyTo": "https://alice.example/posts/12345",
"content": "Hello Alice!",
"to": ["https://alice.example/u/alice"]
}
}
This activity lacks an Author Proof, so it cannot be context-forwarded but may be delivered to the directly addressed recipient (Alice).
Sequence: Legacy Reply
sequenceDiagram
participant LegacySrv as Legacy Server
participant AliceSrv as Context Authority
participant CarolSrv as Follower
LegacySrv->>AliceSrv: Inbox POST Create{Note}
AliceSrv->>AliceSrv: Deliver to Alice locally (no Context Object ingest)
AliceSrv-x CarolSrv: No forwarding
Updating the root object’s addressing lets compliant implementations retroactively restrict presentation of previously stored thread items for local users no longer authorized under the updated Thread Policy. This provides no guarantee of content recall across the federation:
Update while applying its content changes. On such servers the root object remains
displayed at its original visibility indefinitely, and content edits published after a tightening continue to reach
the original, broader audience there.Tightening is therefore reliable only across servers implementing this FEP. Implementations acting as Context Authority SHOULD surface this limitation to users when a visibility change is privacy-motivated (for example, by offering delete-and-repost as an alternative).
This limitation is inherent to federated systems: the policy update mechanism provides best-effort restriction for compliant implementations, not guaranteed erasure.
CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
To the extent possible under law, the authors of this Fediverse Enhancement Proposal have waived all copyright and related or neighboring rights to this work.