@prefix : <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/#> .
@prefix schema: <http://schema.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
@prefix cdx: <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-terms#> .

<> a schema:CreativeWork ;
    schema:about :meshup ;
    schema:name "Context Layers From First Principles: agent-rdf-memory meshup"@en ;
    schema:description "Notes taken about Jessica Talisman's LinkedIn Pulse article on context layers. The notes test the article's inspectable, validated, exportable criteria against Collate (the commercial product built on OpenMetadata) and against agent-rdf-memory, an RDF-based memory harness for AI agents, and add a Virtuoso angle. These are commentary notes, not the article's official companion."@en ;
    schema:abstract "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."@en ;
    schema:dateCreated "2026-10-08T00:00:00Z"^^xsd:dateTime ;
    schema:dateModified "2026-10-08T18:00:00Z"^^xsd:dateTime ;
    schema:inLanguage "en"@en ;
    schema:isBasedOn <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/> ;
    schema:author <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this> ;
    schema:accountablePerson <https://www.linkedin.com/in/kidehen#this> ;
    schema:publisher <https://www.linkedin.com/in/kidehen#this> ;
    schema:hasPart :meshup, :comparisonSection, :howToSection, :faqSection, :glossarySet, :ontology ;
    prov:wasGeneratedBy <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this>, <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> ;
    rdfs:seeAlso <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/> ;
    rdfs:isDefinedBy :ontology .

:ontology a owl:Ontology ;
    schema:name "Context Layer Meshup Ontology"@en ;
    schema:description "Terms minted for this meshup: the comparison dimensions and their per-product assessment properties, the thesis claims, and the sections that the HTML companion renders. Reusable comparison terms come from the cdx: prefix."@en ;
    schema:identifier "context-layers-agent-rdf-memory-meshup"@en .

:meshup a schema:CreativeWork, schema:Article ;
    schema:name "Context Layers From First Principles, meshed with agent-rdf-memory"@en ;
    schema:about :contextLayer, :agentRdfMemory, :collate, :virtuoso ;
    schema:hasPart :ontology, :howto, :faqSection, :glossarySet, :relatedReads ;
    schema:isPartOf <https://www.linkedin.com/newsletters/the-knowledge-engineer-7330987168305188865/> ;
    rdfs:isDefinedBy :ontology .

:article a schema:Article ;
    schema:name "Context Layers From First Principles"@en ;
    schema:author <https://www.linkedin.com/in/jmtalisman/#this> ;
    schema:datePublished "2026-10-07"^^xsd:date ;
    schema:url <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/> ;
    schema:inLanguage "en"@en ;
    schema:isPartOf <https://www.linkedin.com/newsletters/the-knowledge-engineer-7330987168305188865/> .

<https://www.linkedin.com/in/jmtalisman/#this> a schema:Person ;
    schema:name "Jessica Talisman"@en ;
    schema:description "Founder of Contextually LLC and of the Ontology Pipeline framework; author of the newsletter The Knowledge Engineer."@en ;
    schema:worksFor :contextuallyLLC ;
    schema:url <https://jessicatalisman.substack.com/> .

:contextuallyLLC a schema:Organization ;
    schema:name "Contextually LLC"@en ;
    schema:description "Consulting firm for ontology modelling, NLP integration, knowledge graphs, and knowledge infrastructure design."@en .

<https://www.linkedin.com/in/kidehen#this> a schema:Person ;
    schema:name "Kingsley Uyi Idehen"@en ;
    schema:jobTitle "Founder & CEO"@en ;
    schema:worksFor <http://dbpedia.org/resource/OpenLink_Software> ;
    owl:sameAs <https://x.com/kidehen#this>, <https://substack.com/@kidehen#this> .

<https://www.getcollate.io/product#this> a schema:SoftwareApplication ;
    schema:name "Collate"@en ;
    schema:description "Commercial context platform built on the OpenMetadata open-source project. Collate 2.0 was announced 10 June 2026 and reached general availability on 25 August 2026, per the article."@en ;
    schema:isBasedOn <https://open-metadata.org/#this> ;
    schema:url <https://www.getcollate.io/product> ;
    schema:applicationCategory "Context platform"@en .

