One causal graph over every system you run.
Vectry ingests structured events from backends, browsers and devices, binds each one to its actor and operation, and organizes everything into four layers that end in explanations.
Events with a grammar, not free-form logs.
Every event captures an operation over a system entity: created, updated, deleted, restored, patched, merged, duplicated, signaled, triggered or evaluated. The operation names its domain, its entity and the specific instance affected — and when the operation mutates state, it carries the exact diff between original and updated values.
Actors are first-class: user, system, AI or device. Combined with per-organization scoping, every event answers who did what, where, and under which context.
await vectry.capture({
namespace: 'inventory.item.updated',
actor_id: 'usr-99992',
actor_type: 'user',
operation: {
type: 'updated',
system_domain: 'inventory',
system_entity: 'item',
system_entity_id: 'item-3339',
changes: {
original: { quantity: 3 },
updated: { quantity: 5 },
},
},
}); -
namespacestring - Readable identity: domain.entity.operation
-
actor_id / actor_typestring - Who acted: user, system, ai or device
-
operationEventOperation - Formal machine-readable operation + changes diff
-
organization_id / app_idstring - Multi-tenant scoping on every record
Traces and causal threads.
A Trace groups the events that belong to one coherent behavior around one entity — a reservation moving through booking, a quote being negotiated, a session under review. It has a beginning, an end and a primary actor.
A CausalThread links traces across services and systems into the broader storyline of an entity, and closes with an outcome: approved, error, abandoned. That is what lets you ask “what sequence led to this result?” across your whole stack.
const trace = await vectry.traces.start({
system_domain: 'booking',
system_entity: 'reservation',
system_entity_id: 'resv-011',
causal_thread_id: 'thread-98aabb',
});
// … events captured inside the trace …
await trace.end({ outcome: 'approved' }); Explanations you can audit.
An EventExplanation reconstructs the chain of causes behind a specific event: the ordered list of causative events plus a generated narrative that a human — an auditor, an operator, a compliance officer — can actually read.
It is an intelligence-driven audit layer, generated when deeper causal insight is needed, and stored as a first-class record you can query later.
const explanation = await vectry.explain({
event_id: 'evt-ff3901',
});
explanation.caused_by
// → [ quote.created, quote.updated, … ]
explanation.output
// → "The quote was rejected because the item
// was previously marked as expired." Anomalies at every altitude.
Deviations are detected at the level where they happen: a single malformed event, a trace with a missing step, a causal thread whose outcome breaks the expected pattern. Each anomaly records the expected sequence, the actual sequence and a deviation score.
Anomalies link back to their causal explanation — so a spike is never just a number, it is a story you can walk.
const anomalies = await vectry.anomalies.list({
level: 'trace',
min_deviation_score: 0.8,
});
// → [{ anomaly_type: 'sequence_violation',
// expected: [quote.created, quote.approved],
// actual: [quote.created, quote.rejected],
// deviation_score: 0.87 }] Identity-aware, workflow-native.
Vectry is the causal backbone of the Blackwood Stone ecosystem. Veripass grounds every event in verified identity context; Sommatic consumes the causal graph to reason, detect and act — and publishes Vectry workers (vectry.log, trace.start, trace.end, metrics.emit, audit.append) as a verified marketplace publisher.
Integration is non-invasive: your systems of record stay authoritative. Vectry observes, threads and explains.
Stop guessing. Start explaining.
Bring causal infrastructure to your operation — or start instrumenting with the open-source SDKs today.