Enterprise AI 200-Millisecond Problem wired by agent-rdf-memory

200 ms to pick 20k tokens. Graph is wiring; SPARQL is the spinal cord.

KG curated by kg-generator, rdf-infographic-skill, and Grok on behalf of Kingsley Idehen

Executive SummaryBy Dan McCreary · Context and Chaos · 2026-08-27

Synopsis¶

An employee asks a question. The answer exists, split across systems that were never designed to be read together. The model will accept roughly 20,000 tokens of that answer. The retrieval path has about 200 milliseconds to decide which 20,000. Pick the wrong slice and the model hallucinates. Pick the right slice too slowly and nobody uses it. Pick the right slice fast and expensive and the CFO has a problem.

Dan McCreary's thesis is that the knowledge graph is not the context layer. It is the wiring inside the context layer: a compact, versioned, acyclic, typed dependency graph whose grain is 100 to 600 concepts, distilled before runtime so the agent never walks it at execution time. Andrew Lentz drew that line first. OpenLink's agent-rdf-memory agrees on the authoring side and disagrees on the runtime side: the agent does query RDF at session start, via a mandatory SPARQL protocol that loads core plus ontology plus a sparse preferences index, classifies the prompt, and SELECTs exactly one HowTo. That SPARQL hop is the 200-millisecond spinal cord, not a contradiction of distillation.

This graph maps McCreary's dual budget, four-layer decision traces, modeling choices, plumbing, and failure modes onto nine explicit agent-rdf-memory mechanisms. The disagreement is a first-class claim, not a footnote.

SourcesYour Agent Doesn't Need to Walk the Graph Benchmarking Knowledge Retrieval Architectures Across Educational and Commercial Domains Agent RDF Memory README AGENTS.md RDF Memory Protocol SESSION-START-HOOK.md agent-rdf-memory ontology.ttl agent-rdf-memory core.ttl How agent-rdf-memory Aligns With the Agent Engineering Stack

“Your model will accept roughly 20,000 tokens of it. Your retrieval path has about 200-milliseconds to decide which twenty thousand.”

View this analysis as a KG entity

HEAD TO HEAD

Comparison Matrix¶

0 convergent0 divergent0 unaddressed