<https://open-metadata.org/#this> a schema:SoftwareApplication ;
    schema:name "OpenMetadata"@en ;
    schema:description "Open-source metadata project. Its core is licensed Apache 2.0, and it describes a data estate as typed, versioned entities defined in JSON Schema."@en ;
    schema:license <https://www.apache.org/licenses/LICENSE-2.0> ;
    schema:url <https://open-metadata.org/> .

<https://www.linkedin.com/in/sureshsri/#this> a schema:Person ;
    schema:name "Suresh Srinivas"@en ;
    schema:description "Co-creator of OpenMetadata and co-founder of Collate; previously helped build Apache Hadoop and Apache Atlas."@en .

<https://www.linkedin.com/in/sriharsha/#this> a schema:Person ;
    schema:name "Sriharsha Chintalapani"@en ;
    schema:description "Co-creator of OpenMetadata and co-founder of Collate; previously helped build Apache Kafka and Apache Atlas."@en .

:contextLayer a skos:Concept ;
    skos:prefLabel "Context layer"@en ;
    skos:definition "A declared property of a system, expressed through concepts, vocabularies, typed relationships, provenance, and constraints. The article's test: a layer qualifies only when those declarations can be inspected, validated, and exported."@en ;
    skos:inScheme :meshupVocabulary ;
    rdfs:isDefinedBy :ontology .

:agentRdfMemory a schema:SoftwareApplication ;
    schema:name "agent-rdf-memory"@en ;
    schema:description "Filesystem-first memory harness for AI agents. Session memory is stored as Turtle files in a git repository and read at session start. The store can also be loaded into a SPARQL endpoint."@en ;
    schema:isPartOf <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory#this> ;
    schema:codeRepository <https://github.com/OpenLinkSoftware/ai-agent-skills> ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory> .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory#this> a schema:CreativeWork, schema:SoftwareSourceCode ;
    schema:name "agent-rdf-memory (repository directory)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory> ;
    schema:codeRepository <https://github.com/OpenLinkSoftware/ai-agent-skills> .

:memoryCore a schema:CreativeWork ;
    schema:name "core.ttl (identity, credentials-by-reference, output routing)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/core.ttl> .

:memoryPreferences a schema:CreativeWork ;
    schema:name "preferences.ttl (standing instructions as schema:HowToStep)"@en ;
    schema:description "About 300 HowToStep entries that act as the operating contract. The file is read at every session start."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/preferences.ttl> .

:memoryIndex a schema:CreativeWork ;
    schema:name "index.ttl (session pointers)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/index.ttl> .

:memoryAgentsContract a schema:CreativeWork ;
    schema:name "agent-rdf-memory/AGENTS.md (retrieval and storage protocol)"@en ;
    schema:description "Defines the Step 0 load-path gate and the nine-step retrieval sequence. It also states the Turtle-only default serialization."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/AGENTS.md> .

:memoryOntology a schema:CreativeWork ;
    schema:name "ontology.ttl (custom vocabulary and prefixes)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/ontology.ttl> .

:memoryTermRegistry a schema:CreativeWork ;
    schema:name "entities/ontology-terms.ttl (corpus TBox registry)"@en ;
    schema:description "Registry of locally minted classes and properties that later documents should reuse. Its ComparisonDimension class is the canonical term this meshup binds to through the cdx: prefix."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/entities/ontology-terms.ttl> .

:memoryCheckGate a schema:SoftwareApplication ;
    schema:name "check-memory-gate.py (PreToolUse gate)"@en ;
    schema:description "Blocks Write and Edit calls outside agent-rdf-memory/ until core.ttl, preferences.ttl and index.ttl have been read in the session. It fails open on any internal error."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/scripts/check-memory-gate.py> .

:memoryProtocolValidator a schema:SoftwareApplication ;
    schema:name "validate-memory-protocol.py (transcript audit)"@en ;
    schema:description "Checks a Claude Code JSONL transcript for the five protocol steps as an audit trail after the session."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/scripts/validate-memory-protocol.py> .

