Event

Layer 8 of 12·Slice: Infrastructure services·Platform: Hookdeck · Hookdeck Outpost

Scope of this page. Reference material for the Event layer: what it owns, what it must not own, and how Synedrix OS implements it today. It is descriptive, not normative — where this page and the Layer Taxonomy Table disagree, the taxonomy table wins.

What this layer is link

Event standardizes how a fact enters, travels through, and leaves Synedrix OS. Signals, approvals, state changes, failures, anomalies and callbacks all propagate as events, and every one of them — whether emitted by the OS core, the intelligence agents, or a domain pack — uses the same envelope. This layer’s job is to make that envelope, its naming rules, and its lifecycle guarantees the one thing every producer and consumer can rely on regardless of what the event is about.

Event is deliberately thin on meaning and strict on shape. It does not decide whether an event should trigger a side effect — that is Orchestration’s (Layer 3) job once the event arrives — and it does not decide whether a proposed action is permitted — that is Governance’s (Layer 9). What it owns is the contract: a stable envelope, a stable naming grammar, and a small set of lifecycle rules (emit-once, workflow bracketing, causation chains, append-only) that keep an event stream reconstructible end-to-end no matter how many layers a piece of work crosses to produce one.

flowchart LR
  n1([Event]):::term
  subgraph What it owns
    n2[The event envelope]:::agent
    n3[Routing metadata]:::agent
    n4[Correlation IDs]:::agent
    n5[Schemas]:::agent
  end
  n1 --> n2
  subgraph What it must not own
    n6[Domain-specific policy logic]:::warn
    n7[Domain Pack Layer]:::term
    n6 --> n7
  end
  n1 --> n6
  subgraph Interfaces with
    n8[Orchestration]:::check
    n9[Memory]:::check
    n10[Observability]:::check
    n11[Domain packs]:::check
  end
  n1 --> n8

What it owns link

Per the Layer Taxonomy Table, Event owns the standard every event in the system is built to. Concretely, that means:

• The event envelope — the 14 required and optional fields every event carries regardless of category
• Routing metadata — domain, entity_type, source_type and source_id, which determine who owns and who consumes a given event
• Correlation IDs — correlation_id (end-to-end trace) and causation_id (direct cause), preserved unchanged across async steps and runtime-engine boundaries
• Schemas — the naming grammar ({scope}.{subject}.{fact}), the three event categories (OS, intelligence, domain), and the core OS event catalog itself

What it must not own link

This layer standardizes transport and structure; it does not decide what a domain-specific event means for that domain’s business rules. The taxonomy table draws that boundary explicitly.

A domain pack’s event catalog conforms to the Layer 8 envelope and naming rules, and it must still emit the core workflow-lifecycle and approval events this layer defines — but the policy logic that decides what a domain event should trigger belongs to the domain pack, not to the event standard itself.

Interfaces with link

Event is the transport every other layer’s signals travel over, and four relationships carry that traffic:

• Orchestration (Layer 3) — n8n workflows declared with trigger_type: event are satisfied by this layer’s ingress; every workflow execution brackets itself with workflow.started and a terminal workflow.completed or workflow.failed event.
• Memory (Layer 7) — QuestDB consumes the event stream for temporal aggregation, and Neo4j reconstructs lineage from the causation_id chain a stream of events forms; the memory control plane’s own lifecycle stages (memory.record.promoted, memory.record.forgotten) are themselves events under this layer’s envelope.
• Observability (Layer 10) — events feed Langfuse (LLM traces), QuestDB (temporal), Neo4j (lineage graph) and PostHog (behavioural); emission is not optional for the lifecycle events this layer’s standard names.
• Domain packs (Layer 11) — every domain pack contributes its own event catalog under its own domain value and prefix, conforming to this layer’s envelope rather than defining a competing one.

How Synedrix OS implements it link

The Event Taxonomy Standard is the authoritative specification, and it is exhaustive about what “standardize production, transport and consumption” means in practice. Every event, regardless of category, carries the same 15-field envelope: event_id, tenant_id (assigned by the event layer, never by the producer), event_type, domain, entity_type, entity_id, source_type, source_id, timestamp, correlation_id, causation_id, payload, plus the optional policy_context and severity, and a version. The spec fixes six design principles — events are immutable facts, one envelope serves every category, lineage is mandatory, names are stable and past-tense, policy-relevant events carry policy_context so no side effect escapes governance, and everything feeds observability by default. Events fall into three categories distinguished by ownership and prefix rather than structure: OS (core) events under os., workflow., policy., approval., agent. and memory.; Intelligence events emitted by the os-int-* agent family; and Domain events under each pack’s own code, which may never collide with a reserved OS prefix. Naming follows a fixed grammar, {scope}.{subject}.{fact} — lowercase, dotted, past-tense (edition.created, never create.edition) — and once published, a name is stable; renaming it is a breaking change to every subscriber.

