Talisman's test for a context layer is whether its declarations can be inspected, validated, and exported. This meshup runs that test on Collate and on agent-rdf-memory, then adds a Virtuoso angle.
Talisman argues that a context layer counts as one only when its declarations can be inspected, validated, and exported in open standards. Collate, built on OpenMetadata, is her worked example: it publishes its entity model as JSON Schema and offers an optional RDF projection. agent-rdf-memory meets the same test with different machinery: plain Turtle files in git, procedural gates plus SHACL shapes for structure (report-only at present), and a SPARQL load path for Virtuoso. Above all, agent-rdf-memory is about loose coupling: its rules and Turtle files stay the same whichever platform hosts them. The meshup compares and contrasts each approach.
10 comparison dimensions, each a cdx:ComparisonDimension instance. Collate's column reports the article's claims, and the agent-rdf-memory column reports what the repository contains. On larger screens this is a table; on phones each product becomes a card.
| Dimension | Collate (per the article) | agent-rdf-memory (per the repo) |
|---|---|---|
| Inspectable declarations | Collate publishes its entity model as open JSON Schema and documents its standards crosswalk. Ontology Studio and the Ontology Explorer make the graph visible to people. | The memory is plain Turtle in a git repository, so every declaration can be read, grepped and diffed on GitHub. Nothing is hidden in a database. |
| Validated declarations | The article says metadata is checked with SHACL shapes, covering cardinality, datatypes, identifier formats and required ownership. | The store has SHACL shapes for session document entities, index list items and HowTo steps, checked with pyshacl. The shapes are report-only: at build time 231 of 320 session files conform. Procedural gates also run. check-memory-gate.py, a Claude Code PreToolUse hook, blocks writes until the core files are read. validate-memory-protocol.py audits Claude Code JSONL transcripts. session-graph-gate.py, which is harness-neutral, compares triple sets with the named graphs in the triple or quad store the memory is loaded into (Virtuoso in this deployment). |
| Exportable declarations | The article describes Turtle, JSON-LD 1.1 contexts for each domain, and a documented API for export. | Turtle is the default and only serialization. AGENTS.md uses another format only when the user names it, so export means copying files or loading them into a SPARQL store. |
| W3C standards alignment | The article says glossaries are SKOS, relationships are OWL object properties, and lineage uses PROV-O, with SHACL for validation. | RDF and Turtle with schema.org vocabulary and a local onto: ontology. It now uses W3C SHACL for structural shapes, but there is no SKOS scheme or OWL axiom set for the memory itself; the corpus term registry uses owl:equivalentClass. |
| Provenance and history | Every entity is versioned, and each change to a description, owner or classification is emitted as an event on a timeline. | Each session file is a per-session record: its name carries the date, model and environment, and schema:dateCreated and schema:dateModified say when it was written. The store keeps no event log of its own: each session file is a snapshot record for one agent run, and the harness is generic, so any agent can write one. The Claude Code hooks and the transcript audit are specific to one harness; other harnesses have no transcript audit. Routing traces belong to the separate llm-routing-skill, not to the memory store. Repository history comes from git. |
| Lineage and graph structure | Lineage edges across sources, pipelines and dashboards, with transitive inference rules. Classifications propagate along lineage. | No data lineage. The graph links sessions to HowTo files through rdfs:seeAlso and onto: relations, which is a navigation graph, not a data-flow graph. |
| Agent access path | An MCP server, an SDK, and natural-language chat over governed context, with SPARQL reachable through tools. | Agents read files directly or query a SPARQL endpoint chosen at session start (AGENTS.md Step 0). There is no MCP memory server, by design. |
| Sovereignty and lock-in | The article's claim: open JSON Schema and W3C standards mean context is not locked in the platform. It is an assertion about design, not an independent audit. | The harness is files and rules: Turtle graphs in git, read either from the filesystem or through SPARQL against whichever endpoint a session selects (AGENTS.md Step 0). A move from one triple or quad store to another reloads the same Turtle and changes the endpoint; the rules and the harness stay the same. The platform-coupled part is the sync step in session-graph-gate.py, which emits Virtuoso isql or Graph Store PUT. A different store needs a new sync emitter, not new rules. Private overlays stay local, and credentials are referenced by Keychain (or host OS equivalent) item name, not stored in the Turtle. |
| Governance and AI disclosure | An audit log of every AI action, a badge on AI-generated content, and a mapping to EU AI Act obligations including Article 50, per the article. | Behavioral rules live in AGENTS.md and preferences.ttl. Actions are auditable through session transcripts, but there is no product-level audit log or AI-content labeling. |
| Scale and deployment | The article reports more than 700 JSON Schemas, more than 130 connectors, and enterprise deployments including a reported OpenAI internal data agent. These are vendor-reported figures. | Scale comes from the deployment platform, not from the harness. Today the memory is about 190 HowTo files and about 320 session files, held as files in git. The same Turtle loaded into an enterprise-grade triple or quad store inherits that store's scale. The design goal is loose coupling: rules and files any application or platform can read, not tight coupling to one application's schema or one vendor's API. |
The claims the rest of the page tests. Each is a schema:Claim in the companion RDF.
Context is a declared property of a system. A layer qualifies only when its declarations can be inspected, validated and exported.
A glossary becomes an ontology only when it adds typed relationships and axioms. Most vendor claims stop at labelled definitions.
An agent should retrieve declared facts with a query rather than generate them. Both approaches make this a design choice: Collate through its graph and MCP tools, agent-rdf-memory through files and SPARQL.
Virtuoso puts both approaches on one substrate: IRIs for every declaration, SPARQL as the query formula, named graphs for scope, and RDF Views for relational sources. The memory's gate scripts can then validate with ASK queries, not only with file checks.
Collate's graph is a Fuseki projection of a relational store that stays the system of record. Virtuoso can host the same projection with RDF Views over the relational tables, so the RDF is derived rather than copied. agent-rdf-memory already loads into a SPARQL store, so its per-session named graphs can use the same endpoint.
7 steps, applied to any product or harness that claims to be a context layer.
12 defined terms, from the article's vocabulary to the RDF and SPARQL terms this page uses.
Every entity and relationship in the companion RDF, rendered live. Click a node or edge label to open it through URIBurner.
Run the companion graph's queries against URIBurner. The result link works after the Turtle is published to the named graph below.
Pick a named graph and a query recipe, edit the query, and run it against URIBurner.
SELECT queries use text/x-html+tr. DESCRIBE and CONSTRUCT queries use text/x-html-nice-turtle.
Counts the entities of each RDF type. Each row carries an IRI column, so every row links to an entity.
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?typeIri (COUNT(?s) AS ?entityCount) (SAMPLE(?s) AS ?sampleIri)
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/context-layers-agent-rdf-memory-meshup-claude_haiku_5_5-1.ttl> { ?s rdf:type ?typeIri . } }
GROUP BY ?typeIri
ORDER BY DESC(?entityCount)
LIMIT 50text/x-html+trResults appear once the Turtle is published to the named graph below. Until then the run link returns no rows.
Returns every triple about the meshup entity, so you can follow its links into the graph.
DESCRIBE <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/#meshup>text/x-html-nice-turtleResults appear once the Turtle is published to the named graph below. Until then the run link returns no rows.
Returns the IRI-valued triples of the named graph, capped at 200 triples.
CONSTRUCT { ?s ?p ?o }
WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/context-layers-agent-rdf-memory-meshup-claude_haiku_5_5-1.ttl> { ?s ?p ?o . FILTER(isIRI(?o)) } }
LIMIT 200text/x-html-nice-turtleResults appear once the Turtle is published to the named graph below. Until then the run link returns no rows.
https://linkeddata.uriburner.com/DAV/demos/daas/context-layers-agent-rdf-memory-meshup-claude_haiku_5_5-1.ttl is the expected publication location. It returns results only after the Turtle is uploaded there. Until then, the live links return empty results.