:memorySessionGraphGate a schema:SoftwareApplication ;
    schema:name "session-graph-gate.py (SPARQL state check and sync)"@en ;
    schema:description "Compares local session graphs with named graphs in a SPARQL endpoint using ASK, COUNT and dateModified checks, then emits an isql or curl sync."@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/scripts/session-graph-gate.py> .

:memoryLoaderSql a schema:SoftwareSourceCode ;
    schema:name "load-agent-rdf-memory.sql (Virtuoso loader)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/scripts/load-agent-rdf-memory.sql> .

:memoryReuseHowTo a schema:HowTo ;
    schema:name "Cross-document local term reuse (howto)"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/blob/main/agent-rdf-memory/howto/cross-document-local-term-reuse.ttl> .

:meshupVocabulary a skos:ConceptScheme ;
    skos:prefLabel "Context-layer meshup vocabulary"@en .

:virtuoso a schema:SoftwareApplication ;
    schema:name "OpenLink Virtuoso"@en ;
    schema:url <https://virtuoso.openlinksw.com/> ;
    schema:description "Quad store and SQL engine that hosts URIBurner and can host the agent-rdf-memory named graphs, SPARQL endpoint, and RDF Views over relational tables."@en .

:collate a schema:SoftwareApplication ;
    schema:name "Collate"@en ;
    schema:sameAs <https://www.getcollate.io/product#this> .

:kgGenerator a schema:SoftwareApplication ;
    schema:name "kg-generator"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator> .

# ── Comparison dimensions (cdx:ComparisonDimension reused via bound prefix) ──

:assessesCollate a rdf:Property ;
    schema:name "assesses Collate"@en ;
    rdfs:domain cdx:ComparisonDimension ;
    rdfs:range xsd:string ;
    rdfs:isDefinedBy :ontology .

:assessesMemory a rdf:Property ;
    schema:name "assesses agent-rdf-memory"@en ;
    rdfs:domain cdx:ComparisonDimension ;
    rdfs:range xsd:string ;
    rdfs:isDefinedBy :ontology .

:dimInspectable a cdx:ComparisonDimension ;
    schema:name "Inspectable declarations"@en ;
    :assessesCollate "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."@en ;
    :assessesMemory "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."@en ;
    schema:position 1 .

:dimValidated a cdx:ComparisonDimension ;
    schema:name "Validated declarations"@en ;
    :assessesCollate "The article says metadata is checked with SHACL shapes, covering cardinality, datatypes, identifier formats and required ownership."@en ;
    :assessesMemory "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)."@en ;
    schema:position 2 .

:dimExportable a cdx:ComparisonDimension ;
    schema:name "Exportable declarations"@en ;
    :assessesCollate "The article describes Turtle, JSON-LD 1.1 contexts for each domain, and a documented API for export."@en ;
    :assessesMemory "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."@en ;
    schema:position 3 .

:dimStandards a cdx:ComparisonDimension ;
    schema:name "W3C standards alignment"@en ;
    :assessesCollate "The article says glossaries are SKOS, relationships are OWL object properties, and lineage uses PROV-O, with SHACL for validation."@en ;
    :assessesMemory "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."@en ;
    schema:position 4 .

:dimProvenance a cdx:ComparisonDimension ;
    schema:name "Provenance and history"@en ;
    :assessesCollate "Every entity is versioned, and each change to a description, owner or classification is emitted as an event on a timeline."@en ;
    :assessesMemory "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."@en ;
    schema:position 5 .

:dimLineage a cdx:ComparisonDimension ;
    schema:name "Lineage and graph structure"@en ;
    :assessesCollate "Lineage edges across sources, pipelines and dashboards, with transitive inference rules. Classifications propagate along lineage."@en ;
    :assessesMemory "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."@en ;
    schema:position 6 .

:dimAgentAccess a cdx:ComparisonDimension ;
    schema:name "Agent access path"@en ;
    :assessesCollate "An MCP server, an SDK, and natural-language chat over governed context, with SPARQL reachable through tools."@en ;
    :assessesMemory "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."@en ;
    schema:position 7 .

