Skip to content
Explanation

Vultron and ActivityPub

This page is not normative

This page is not considered a core part of the Vultron Protocol as proposed in the main documentation. Although within the page we might provide guidance in terms of SHOULD, MUST, etc., the content here is not normative.

Vultron messages are ActivityStreams 2.0 (AS2) activities, delivered between actors over ActivityPub. AS2 is the wire vocabulary, not an analogy for it: every protocol message a Vultron actor sends is an AS2 activity, and every object it carries is either an AS2 object or a Vultron extension of one. This page gives you the shape of those activities so that the activity guides can name each one by its verb and object without re-explaining the fields.

Two other pages carry what this one leaves out. Message Types lists every activity the protocol uses, with its formal message name, its discriminating fields, and a rendered example. Activity Vocabulary Design explains why each verb was chosen.

The grammar of an activity

The AS2 vocabulary describes an activity as a sentence: an actor performs a verb on an object, optionally from an origin, to a target, in a context.

---
title: The Parts of an ActivityStreams Activity
---
flowchart LR
    Actor -->|performs| Activity
    Activity -->|on| Object
    Activity -->|from| Origin
    Activity -->|to| Target
    Activity -->|using| Instrument
    Activity -->|with| Result
    Activity -->|in| Context

The diagram shows the seven relationships an AS2 activity can express. Vultron uses four of them on nearly every message: actor, the verb (type), object, and either target or context to name the case.

The activity guides write an activity as Verb(Object), with a nested form when the object is itself an activity. Offer(VulnerabilityReport) is an as:Offer whose object is a VulnerabilityReport; Accept(Offer(VulnerabilityReport)) is an as:Accept whose object is that Offer.

What a Vultron activity looks like

The message below is Report Submission (RS), implemented in ActivityStreams as Offer(VulnerabilityReport). It was produced by the reference implementation; the identifiers and timestamps are placeholders.

{
  "@context": [ // (1)!
    "https://www.w3.org/ns/activitystreams",
    "https://certcc.github.io/Vultron/ns/context.jsonld"
  ],
  "type": "Offer",
  "id": "urn:uuid:70f657e8-8640-414f-9b1a-2512f9664e3a",
  "published": "2026-09-28T17:38:03.000000+00:00",
  "to": ["https://vendor.example/actors/psirt"],
  "actor": "https://reporter.example/actors/finder",
  "object": { // (2)!
    "type": "VulnerabilityReport",
    "id": "https://reporter.example/reports/CVE-2026-0001",
    "name": "Buffer overflow in example-server",
    "content": "Details of the finding.",
    "attributedTo": "https://reporter.example/actors/finder" // (3)!
  }
}
  1. The activity cites the AS2 namespace first, so any AS2 receiver recognizes it, and then the Vultron JSON-LD context, which declares VulnerabilityReport and the other Vultron types.
  2. The nested object carries no @context of its own: the activity's context applies to everything inside it.
  3. The report's author is the finder who sends it, so attributedTo matches the activity's actor here.

Read it field by field.

Field What it carries Where the guides rely on it
type The AS2 verb Every guide names its activities by verb and object
actor The actor performing the activity Case-management handshakes are sent by the CASE_MANAGER, with the requesting participant in attributedTo and the request in inReplyTo
object The thing acted on: a Vultron object, or an earlier activity being answered Accept, Reject, TentativeReject, and Read carry the activity they answer, not the object inside it
target Where the object goes Add names the case here, as does Remove(CaseParticipant); Offer(CaseParticipantRole) names the actor being offered the role
origin Where the object comes from Remove(Note) and Remove(EmbargoEvent), which terminates an embargo, name the case here rather than in target
context The case an activity belongs to Invite(EmbargoEvent) names the case here, and so does the Note an Add(Note) carries
inReplyTo The earlier activity this one answers, when the verb alone does not say so Accept(Offer(Actor)[target=VulnerabilityCase]) names, in inReplyTo, the actor recommendation it accepts, and so does the CASE_MANAGER's forward of that recommendation, Offer(CaseParticipant)
to The recipient inboxes A report is offered to each recipient separately; case traffic goes to the CASE_MANAGER

Whether the case sits in target or context is not a matter of style. A receiver tells activities apart by these fields, so an Add(Note) that names its case in context instead of target is not recognized as a note. Each guide states which field its activities use, and Message Types records the discriminator for every activity.

The Vultron vocabulary

The verbs are all standard AS2: Offer, Accept, Reject, TentativeReject, Read, Create, Add, Remove, Invite, Join, Ignore, Leave, Announce, and Update. Vultron adds no verbs.

The objects are where Vultron extends AS2. VulnerabilityReport, VulnerabilityCase, CaseParticipant, CaseParticipantRole, CaseStatus, ParticipantStatus, EmbargoEvent, CaseLedgerEntry, and ProcessingFault are Vultron types, declared in the Vultron JavaScript Object Notation for Linked Data (JSON-LD) context that every activity cites in its @context, after the AS2 namespace. Standard AS2 objects appear too: a case note is an as:Note, and the actor invited to a case is an as:Actor. An embargo is not one of them: it is sent with the Vultron type EmbargoEvent, never a plain as:Event.

The same verb carries different protocol messages depending on its object. Accept(Offer(VulnerabilityReport)) is Report Valid (RV); Accept(Invite(EmbargoEvent)) is a participant's consent to embargo terms, while Add(EmbargoEvent) is Embargo Proposal Acceptance (EA); Accept(Invite(VulnerabilityCase preview)) is an actor joining a case. Read the object before the verb.

  • Objects — each Vultron object type and its fields
  • Activity guides — how to carry out each protocol task, activity by activity
  • Message Types — the full mapping from formal message names to wire activities

Reading path: You maintain a vulnerability tracker and want it to talk to your partners

This page is part of Send your first message.

Path overview