Nine lifecycle rules keep the envelope trustworthy end-to-end: each occurrence emits exactly one immutable event; every workflow brackets itself with workflow.started and one terminal event; every agent invocation and workflow execution emits a corresponding os.outcome.* event derived from its Outcome Envelope; approval-gated paths bracket with approval.requested and exactly one of approval.granted / approval.denied; causation_id chains and correlation_id together reconstruct end-to-end lineage in Neo4j; consumers order by causation chain first and timestamp second, never assuming wall-clock ordering across async boundaries; the log is append-only; every memory recall brackets with memory.recall.requested and exactly one of .served / .denied, and every tier transition emits memory.record.promoted or .demoted; and erasing a memory record’s content emits memory.record.forgotten rather than leaving a silent gap. The core OS event catalog itself spans workflow lifecycle, outcomes (one event per Outcome Envelope status), approvals and policy decisions, agent invocation and tool authorization (agent.tool.authorized / .unauthorized / .suspended and the MCP/A2A approval events), intelligence and observability signals, and — since v0.3, implementing ADR-OS-002 — the full memory.* catalog emitted by the Memory Curator, the Consolidation & Reflection Agent and the Memory Access Broker.

The standard is explicit that the envelope itself is a breaking-change surface: any change to its 15 fields, the naming rules, or the lifecycle rules is a major version bump, which is why v0.2 → v0.3’s addition of the memory.* catalog — new names and two new lifecycle rules scoped to that family, with every existing field, name and rule untouched — qualified as only a minor bump. The v1.0 addition of the required tenant_id field is the other side of that rule: an envelope field change, and so a major bump.

Platform mapping link

Two platforms realize this layer, one on each side of the boundary: ingress and egress are separate products with separate licences, and neither one owns the envelope itself — both carry it, they do not define it.

Both platforms are deliberately downstream of governance rather than a way around it — a workflow reaches the Outpost publish step only after Policy Guard has cleared it, and Hookdeck’s inbound filters must be used for genuine transport noise, not for anything that resembles a policy decision.

OS agents at this layer link

No OS-owned agent is assigned to the Event layer in the Agent Registry. This mirrors Tool Abstraction’s position for the same reason: Event is transport and schema infrastructure that every agent’s activity flows through, not a layer where an agent reasons or reaches a decision. The registry assigns OS agents only to Layers 3, 4, 5, 7, 9 and 10. Agents that emit or consume events heavily — the Orchestrator (os-agt-001) bracketing workflows, the Memory Curator (os-agt-010) emitting memory.* events, the Audit & Lineage Agent (os-agt-008) reconstructing causation chains — are all homed at their own layers and simply produce or read events as a normal part of their work.

Layer principles that apply link

Two of the taxonomy table’s layer principles bear on this layer:

• 1. Shared before specific — one 15-field envelope serves OS, intelligence and every domain pack’s events rather than each category inventing its own shape; this is the principle that makes a single Event Taxonomy Standard possible at all.
• 2. Controls before execution — policy-relevant events carry policy_context, and events that represent or precede a side effect must remain auditable rather than bypassing governance for convenience; the approval-bracketing lifecycle rule is this principle expressed as an event contract.

Related Synedrix OS documents link

• Layer Taxonomy Table — the authoritative row for this layer.
• Event Taxonomy Standard — the 15-field envelope, naming rules, lifecycle rules, and the core OS event catalog.
• Hookdeck — the ingress gateway realizing this layer.
• Hookdeck Outpost — the egress gateway realizing this layer.
• Workflow Contract Spec — trigger_type, trigger_source, idempotency_strategy, which this layer’s events implement for event-triggered workflows.
• Outcome Spec — the Outcome Envelope every os.outcome.* event is derived from.
• Memory Fabric Spec — the source of the memory.* event names carried under this layer’s OS prefix.

Synedrix OS · Layer reference · Event