:dimSovereignty a cdx:ComparisonDimension ;
    schema:name "Sovereignty and lock-in"@en ;
    :assessesCollate "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."@en ;
    :assessesMemory "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."@en ;
    schema:position 8 .

:dimGovernance a cdx:ComparisonDimension ;
    schema:name "Governance and AI disclosure"@en ;
    :assessesCollate "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."@en ;
    :assessesMemory "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."@en ;
    schema:position 9 .

:dimScale a cdx:ComparisonDimension ;
    schema:name "Scale and deployment"@en ;
    :assessesCollate "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."@en ;
    :assessesMemory "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."@en ;
    schema:position 10 .

# ── Thesis claims (schema:Claim, load-bearing for the HTML hero) ──

:claimDeclared a schema:Claim ;
    schema:text "Context is a declared property of a system. A layer qualifies only when its declarations can be inspected, validated and exported."@en ;
    schema:citation <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/> ;
    schema:position 1 .

:claimGlossaryIsNotOntology a schema:Claim ;
    schema:text "A glossary becomes an ontology only when it adds typed relationships and axioms. Most vendor claims stop at labelled definitions."@en ;
    schema:citation <https://www.linkedin.com/pulse/context-layers-from-first-principles-jessica-talisman-eukpc/> ;
    schema:position 2 .

:claimRetrievedNotInvented a schema:Claim ;
    schema:text "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."@en ;
    schema:position 3 .

:claimVirtuosoBothSides a schema:Claim ;
    schema:text "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."@en ;
    schema:position 4 .

# ── Virtuoso angle (meshup step 3) ──

:virtuosoAngle a schema:CreativeWork ;
    schema:name "Virtuoso angle on Collate and agent-rdf-memory"@en ;
    schema:text "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."@en ;
    schema:about :virtuoso, :collate, :agentRdfMemory .

# ── HowTo ──

:howto a schema:HowTo ;
    schema:name "How to test a context layer against the article's three criteria"@en ;
    schema:description "A procedure for auditing a context layer, whether it is a product or a memory harness."@en ;
    schema:step :step1, :step2, :step3, :step4, :step5, :step6, :step7 ;
    schema:totalTime "PT30M"^^xsd:duration .

:step1 a schema:HowToStep ;
    schema:position 1 ;
    schema:name "Name the declarations"@en ;
    schema:text "List what the context consists of: classes, properties, glossary terms, constraints and provenance. Ask which of them the product or harness actually stores."@en .

:step2 a schema:HowToStep ;
    schema:position 2 ;
    schema:name "Test inspectability"@en ;
    schema:text "Find the declarations in a readable, open form, such as JSON Schema, Turtle, or plain files in version control. If the only view is a UI, mark the criterion as unmet."@en .

:step3 a schema:HowToStep ;
    schema:position 3 ;
    schema:name "Test validation"@en ;
    schema:text "Look for a machine check that rejects bad declarations: SHACL shapes, schema validation, or procedural gates. Record which kind it is, because a gate that reads files is not the same as a shape that constrains the graph."@en .

:step4 a schema:HowToStep ;
    schema:position 4 ;
    schema:name "Test export"@en ;
    schema:text "Export the declarations in at least one standard serialization, such as Turtle or JSON-LD, without a vendor-only step. Check that the export round-trips."@en .

:step5 a schema:HowToStep ;
    schema:position 5 ;
    schema:name "Check the W3C mapping"@en ;
    schema:text "Map each term to its standard: SKOS for glossaries, OWL for typed relations, PROV-O for provenance, SHACL for constraints. Mark any term with no standard counterpart."@en .

:step6 a schema:HowToStep ;
    schema:position 6 ;
    schema:name "Check the agent path"@en ;
    schema:text "Confirm that an agent retrieves declared facts through a query or tool call, and that the retrieved facts carry their IRIs. Test one question that a language model alone would answer wrongly."@en .

:step7 a schema:HowToStep ;
    schema:position 7 ;
    schema:name "Score and publish the result"@en ;
    schema:text "Score each comparison dimension with its evidence. Label vendor-reported figures as such, and keep your own measurements separate."@en .