Dimension	McCreary — distillation at runtimeAuthoring / distillation	OpenLink — SPARQL at session startRuntime retrieval protocol
Does the agent query the graph at runtime?disagrees withThe first-class tension. McCreary says never. OpenLink says SPARQL at session start.	never at execution timeAuthoring versus runtime query are separate. The agent never touches the graph.	SPARQL at session startMandatory protocol queries RDF before the model answers. Bounded SELECT, not a walk.
Fallback when the preferred path failscompared toRebuild the artifact versus AGENTS.md step 8 file-read.	rebuild the versioned artifactIf the compact graph is stale, rebuild it. Do not let the agent walk a live second database.	AGENTS.md step 8 file-readWhen SPARQL is unavailable, read Turtle from disk. Degraded, not preferred.
Grain of the compact graphaligned withAgreement: 100-600 concepts; 9 HowTos / 105 steps sit in band.	100 to 600 conceptsCoarse enough to reason over, fine enough to be useful.	9 HowTos / 105 stepspreferences.ttl already sits in that grain band.
How the 20,000 tokens are chosencompared toPrecomputed bounded subgraph versus ontology-routed SPARQL.	precomputed bounded subgraphPersonalised PageRank, centrality, typed deps, stopping rule against context poisoning.	PromptIntent plus RetrievalPolicyClassify intent, apply policy, requiresHowTo, preferredContextSource.
Persist why, not just whataligned withAgreement: decision traces and MemoryWriteTrigger.	four-layer decision traceException, precedent, cross-system synthesis, out-of-band approval.	sessions/*.ttl plus MemoryWriteTriggerWrite the why when the trigger fires. Episodic memory is the trace store.
Typed edges versus RELATED_TOaligned withAgreement: both reject generic RELATED_TO.	PREREQUISITE_OF / DEPENDS_ON / PART_OFTyped edges. The type is the instruction. RELATED_TO is a shrug.	requiresHowTo / preferredContextSource / MemoryWriteTriggerOntology properties are typed instructions, never generic related-to.
What the agent actually readscompared toDistilled artifact versus SELECT-bounded HowTo Turtle.	a distillationThe compact graph is distilled out; the agent reads that artifact.	one HowTo after SELECTThe agent reads core + ontology + index, then exactly one howto/*.ttl.
Where the spinal cord livescompared toBuilt entirely upstream, or built upstream and fired as a SPARQL reflex.	upstream wiring onlyBiology analogy: spinal cord built in advance. Runtime does not invent a path.	SPARQL reflex over prebuilt wiringWiring is still built in advance (ontology + preferences). The reflex is the SELECT.

McCreary — distillation at runtimeAuthoring / distillation

Does the agent query the graph at runtime?disagrees with

never at execution timeAuthoring versus runtime query are separate. The agent never touches the graph.

Fallback when the preferred path failscompared to

rebuild the versioned artifactIf the compact graph is stale, rebuild it. Do not let the agent walk a live second database.

Grain of the compact graphaligned with

100 to 600 conceptsCoarse enough to reason over, fine enough to be useful.

How the 20,000 tokens are chosencompared to

precomputed bounded subgraphPersonalised PageRank, centrality, typed deps, stopping rule against context poisoning.

Persist why, not just whataligned with

four-layer decision traceException, precedent, cross-system synthesis, out-of-band approval.

Typed edges versus RELATED_TOaligned with

PREREQUISITE_OF / DEPENDS_ON / PART_OFTyped edges. The type is the instruction. RELATED_TO is a shrug.

What the agent actually readscompared to

a distillationThe compact graph is distilled out; the agent reads that artifact.

Where the spinal cord livescompared to

upstream wiring onlyBiology analogy: spinal cord built in advance. Runtime does not invent a path.

OpenLink — SPARQL at session startRuntime retrieval protocol

Does the agent query the graph at runtime?disagrees with

SPARQL at session startMandatory protocol queries RDF before the model answers. Bounded SELECT, not a walk.

Fallback when the preferred path failscompared to

AGENTS.md step 8 file-readWhen SPARQL is unavailable, read Turtle from disk. Degraded, not preferred.

Grain of the compact graphaligned with

9 HowTos / 105 stepspreferences.ttl already sits in that grain band.

How the 20,000 tokens are chosencompared to

PromptIntent plus RetrievalPolicyClassify intent, apply policy, requiresHowTo, preferredContextSource.

Persist why, not just whataligned with

sessions/*.ttl plus MemoryWriteTriggerWrite the why when the trigger fires. Episodic memory is the trace store.

Typed edges versus RELATED_TOaligned with

requiresHowTo / preferredContextSource / MemoryWriteTriggerOntology properties are typed instructions, never generic related-to.

What the agent actually readscompared to

one HowTo after SELECTThe agent reads core + ontology + index, then exactly one howto/*.ttl.

Where the spinal cord livescompared to

SPARQL reflex over prebuilt wiringWiring is still built in advance (ontology + preferences). The reflex is the SELECT.

Section 1

The 200-millisecond clock ¶

The employee asks. The answer exists. The window is 20,000 tokens. The clock is 200 milliseconds. Latency and cost are a dual budget.

100-600concepts

Right grain

McCreary's modeling grain: coarse enough to reason over, fine enough to be useful.

2614tokens

Compact KG

Hold loosely: compact knowledge graph size after encoding.

20000tokens

Context window

Rough size of the slice the model will accept.

22percent

CRM discount anecdote

The number CRM knows, without the four-layer decision trace behind it.

200milliseconds

Retrieval budget

Time the retrieval path has to choose which 20,000 tokens.

~1000x

Compression

Hold loosely: Reasoning Density Score compression claimed for the clinical-trial corpus.

9 HowTos / 105 steps

agent-rdf-memory map

Sparse hub in preferences.ttl; full specs live in howto/*.ttl via rdfs:seeAlso.

2680000tokens

Clinical trial corpus

Hold loosely: source corpus size in the still-in-preprint Yarmoluk/McCreary benchmark.

Section 2

Three ways to miss the budget ¶

Wrong 20,000: hallucination. Right but four seconds: unused. Right, fast, and expensive: the CFO has a problem.

Wrong 20,000 tokens

The retrieval path selected a slice that looks similar but is not the decision. The model fills the gaps. That is hallucination dressed as synthesis.

Right answer in four seconds

Correct tokens arrived after the conversation had moved on. Unused is a product failure even when the graph is right.

Right, fast, and expensive

The compact graph McCreary wants costs about a tenth of a cent per query. Unbounded context stuffing does not. The CFO notices.

Section 3

Graph as wiring, not as the context layer ¶

Vector search asks what looks like this. Business asks what is connected, how, who approved, and the last three times. The spinal cord is built in advance.

Graph as wiring → hub-and-spoke preferences.ttl

Hub-and-spoke: sparse index in memory, full HowTo loaded only after SPARQL SELECT.

The graph is wiring inside the context layer, not the context layer

Vector search answers what looks like this. Business questions ask what is connected, how, who approved, and the last three times. Biology analogy: spinal cord wiring is built in advance so the signal does not have to invent a path.

Section 4

Four layers of the decision trace ¶

The atomic unit is not a document, a table, or a metric. It is a decision: exception logic, historical precedent, cross-system synthesis, out-of-band approval.

Exception logic

Why this case left the default rule. Typed RDF, never RELATED_TO: the exception is a first-class edge with a reason.

Historical precedent

The last three times this exception happened. sessions/*.ttl episodic memory is where agent-rdf-memory persists those traces.

Cross-system synthesis

Facts that only exist when CRM, ERP, tickets, and a hallway conversation are read together. Virtuoso UDA/ODBC plus named graphs is the plumbing.

Out-of-band approval

The VP in the hallway. MemoryWriteTrigger says persist the why, not just the what, when an approval leaves the system of record.

Section 5

Three modeling choices ¶

Acyclic dependency graph. Typed edges rather than RELATED_TO. Grain of 100 to 600 concepts.

Acyclic dependency graph

A DAG so retrieval can walk prerequisites without looping. Cycles are context poisoning waiting to happen.

Typed edges, not RELATED_TO

PREREQUISITE_OF, DEPENDS_ON, PART_OF. The type is the instruction. A generic edge is a shrug. agent-rdf-memory uses requiresHowTo, preferredContextSource, MemoryWriteTrigger.

Grain of 100 to 600 concepts

Coarse enough to reason over, fine enough to be useful. Nine HowTo themes and 105 steps sit in that band.

Section 6

Reasoning density: Turtle over stuffed markdown ¶

Hold loosely: 2.68 million tokens of clinical-trial corpus became a 2,614-token compact KG, roughly 1000x. Reasoning Density Score is F1 over tokens.

Reasoning density → Turtle; load core + ontology + index, then SELECT

Measure the tokens. Hold the 2.68M → 2,614 preprint loosely.

Reasoning Density Score equals F1 over tokens

Hold loosely: a still-in-preprint clinical-trial corpus of 2.68 million tokens encoded as a compact knowledge graph of 2,614 tokens, roughly a thousandfold compression, co-authored with Daniel Yarmoluk.

Section 7

Plumbing that already exists ¶

Semantic layers, ISO 11179 definitions, process mining, lineage, provenance, bitemporal modeling. Not new infrastructure.

Semantic layer

Business meaning already modeled above the warehouses. The graph should consume that layer, not replace it.

ISO 11179 definitions

Precise, non-circular definitions. The highest-compression token in the building.

Process mining, lineage, provenance

Where the number came from, which job produced it, who signed it. Named graphs plus SPARQL provenance patterns.

Bitemporal modeling

Valid time versus transaction time. The hallway approval entered a week later is a bitemporal fact, not a bug.

Section 8

Where structure does not pay ¶

Single-hop lookup. Corpora without a dependency lattice. Content that churns faster than the graph can be rebuilt.

Single-hop lookup

Already served by a database. Do not pay graph tax for a primary key.

No dependency lattice

Support tickets and news items are similar, not prerequisite. Vector search is the honest tool.

Churn faster than rebuild

If the graph cannot be rebuilt before the facts rotate, the compact artifact is a lie about yesterday.

Section 9

The runtime-query disagreement is first-class ¶

McCreary, with Lentz: the agent reads a distillation and never touches the graph at execution time. OpenLink: the agent SPARQL-queries RDF at session start. Both can be true if the SPARQL SELECT is itself the distillation.

OpenLink: the agent SPARQL-queries RDF at session start

agent-rdf-memory's mandatory retrieval protocol: load core.ttl, load preferences.ttl, overlay private preferences if present, load ontology.ttl, load index.ttl, classify the prompt against PromptIntent, SPARQL SELECT the matching HowTo, load that one howto/*.ttl. File-read fallback is AGENTS.md step 8, not the happy path. The SPARQL hop is the 200-millisecond spinal cord.

McCreary: the agent never touches the graph at execution time

Agreeing with Andrew Lentz: authoring the graph and querying it at runtime are separate decisions. Everything below the distillation is authoring. The compact graph is a versioned build artifact, not a second database the agent walks.

Section 10

SPARQL retrieval protocol as spinal cord ¶

Nine steps from core.ttl to one HowTo. That sequence is the 200-millisecond spinal cord: wiring built in advance so the signal does not invent a path.

Load core.ttl

Load identity and path routing from core.ttl. Do not copy secrets into public graphs.

Load preferences.ttl

Load the sparse hub: 9 HowTo themes, 105 schema:step pointers. This is the wiring index, not the full specs.

Overlay private preferences if present

If a private preferences graph exists, overlay it. Local policy wins without forking the shared hub.

Load ontology.ttl

Load PromptIntent, RetrievalPolicy, requiresHowTo, preferredContextSource, MemoryWriteTrigger. This is the router, not the content.

Load index.ttl

Load the HowTo index so SPARQL can SELECT without opening every howto/*.ttl.

Classify the prompt against PromptIntent

Map the user prompt onto a PromptIntent. Classification is the 200 ms decision of which 20k, expressed as a typed intent rather than a vector nearest-neighbor.

SPARQL SELECT the matching HowTo

Bounded SELECT: one intent, one HowTo IRI, optional preferredContextSource. Not a graph walk. The result is the distillation.

Load one howto/*.ttl, or file-read fallback

Load the single selected HowTo. If SPARQL is unavailable, AGENTS.md step 8 permits reading the Turtle from disk. Fallback is degraded mode.

Write the session trace

If MemoryWriteTrigger fires, persist why not just what into sessions/*.ttl: exception, precedent, synthesis, out-of-band approval.

Section 11

Critical perspective: SPARQL as bounded distillation ¶

The disagreement is real and should stay visible. The synthesis is that ontology-routed SPARQL is the distillation step, not a contradiction of it.

How-To

How-To Guide¶

Map McCreary's thesis onto agent-rdf-memory

Nine explicit schema:Claim / how-to mappings. Not a slide dump: each step names the problem, the OpenLink mechanism, and the RDF types that carry it.

200 ms token selection → ontology-routed SPARQL

PromptIntent, RetrievalPolicy, requiresHowTo, preferredContextSource. Topological retrieval, not similarity.

Graph as wiring → hub-and-spoke preferences.ttl

Hub-and-spoke: sparse index in memory, full HowTo loaded only after SPARQL SELECT.

Decision trace → sessions/*.ttl plus MemoryWriteTrigger

Atomic unit is the decision, encoded as RDF session traces.

Four layers → typed RDF properties, never RELATED_TO

Typed edges: exception, precedent, synthesis, approval.

Acyclic typed deps and right grain → 9 HowTos / 105 steps

Right grain, DAG, typed deps. Not a vector soup.

Reasoning density → Turtle; load core + ontology + index, then SELECT

Measure the tokens. Hold the 2.68M → 2,614 preprint loosely.

Plumbing → Virtuoso named graphs, SPARQL, UDA/ODBC

Not new infrastructure. Virtuoso is the existing spinal cord hardware.

Runtime disagreement IS the 200 ms spinal cord

First-class disagreement. Both claims stay in the graph, linked by disagreesWith.

File fallback when SPARQL is unavailable

Degraded mode. Do not confuse file-read with the protocol.

Run the agent-rdf-memory session-start protocol

Mandatory retrieval sequence from README, AGENTS.md, and SESSION-START-HOOK.md. SPARQL preferred; file-read is step 8 only.

Load core.ttl

Load identity and path routing from core.ttl. Do not copy secrets into public graphs.

Load preferences.ttl

Load the sparse hub: 9 HowTo themes, 105 schema:step pointers. This is the wiring index, not the full specs.

Overlay private preferences if present

If a private preferences graph exists, overlay it. Local policy wins without forking the shared hub.

Load ontology.ttl

Load PromptIntent, RetrievalPolicy, requiresHowTo, preferredContextSource, MemoryWriteTrigger. This is the router, not the content.

Load index.ttl

Load the HowTo index so SPARQL can SELECT without opening every howto/*.ttl.

Classify the prompt against PromptIntent

Map the user prompt onto a PromptIntent. Classification is the 200 ms decision of which 20k, expressed as a typed intent rather than a vector nearest-neighbor.

SPARQL SELECT the matching HowTo

Bounded SELECT: one intent, one HowTo IRI, optional preferredContextSource. Not a graph walk. The result is the distillation.

Load one howto/*.ttl, or file-read fallback

Load the single selected HowTo. If SPARQL is unavailable, AGENTS.md step 8 permits reading the Turtle from disk. Fallback is degraded mode.

Write the session trace

If MemoryWriteTrigger fires, persist why not just what into sessions/*.ttl: exception, precedent, synthesis, out-of-band approval.

FAQ

Frequently Asked Questions¶

What is the 200-millisecond problem?▼

An employee asks a question whose answer is split across systems never designed to be read together. The model accepts roughly 20,000 tokens. The retrieval path has about 200 milliseconds to choose which 20,000. Latency and cost are a dual budget.

What happens if retrieval misses that budget?▼

Wrong 20,000 tokens: the model hallucinates. Right tokens in four seconds: unused. Right, fast, and expensive: the CFO has a problem.

Is the knowledge graph the context layer?▼

No. McCreary: the graph is wiring inside a context layer, not the context layer itself. Vector search asks what looks like this. Business asks what is connected, how, who approved, and the last three times.

What is the atomic unit of useful context?▼

A decision trace, not a document, table, or metric. Four layers: exception logic, historical precedent, cross-system synthesis, out-of-band approval. CRM knows the 22 percent discount; it does not know the hallway approval.

What modeling choices does McCreary require?▼

An acyclic dependency graph, typed edges (PREREQUISITE_OF, DEPENDS_ON, PART_OF) rather than RELATED_TO, and a grain of 100 to 600 concepts.

What is Reasoning Density Score?▼

F1 over tokens. Hold loosely: a still-in-preprint clinical-trial corpus of 2.68 million tokens encoded as a 2,614-token compact knowledge graph, roughly 1000x, co-authored with Daniel Yarmoluk.

Does this require new infrastructure?▼

No. Semantic layers, ISO 11179, process mining, lineage, provenance, bitemporal modeling. OpenLink maps them onto Virtuoso named graphs, SPARQL, and UDA/ODBC. Prukalpa Sankar: a graph on ungoverned content is a semantic-layer failure with better response times.

Where does structure not pay?▼

Single-hop lookup already served by a database. Corpora without a dependency lattice, such as support tickets or news. Content that churns faster than the graph can be rebuilt.

Do McCreary and OpenLink agree that the agent should query the graph at runtime?▼

No. That disagreement is first-class. McCreary, with Andrew Lentz: the agent reads a distillation and never touches the graph at execution time. OpenLink agent-rdf-memory: mandatory SPARQL at session start (core, preferences, ontology, SELECT one HowTo). The SELECT is a bounded distillation; that hop is the 200-millisecond spinal cord.

How does agent-rdf-memory choose the 20,000 tokens?▼

Ontology-routed SPARQL. Classify the prompt as a PromptIntent, apply RetrievalPolicy, follow requiresHowTo and preferredContextSource, SELECT one HowTo. Topological, not cosine-similar.

What is hub-and-spoke in preferences.ttl?▼

A sparse index of 9 HowTo themes and 105 schema:step pointers. Full specifications live in howto/*.ttl behind rdfs:seeAlso. Progressive disclosure is the distillation the agent actually walks.

What happens if SPARQL is unavailable?▼

AGENTS.md step 8: read the HowTo Turtle from disk. Fallback is a degraded spinal reflex, not the architecture. Happy path remains ontology-routed SELECT.

How does agent-rdf-memory persist decision traces?▼

sessions/*.ttl episodic memory plus ontology MemoryWriteTrigger. Persist why, not just what, when exception logic, precedent, cross-system synthesis, or out-of-band approval fires.

Who drew the authoring-versus-runtime line McCreary accepts?▼

Andrew Lentz, in Your Agent Doesn't Need to Walk the Graph. Lentz: storing context in a graph can be right; hooking that graph up to the agent almost never is. McCreary agrees on the authoring side. OpenLink still queries RDF at session start, but as a bounded SELECT rather than a walk.

Glossary

Glossary of Terms¶

SPARQL

RDF query language. In agent-rdf-memory it is the 200-millisecond spinal cord: ontology-routed SELECT against named graphs after prompt-intent classification.

PageRank

McCreary's retrieval ranking: personalised PageRank seeded on entities in the question ranks which related records bear on this query rather than on the graph as a whole.

ISO 11179

Metadata registry standard McCreary cites for precise, non-circular definitions — the highest-compression token in the building.

Knowledge graph

McCreary: the graph is wiring inside a context layer, not the context layer itself. OpenLink: a queryable RDF memory the agent SPARQL-selects at session start.

RDF

W3C graph data model. agent-rdf-memory encodes the behavioral contract, preferences, ontology, and session traces as RDF-Turtle.

Turtle

RDF serialization used as the compact, versioned build artifact. McCreary's reasoning-density argument: Turtle over stuffed markdown.

Decision trace

McCreary's atomic unit of useful context: exception logic, historical precedent, cross-system synthesis, and out-of-band approval. Not a document, table, or metric.

Reasoning Density Score

F1 divided by tokens. Hold loosely: 2.68 million tokens of clinical-trial corpus to a 2,614-token compact KG, roughly 1000x, in the still-in-preprint Yarmoluk/McCreary benchmark.

PromptIntent

agent-rdf-memory ontology class. Classifying the user prompt against PromptIntent is how the 200-millisecond token choice is made without vector similarity.

Hub-and-spoke preferences

preferences.ttl holds sparse schema:step pointers (9 themes, 105 steps). howto/*.ttl holds full specs via rdfs:seeAlso. Progressive disclosure is the distillation.

MemoryWriteTrigger

Ontology signal to persist why, not just what, into sessions/*.ttl when a decision-trace layer fires.

Bounded subgraph

McCreary: personalised PageRank, centrality, typed dependencies, and a stopping rule against context poisoning. OpenLink: SPARQL SELECT of one HowTo.

Bitemporal

Valid time versus transaction time. The hallway approval entered a week later is a bitemporal fact, not a bug.

Context poisoning

What happens without a stopping rule: the model drowns in related-but-not-bearing records. A bounded retrieval is a bounded token count.

Spinal cord (context wiring)

McCreary's biology analogy: wiring built in advance so the signal does not invent a path. OpenLink: the 9-step SPARQL retrieval protocol is that reflex over prebuilt wiring.

Knowledge Graph Explorer 254 nodes · 837 links ¶

Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.

Enterprise AI 200-Millisecond Problem wired by agent-rdf-memory

Nodes: 0 Links: 0

Click SVG to activate zoom, click outside to release | Drag nodes to pin, double-click to unpin

Classes Properties Instances

SPARQL Workbench 13 sample queries ¶

Query this knowledge graph on URIBurner. The editor opens on the canonical SAMPLE entity-type summary (DAV named graph). Pick a recipe, edit freely, then run live or copy.

Sample Queries

Reproduced verbatim from the companion RDF. Execute loads the query into the workbench below and runs it live.

SELECT thesis claims and their solution mappings


PREFIX : <https://contextandchaos.substack.com/p/enterprise-ais-200-millisecond-problem#>
PREFIX schema: <http://schema.org/>
SELECT ?claimIri ?claim ?mappingIri ?mapping
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl>
WHERE {
  ?claimIri a :ThesisClaim ;
            schema:name ?claim ;
            :mapsProblemTo ?mappingIri .
  ?mappingIri schema:name ?mapping .
}
ORDER BY ?claim

SELECT the first-class runtime-query disagreement


PREFIX : <https://contextandchaos.substack.com/p/enterprise-ais-200-millisecond-problem#>
PREFIX schema: <http://schema.org/>
SELECT ?leftIri ?left ?rightIri ?right
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl>
WHERE {
  ?leftIri :disagreesWith ?rightIri ;
           schema:name ?left ;
           schema:description ?leftDesc .
  ?rightIri schema:name ?right .
  FILTER(STR(?leftIri) < STR(?rightIri))
}

SELECT the nine-step retrieval protocol in order


PREFIX : <https://contextandchaos.substack.com/p/enterprise-ais-200-millisecond-problem#>
PREFIX schema: <http://schema.org/>
SELECT ?stepIri ?position ?name
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl>
WHERE {
  ?stepIri a :RetrievalProtocolStep ;
           schema:position ?position ;
           schema:name ?name .
}
ORDER BY ?position

SELECT comparison positions by dimension and subject


PREFIX : <https://contextandchaos.substack.com/p/enterprise-ais-200-millisecond-problem#>
PREFIX schema: <http://schema.org/>
SELECT ?dimIri ?dimension ?subjectIri ?subject ?stance
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl>
WHERE {
  ?pos a :ComparisonPosition ;
       :ofDimension ?dimIri ;
       :ofSubject ?subjectIri ;
       :stance ?stance .
  ?dimIri schema:name ?dimension .
  ?subjectIri schema:name ?subject .
}
ORDER BY ?dimension ?subject

DESCRIBE this mapping document


DESCRIBE <https://contextandchaos.substack.com/p/enterprise-ais-200-millisecond-problem>
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl>

Query editor

SPARQL Query

SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl> {
    ?s a ?type .
    OPTIONAL { ?s rdfs:label|<http://schema.org/name> ?label }
  }
}
GROUP BY ?type
ORDER BY DESC(?entityCount)

▶ Run live on URIBurner SELECT: text/x-html+tr | DESCRIBE/CONSTRUCT: text/x-html-nice-turtle

Attribution & Provenance¶

Generation environment

Grok · Grok Bot (Cursor)

rdflib parse + harness validation

Linked Data runtime

URIBurner (Virtuoso-backed)

OpenLink Virtuoso

Named graphs

Document base · source namespace

DAV load target · DAV/demos/daas/enterprise-ais-200-millisecond-problem-agent-rdf-memory-grok-1.ttl

Resolver pattern

URIBurner describe

https://linkeddata.uriburner.com/describe/?url={uri}

Extraction provenance

Entities and narrative derived from the companion Turtle graph (kg-generator → rdf-infographic-skill). Graph payload embedded at generation time for offline exploration.

Enterprise AI 200-Millisecond Problem wired by agent-rdf-memory

Synopsis¶

Comparison Matrix¶

How-To Guide¶

Frequently Asked Questions¶

Glossary of Terms¶

Knowledge Graph Explorer 254 nodes · 837 links ¶

Enterprise AI 200-Millisecond Problem wired by agent-rdf-memory

KG Settings

Predicate Filters

Node Types

Literal Filter

SPARQL Workbench 13 sample queries ¶

Sample Queries

Query editor

Attribution & Provenance¶

Source material

Companion files

Skills used

Generation environment

Linked Data runtime

Named graphs

Resolver pattern

Extraction provenance