Cogniscence captures structured events from operating systems, applications, browsers, and agents, and preserves them as immutable evidence, builds a temporal entity graph, and returns cited context packets fast enough for active agent work.
The right subgraph, at the right time, under the right scope, with evidence for every important claim.
Agents that cannot remember cannot reason over time. Today's memory layers force a trade-off between speed and structure, between recall and evidence, between sharing and privacy.
Cogniscence refuses the trade-off.
Embedding search returns isolated text chunks with no stable identity, no temporal truth, and no relationships. Fuzzy matching quietly becomes the default path, and hides every extraction gap.
Append-only histories force ever-growing scans. Old memory becomes second-class: slow, summarized away, or effectively archived instead of directly addressable.
A model that freely rewrites its own memory cannot prove why a claim exists. Without immutable evidence and reversible decisions, every merge is a contamination risk.
Multi-agent systems pass prompts, not state. Without scoped visibility, watermarks, and explicit handoffs, teams of agents leak private data or silently lose conflicts.
Cogniscence captures structured events from operating systems and applications and browsers and agents then preserves them as immutable evidence and turns them into a temporal entity graph. The result is a shared-memory system designed for speed and structure and accountability rather than approximation.Cogniscence gives every approved agent the right subgraph at the right time under the right scope with evidence for every important claim.
Every accepted observation is preserved as an immutable Episode before it becomes semantic memory. Each node edge and context item links back to exact evidence spans rule versions transaction time valid time trust and visibility. That means every important claim can be proven.
Memory is structured as typed entities: Person Task Decision Thread connected by bitemporal relationships. Identity resolution is a reversible view over evidence-local anchors which means merges splits and corrections rewrite the view but never the underlying evidence.
Every request returns a Fast Context Packet inside a deterministic SLO using ordered indexes and bounded graph expansion and TRM ranking. Old history is sought not scanned. An SLM may enrich concurrently but it never delays or invalidates the fast answer.
Principals workspaces policies and visibility are graph entities. Agents publish scoped state and hand it off at explicit graph and ledger watermarks so a receiving agent sees allowed context. It never sees silently stale state and it never sees another principal's private memory.
Retrieval speed, entity modeling, scaling, and shared context are accepted only when demonstrated together, measured against no-memory, raw-history, and vector-only baselines.
Ordered indexes and bounded graph expansion return current and year-old history without scanning the corpus. Hot lookups land in single-digit milliseconds; every natural-language request gets a deterministic Fast Context Packet inside its SLO.
Agents receive stable, typed, temporal, evidence-backed nodes and edges (Person, Task, Decision, Thread), not isolated text chunks. Identity resolution is a reversible view; merges never destroy evidence.
Every accepted observation becomes an immutable Episode before it becomes memory. Every semantic node and edge links back to evidence spans, rule and model versions, trust, and visibility.
One node/edge schema and stable IDs survive promotion from Hot to Warm to sealed Cold segments and across Workspace Home Shards. No data-model migration as memory grows.
A Tiny Reasoning Model ranks bounded candidates; a Small Language Model proposes semantics. Deterministic validators, evidence, and policy decide what becomes active memory. Models never mutate the graph.
The Event Bridge SDK maps native signals from macOS, Windows, Linux, browsers, mobile, and cloud services into one versioned protocol. Missing capability is explicit, never invented structure.
The canonical semantic memory is a single temporal property graph. Hot serves the working set, Warm holds durable mutable history, Cold keeps sealed history directly addressable, and the Graph Directory routes every read without a global scan.
The graph is the relationship and entity model, supported by an append-only Episode ledger, B-tree and hash indexes, FTS5 lexical candidates, byte-bounded caches, and encrypted blob segments. These mechanisms make the graph fast. They never replace it.
Stable UUIDv7 identity never changes when memory moves temperature. Tier transitions (promote, warm, seal, overlay, compact, evict) cannot rewrite identity, erase provenance, or change visibility.
Passive segments open read-only and memory-mapped. A year-old conversation is fetched by bounded seek against the thread/time index with no whole-segment activation, no archive scan, and no model reconstruction.
Rust owns the cache-sensitive data plane: graph arenas, stable-ID maps, bounded walks. Elixir/OTP owns sessions, supervision, backpressure, and coordination. The boundary is an enqueue-only NIF or a protocol-compatible sidecar, proven against scheduler, crash, fuzz, and 24-hour soak gates.
Full hybrid round trip including query decode, policy handle, boundary crossing, and compact result decode (p95).
Structured events, immutable evidence
Adapters publish Cogniscence Structured Event Protocol envelopes from macOS, Windows, Linux, browsers, and services. The gateway authenticates, verifies consent, applies redaction, enforces idempotency, then encrypts and appends an immutable Episode before any semantics run.
Extraction assurance, not blind trust
Deterministic schema mappings run first. The SLM may propose typed nodes, edges, and evidence spans, but a deterministic validator checks every span, time range, trust ceiling, and scope before the TRM scores bounded candidates. Confidence alone never activates a claim.
Fast packet first, enrichment concurrent
Every request returns a deterministic Fast Context Packet (stable handles, aliases, FTS, bounded graph expansion, TRM ranking) inside the latency SLO. The SLM concurrently proposes an enrichment delta that can add evidence, but never delays the fast answer.
Semantic memory is earned, not assumed. An observation becomes an active graph assertion only after deterministic verification. Anything below the floor stays evidence-only or provisional, and task-critical relations demand corroboration or review.
{
"task": "Continue the launch plan from the last pricing decision",
"entity_hints": ["Project Atlas", "pricing"],
"relations": ["decided_in", "depends_on", "assigned_to"],
"max_depth": 2,
"max_items": 24,
"max_tokens": 1800,
"consistency": {
"mode": "read_your_writes",
"min_ledger_sequence": 8123
}
}Release requires every outcome and every dependency gate to pass on frozen datasets and supported hardware. No aggregate score can hide a single failure.
| Operation | p50 | p95 | p99 |
|---|---|---|---|
| Hot ID / path / edge lookup | ≤ 2 ms | ≤ 8 ms | ≤ 15 ms |
| Warm ID / path / thread page | ≤ 10 ms | ≤ 35 ms | ≤ 75 ms |
| Cold old-history page, local SSD | ≤ 35 ms | ≤ 100 ms | ≤ 200 ms |
| Scoped graph query (≤ 3 hops, ≤ 200 results) | ≤ 30 ms | ≤ 100 ms | ≤ 200 ms |
| Fast Context Packet, including TRM | ≤ 60 ms | ≤ 150 ms | ≤ 300 ms |
| SLM Enrichment Delta (concurrent) | reported separately | ≤ 2 s local | ≤ 4 s timeout |
The first five rows define near-instant retrieval. SLM enrichment runs concurrently, is reported separately, and never blocks a Fast Packet.
Be among the first teams to deploy Cogniscence. We onboard a small number of design partners running real cross-application agent workflows.
Local-first by design. Your memory never leaves your custody.