# ── FAQ ──

:faqSection a schema:FAQPage ;
    schema:name "Frequently asked questions: Context Layers meshup"@en ;
    schema:mainEntity :q1, :q2, :q3, :q4, :q5, :q6, :q7, :q8, :q9, :q10, :q11, :q12 ;
    schema:hasPart :q1, :q2, :q3, :q4, :q5, :q6, :q7, :q8, :q9, :q10, :q11, :q12 .

:q1 a schema:Question ;
    schema:name "What test does the article propose for a context layer?"@en ;
    schema:acceptedAnswer :a1 .
:a1 a schema:Answer ;
    schema:text "A context layer qualifies only when its declarations can be inspected, validated and exported, with the declarations in open standards."@en .

:q2 a schema:Question ;
    schema:name "Why is the word 'context' hard to pin down?"@en ;
    schema:acceptedAnswer :a2 .
:a2 a schema:Answer ;
    schema:text "Vendors use it for different things, such as a search index, a prompt assembly service or a glossary with a chat window. The article's point is that few state what the context consists of or who declared it."@en .

:q3 a schema:Question ;
    schema:name "What does Collate build on?"@en ;
    schema:acceptedAnswer :a3 .
:a3 a schema:Answer ;
    schema:text "Collate is the commercial product built on OpenMetadata, an open-source project licensed Apache 2.0. Its entity model is published as more than 700 JSON Schemas."@en .

:q4 a schema:Question ;
    schema:name "Which W3C standards does the article credit Collate with?"@en ;
    schema:acceptedAnswer :a4 .
:a4 a schema:Answer ;
    schema:text "RDF, OWL, SKOS, SHACL and PROV-O, plus JSON-LD 1.1 contexts for export. The article also notes that the RDF graph is a Beta feature, disabled by default."@en .

:q5 a schema:Question ;
    schema:name "Does agent-rdf-memory use SHACL shapes?"@en ;
    schema:acceptedAnswer :a5 .
:a5 a schema:Answer ;
    schema:text "Yes, since 2026-10-08. shapes/memory-shapes.ttl constrains session document entities, index list items and HowTo steps, and pyshacl checks them. The shapes are report-only: at build time 231 of 320 session files conform, and the failures are reported rather than fixed. The procedural gates (check-memory-gate.py, validate-memory-protocol.py, session-graph-gate.py) still run alongside them."@en .

:q6 a schema:Question ;
    schema:name "Why does agent-rdf-memory use Turtle only?"@en ;
    schema:acceptedAnswer :a6 .
:a6 a schema:Answer ;
    schema:text "AGENTS.md makes Turtle the default serialization and reserves other formats for when a user names them. That keeps one canonical syntax that is readable by both humans and agents."@en .

:q7 a schema:Question ;
    schema:name "How does agent-rdf-memory decide what to read at session start?"@en ;
    schema:acceptedAnswer :a7 .
:a7 a schema:Answer ;
    schema:text "AGENTS.md defines a nine-step retrieval sequence. It reads core.ttl, preferences.ttl and index.ttl, follows references to howto files, and prefers a SPARQL endpoint when one is recorded, with file reads as the fallback."@en .

:q8 a schema:Question ;
    schema:name "What is the 'Virtuoso angle' on a context layer?"@en ;
    schema:acceptedAnswer :a8 .
:a8 a schema:Answer ;
    schema:text "Virtuoso keeps the relational store as the source of truth and derives RDF through RDF Views. It then exposes IRIs, SPARQL, named graphs and inference over one substrate."@en .

:q9 a schema:Question ;
    schema:name "What does the 59%-to-94% benchmark show?"@en ;
    schema:acceptedAnswer :a9 .
:a9 a schema:Answer ;
    schema:text "Collate reports that text-to-SQL execution accuracy rose from 59% to 94% on a subset of Spider 2.0-Snow when its context layer was in scope, with the model held constant. The article says this figure is Collate's own and should be read that way."@en .

