The graph of weights. The graph of doing. The graph of knowing. An RDF-backed narrative of Tony Seale's thesis that the future AI stack has three forms of structure — learned, operational and semantic — with a live SPARQL workbench over the collection's sample data.
Verbatim text of the social media post — reproduced exactly, as modeled in the companion RDF.
AI was always going to arrive at graphs: the future AI stack has three forms of structure — the graph of weights (learned, commoditised), the graph of doing (operational, from frameworks), and the graph of knowing (semantic, uniquely yours to build and own).
Six comparison dimensions across the triptych, with values drawn from the post and the comment thread. Each dimension is a first-class instance in the companion RDF (typed via the corpus-canonical cdx:ComparisonDimension class).
| Dimension | Graph of Weightslearned | Graph of Doingoperational | Graph of Knowingsemantic |
|---|---|---|---|
| Question it answers | How much? | What changes? | What is, and what does it mean? |
| Structure type | Learned, continuous — a neural network | Operational, discrete — agents, tasks, decisions, dependencies | Semantic, discrete — knowledge graphs, ontologies |
| AI stack counterpart | The LLM model itself | Agent frameworks and orchestration layers | Knowledge graphs and retrieval context |
| Change rate | Versioned by someone else — you know which model you ran | Rebuilt every run — cannot go stale | Persists and changes underneath you — 'when was this true' is a real question |
| Who owns it | Commoditised — LLM providers | Handed to you by frameworks | Nobody hands it to you — uniquely yours to build and own |
| Commoditisation | Learned — will be commoditised | Operational — will come from frameworks | Semantic — the third is uniquely yours |
The post's worked example — an agent tasked to assess credit risk — encoded as instance data in the companion RDF: a doing-node points straight at the Credit Risk concept, and from there to the customer it assesses, the evidence it weighs, the policy it obeys, and the decision it reaches. This sample data — plus a small weighted-edge corpus for the graph of weights — is queryable in the SPARQL workbench below.
GRAPH OF DOING → GRAPH OF KNOWING
Weight values on the cross-graph joins (agent → concept 0.92, policy → concept 0.99, concept → decision 0.78) are demonstrative figures for SPARQL practice, not sourced measurements.
Query the collection's knowledge graph — loaded at the named graph https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl — directly against the URIBurner SPARQL endpoint. Pick a recipe, edit it live, then run or copy.
text/x-html+tr · DESCRIBE / CONSTRUCT → text/x-html-nice-turtle. Live links are URL-encoded with encodeURIComponent.Ready-to-run SPARQL recipes over the sample data — from the triptych's node inventory to the two-graphs-one-walk join and the weighted edges of the graph of weights.
PREFIX : <https://www.linkedin.com/posts/tonyseale_ai-was-always-going-to-arrive-at-graphs-share-7493794469650128896-jM5v/#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?graph ?node ?label WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?node :belongsToGraph ?graph .
OPTIONAL { ?node rdfs:label ?label }
}
} ORDER BY ?graph ?node
PREFIX : <https://www.linkedin.com/posts/tonyseale_ai-was-always-going-to-arrive-at-graphs-share-7493794469650128896-jM5v/#>
SELECT ?agent ?concept ?customer ?evidence ?policy ?decision WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?agent a :AgentNode ; :pointsAt ?concept .
?concept :assesses ?customer ; :weighs ?evidence ; :obeys ?policy ; :reaches ?decision .
}
}
PREFIX : <https://www.linkedin.com/posts/tonyseale_ai-was-always-going-to-arrive-at-graphs-share-7493794469650128896-jM5v/#>
SELECT ?edge ?source ?target ?weight WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?edge a :WeightedEdge ; :sourceNode ?source ; :targetNode ?target ; :hasWeight ?weight .
}
} ORDER BY DESC(?weight)
PREFIX : <https://www.linkedin.com/posts/tonyseale_ai-was-always-going-to-arrive-at-graphs-share-7493794469650128896-jM5v/#>
PREFIX schema: <http://schema.org/>
SELECT ?position ?authorName ?text WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?comment a schema:Comment ;
schema:parentItem :post ;
schema:position ?position ;
schema:author ?author ;
schema:text ?text .
?author schema:name ?authorName .
}
} ORDER BY ?position
PREFIX : <https://www.linkedin.com/posts/tonyseale_ai-was-always-going-to-arrive-at-graphs-share-7493794469650128896-jM5v/#>
PREFIX cdx: <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-terms#>
PREFIX schema: <http://schema.org/>
SELECT ?dimension ?dimName ?weights ?doing ?knowing WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?dimension a cdx:ComparisonDimension ; schema:name ?dimName ;
:forGraphOfWeights ?weights ; :forGraphOfDoing ?doing ; :forGraphOfKnowing ?knowing .
}
} ORDER BY ?dimName
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE {
GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl> {
?s rdf:type ?type .
OPTIONAL { ?s rdfs:label ?label }
}
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
The collection's knowledge graph — post, author, the three graph instances, the credit-risk walk, and the weighted-edge corpus. Drag to pin nodes, double-click to unpin, click a node to open its resolver description. Click the graph surface to arm zoom; click outside to release it.
The post's argument as a position-ordered sequence of steps (schema:ItemList in the companion RDF). Each step heading links to its schema:CreativeWork entity IRI via the resolver.
Peter Steinberger (OpenClaw creator, now at OpenAI) asked whether we are still talking loops or have shifted to graphs — twelve words, 2.9 million views — and within hours an obituary appeared: loop engineering is dead.
First we engineered the prompt, then the context, then the harness, then the loop, now the graph — each name points at something real; mostly the field is christening what it was already doing.
Like music moving from records to tapes to CDs before coming to rest on the web, the graph will be the end game for engineering — but the word graph is being used to mean different things, and semantics really matter.
The loop never died: a loop is a graph whose path bends back on itself. Give it branches, let them merge, put increasingly autonomous agents at the nodes, and you have what people now call graph engineering.
The Graph of Doing — agents, tasks, decisions, dependencies — is how a system moves through work.
The Graph of Knowing — customers, products, molecules, contracts, policies — is what your world contains and how it connects; the half Palantir built a company on, the half Microsoft is bolting into Fabric, the part Snowflake and Databricks are trying to build in.
Both are graphs, and graphs connect: an agent tasked to assess credit risk is a node in the graph of doing that points straight at the concept Credit Risk in the graph of knowing — and from there to the customer it assesses, the evidence it weighs, the policy it obeys, the decision it reaches.
Back in 2023 the author wrote about a Semantic Router feeding results into a Working Memory Graph, fuelling subsequent steps within its Graph of Thought — sufficiently complex systems keep resolving into the same shape, a network shape.
The LLM is a neural network — a graph of weights. The execution loop is a circular path in a graph. The context and meaning are a Knowledge Graph. Graph engineering is building this discrete data network around the continuous neural network.
LLMs give you the graph of weights; the frameworks will hand you a graph of doing; nobody hands you the graph of knowing — your customers, your products, your policies. That one you have to build — and own — yourself.
The future AI stack has three forms of structure: learned, operational and semantic. The first will be commoditised, the second will come from frameworks, but the third is uniquely yours.
Eleven comments modeled verbatim: a curated sampling of 10 public comments from the source payload, plus Kingsley Uyi Idehen's comment captured from the latest edition of the post (thread live at ~32 comments, 2026-08-14). Each is a schema:Comment entity with a sequential thread position.
Tony, the loop never died, it just became a path in a bigger graph - that reframe does more work than the thread it came from. From the delivery seat, what breaks the join between your two graphs is rarely the modelling. It is that the graph of doing and the graph of knowing have different change rates and different owners. … So make the join an explicit versioned contract: an agent node binds to a pinned version of a concept, never to current. … What Palantir captured was not the graph, it was ownership of the mapping.
Good taxonomy, big fan of the framing. But, the three graphs age differently. Weights are versioned by someone else, and you know which model you ran. The graph of doing is rebuilt every run, so it can't go stale. The graph of knowing persists and changes underneath you at the same time. It's the only one where "when was this true" is a real question. … Uniquely yours to build, and uniquely yours to keep true.
Completely agree. The move to graphs always felt inevitable — once systems need to reason across relationships, state and dependencies, linear representations stop being enough. … there is one further layer emerging between the graph of knowing and the graph of doing: can what the system currently knows actually support this particular decision or action? … not another graph, but assurance at the boundary between knowing and doing.
This distinction really lands for us — we are developing a local, open-source knowledge-graph-based system as we speak, and the "graph of doing" vs "graph of knowing" split is exactly where the hard design decisions live. … in the agentic ecosystem we are building, it's increasingly the agents themselves proposing that structure, with a human still confirming each step.
Tony Seale very clarifying, and for me 3 convictions sit behind this. First, the graph of weights is already a latent map of relational possibility … the future of intelligence lies in joining latent pattern recognition with explicit, auditable dependency graphs … What we fail to model as a dependency, we will keep misreading as an isolated event…
I love your post. … And there are a ton of other graphs as well, Graph of authority, graph of state transitions, graph of self model, identity, capabilities and permissions.. And a few others even more critical
Graph of weights, graph of doing, graph of knowing - love that framing!
Saying that loops are dead and graphs are now the thing is right up there with saying algorithms are dead and data structures are now the thing. sigh.
So when snow melts you discover a new product witj oxygen and twice hydrogen ? Good for you...
Soon we’ll have a graph of models that use knowledge graphs. Graphception!
Thirteen questions covering the distinct claims of the post and thread.
Twelve terms the post and thread introduce or invoke, each a schema:DefinedTerm in the companion RDF.
Learned structure: the continuous neural network of an LLM — a graph of weighted connections.
Operational structure: agents, tasks, decisions and dependencies — how a system moves through work.
Semantic structure: customers, products, molecules, contracts, policies — what your world contains and how it connects.
Building the discrete data network — graphs of doing and knowing — around the continuous neural network; the author's candidate end game for AI engineering.
A graph-structured representation of entities and the relations between them; the container of context and meaning.
An explicit specification of the concepts, types and relations in a domain; the semantics layer of the graph of knowing.
The LLM itself — a graph of weights; the continuous network around which graph engineering builds a discrete data network.
A component the author wrote about in 2023 that routes requests by meaning, feeding results into a Working Memory Graph.
A graph-structured working memory that fuels the subsequent steps within a Graph of Thought (author's 2023 design).
A graph-shaped reasoning process; the pattern sufficiently complex systems keep resolving into.
An increasingly autonomous entity sitting at a node of the graph of doing, executing tasks and reaching decisions.
The pattern where a node in the graph of doing points straight at a concept in the graph of knowing, and the walk continues to the entities it assesses, weighs, obeys and reaches.
A set of principles for publishing structured data so that it can be interlinked and resolved via standardized identifiers (hyperlinks); per Kingsley Uyi Idehen's comment, the means by which a graph becomes a web — cross-silo connectivity as long proposed and demonstrated by the Semantic Web project.
The actionable sequence implied by the post — from inventorying your world to versioning the join between your graphs.
List what your world contains and how it connects: customers, products, molecules, contracts, policies. These are the entities of your graph of knowing.
Encode the inventory as a knowledge graph or ontology — knowledge graphs, ontologies and semantics are the half Palantir built a company on.
Model agents, tasks, decisions and dependencies — how your system moves through work. Frameworks will hand you this graph.
Make doing-nodes point straight at knowing-concepts — the credit-risk agent pointing at Credit Risk is two graphs, one walk.
Pin agent nodes to pinned versions of concepts, never to current; upgrade deliberately with re-evaluation, the same discipline you would apply to a model version.
Nobody hands you the graph of knowing — you have to build and own it yourself, and keep it true: 'when was this true' is a real question.
This knowledge graph overview was generated from Tony Seale's LinkedIn post by transforming the source into RDF using kg-generator, then rendered as an interactive infographic using rdf-infographic-skill, powered by DeepSeek V4 Flash. The companion RDF — including the sample data for the SPARQL workbench — is designed to be uploaded to the Virtuoso-based URIBurner server as the named graph https://linkeddata.uriburner.com/DAV/demos/daas/ai-graphs-tony-seale-deepseek_v4flash-1.ttl, which the queries above target.
Technology Stack:
Yep!
Also, as you know, graphs are not necessarily webs. A graph can have connectivity that remains trapped within a silo. That connectivity can transcend silos when standardized, resolvable identifiers (e.g., hyperlinks) are used to name the nodes and edges, unleashing the kind of cross-silo connectivity already demonstrated for documents by the World Wide Web. This brings us, once again, to the foresight and magic of upgrading graphs to Webs courtesy of Linked Data principles, as long proposed and demonstrated by the Semantic Web project through endeavors such as the Linked Open Data Cloud, which provides many of the resolvers that already serve a burgeoning Agentic Web.
BTW -- I am going to use one of my AI agents, courtesy of its Linked Data-based harness, to generate a Semantic Web variant of a knowledge graph from this post. This serves to bring easy-to-understand clarity to a really important topic in a world where labels come and go while the underlying concepts remain constant.
Link to follow in my next reply. 😀