:q10 a schema:Question ;
    schema:name "Where does agent-rdf-memory lose to Collate?"@en ;
    schema:acceptedAnswer :a10 .
:a10 a schema:Answer ;
    schema:text "On lineage, governance reporting, and event-level provenance, and on validation coverage: its SHACL shapes check structure only and are report-only, with failures in older files. Its scale depends on the platform it runs on: a Virtuoso deployment can serve enterprise workloads. Its design goal is loose coupling, not a catalog."@en .

:q11 a schema:Question ;
    schema:name "Where does agent-rdf-memory win over Collate?"@en ;
    schema:acceptedAnswer :a11 .
:a11 a schema:Answer ;
    schema:text "On inspectability at the file level and on local sovereignty. Every declaration is a plain Turtle file in git, and credentials stay in the Keychain rather than in declarations."@en .

:q12 a schema:Question ;
    schema:name "Is this collection the article's official companion?"@en ;
    schema:acceptedAnswer :a12 .
:a12 a schema:Answer ;
    schema:text "No. It is commentary taken about the article, with the agent-rdf-memory comparison added. The article itself and its author's own companion tools are the authoritative sources."@en .

# ── Glossary ──

:glossarySet a schema:DefinedTermSet ;
    schema:name "Context layer meshup glossary"@en ;
    schema:hasDefinedTerm :termContextLayer, :termOntology, :termGlossary, :termSHACL, :termSKOS, :termPROVO, :termJSONSchema, :termRDFMemory, :termTurtle, :termNamedGraph, :termResolver, :termSPARQLAsk ;
    schema:inDefinedTermSet :glossarySet .

:termContextLayer a schema:DefinedTerm ;
    schema:name "Context layer"@en ;
    schema:description "A declared property of a system, structured through concepts, vocabularies, typed relationships, provenance and constraints."@en ;
    schema:inDefinedTermSet :glossarySet .
:termOntology a schema:DefinedTerm ;
    schema:name "Ontology"@en ;
    schema:description "A glossary with typed classes and properties, plus axioms that support inference. A glossary with a hierarchy alone does not meet this bar."@en ;
    schema:inDefinedTermSet :glossarySet .
:termGlossary a schema:DefinedTerm ;
    schema:name "Glossary"@en ;
    schema:description "A set of agreed names and definitions. The article treats it as the first, weakest layer, modeled as a SKOS concept scheme."@en ;
    schema:inDefinedTermSet :glossarySet .
:termSHACL a schema:DefinedTerm ;
    schema:name "SHACL"@en ;
    schema:description "The W3C Shapes Constraint Language, used to check cardinality, datatypes, identifiers and ownership against a graph."@en ;
    schema:inDefinedTermSet :glossarySet .
:termSKOS a schema:DefinedTerm ;
    schema:name "SKOS"@en ;
    schema:description "The W3C Simple Knowledge Organization System. Glossary terms map to SKOS concepts, with match strength declared."@en ;
    schema:inDefinedTermSet :glossarySet .
:termPROVO a schema:DefinedTerm ;
    schema:name "PROV-O"@en ;
    schema:description "The W3C provenance ontology, used for derivation, generation and attribution."@en ;
    schema:inDefinedTermSet :glossarySet .
:termJSONSchema a schema:DefinedTerm ;
    schema:name "JSON Schema"@en ;
    schema:description "A machine-readable schema language for JSON documents. Collate defines each entity in it before generating code."@en ;
    schema:inDefinedTermSet :glossarySet .
:termRDFMemory a schema:DefinedTerm ;
    schema:name "RDF memory"@en ;
    schema:description "Agent memory stored as RDF, here as Turtle files that record standing rules and session facts."@en ;
    schema:inDefinedTermSet :glossarySet .
:termTurtle a schema:DefinedTerm ;
    schema:name "Turtle"@en ;
    schema:description "A compact text syntax for RDF triples, the default serialization in agent-rdf-memory."@en ;
    schema:inDefinedTermSet :glossarySet .
:termNamedGraph a schema:DefinedTerm ;
    schema:name "Named graph"@en ;
    schema:description "A set of triples identified by its own IRI. Virtuoso uses named graphs to scope queries to a session or dataset."@en ;
    schema:inDefinedTermSet :glossarySet .
:termResolver a schema:DefinedTerm ;
    schema:name "Resolver link"@en ;
    schema:description "A link that opens an IRI through a describe service. This page uses the URIBurner describe pattern."@en ;
    schema:inDefinedTermSet :glossarySet .
:termSPARQLAsk a schema:DefinedTerm ;
    schema:name "SPARQL ASK"@en ;
    schema:description "A SPARQL query form that returns true or false. session-graph-gate.py uses it to check whether a named graph exists and is in sync."@en ;
    schema:inDefinedTermSet :glossarySet .

# ── Sections (HTML anchors) ──

:comparisonSection a schema:CreativeWork ;
    schema:name "Collate and agent-rdf-memory, head to head"@en ;
    schema:hasPart :dimInspectable, :dimValidated, :dimExportable, :dimStandards, :dimProvenance, :dimLineage, :dimAgentAccess, :dimSovereignty, :dimGovernance, :dimScale .

# ── Related reads (URIBurner weblog cross-references; paraphrased summaries) ──

:relatedRead1 a schema:CreativeWork ;
    schema:name "Enterprise Context Layer Meshup"@en ;
    schema:description "Meshup of an Atlan field guide on the enterprise context layer. It argues the layer is distinct from a catalog, semantic layer, knowledge graph, RAG or memory, and organizes it as meaning, practice and norms."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=atlan-enterprise-context-layer-meshup-gpt5-1.html> ;
    schema:position 1 .

:relatedRead2 a schema:CreativeWork ;
    schema:name "Semantic and Context Layers via Open Standards"@en ;
    schema:description "Architecture note placing the context layer as the enclosing ontology, with TBox, RBox and ABox over RDF, and keeping the model separate from its notations."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=semantic-context-layers-open-standards-gpt5-chat-1.html> ;
    schema:position 2 .

:relatedRead3 a schema:CreativeWork ;
    schema:name "Keeping Agent Knowledge Under Your Own Control: Neo4j EKL vs. agent-rdf-memory"@en ;
    schema:description "Side-by-side of Neo4j's enterprise knowledge layer and agent-rdf-memory on eleven dimensions, with each row drawn only from the two source articles."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=neo4j-ekl-vs-agent-rdf-memory-claude_sonnet_5-1.html> ;
    schema:position 3 .

:relatedRead4 a schema:CreativeWork ;
    schema:name "Rent the Intelligence, Own the Relationship: Context Engine vs. Context Infrastructure"@en ;
    schema:description "Contrasts a vendor-held context engine with six loosely coupled layers: identity, identification, authentication, authorization, data spaces and related concerns. It is directly about lock-in."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=context-engine-vs-context-infrastructure-claude_sonnet_5-1.html> ;
    schema:position 4 .

:relatedRead5 a schema:CreativeWork ;
    schema:name "How agent-rdf-memory Aligns With the Agent Engineering Stack"@en ;
    schema:description "Maps an eleven-layer agent engineering stack onto the files of the agent-rdf-memory repository, layer by layer, with coverage scored per layer."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=agent-rdf-memory-stack-alignment-inline-links.html> ;
    schema:position 5 .

:relatedRead6 a schema:CreativeWork ;
    schema:name "Grok Bot & The Fourth Moment of AI: the OpenLink RDF Memory Platform-Agnostic Harness"@en ;
    schema:description "Argues from platform dilemmas across the AI stack that a decoupled, platform-agnostic memory harness is a strategic position. It is commentary, and its claims are the author's."@en ;
    schema:url <https://linkeddata.uriburner.com/weblog/?post=grok-bot-fourth-moment-ai-harnesses-gemini_3_7_flash-1.html> ;
    schema:position 6 .

:relatedReads a schema:ItemList ;
    schema:name "Related reads on the URIBurner weblog"@en ;
    schema:itemListElement :relatedRead1, :relatedRead2, :relatedRead3, :relatedRead4, :relatedRead5, :relatedRead6 .
