Balisage: The Markup Conference 2026 August 3-7, 2026 Thirty years of working with markup languages, semantic web standards, and knowledge representation systems reveals a single recurring problem wearing many different masks: the problem of bounded, scoped, composable meaning. This paper traces a personal and technical journey from the HTML Document Object Model of 1996 through XML, XSLT, XSD, XQuery, RDF, SHACL, and the neural systems of the present day, arriving at the holonic graph as the resolution of a tension that has persisted, largely unacknowledged, throughout the life of the markup community. The holon — Arthur Koestler's term for a unit that is simultaneously a whole and a part of a larger whole — turns out to have been implicit in every major design decision the XML and semantic web stacks ever made. RDF 1.2, SHACL 1.2, and named graphs now provide the formal apparatus to make it explicit. The implications extend from knowledge governance to the grounding of large language models. Kurt Cagle Kurt Cagle is a consulting ontologist, IEEE Standards Editor at the IEEE Spatial Web Foundation, and founding contributor to the W3C Context Graph Community Group. He has authored more than twenty-five books on XML, semantic web, and knowledge representation technologies spanning thirty years of active engagement with the W3C and related standards bodies. He writes The Cagle Report on LinkedIn, and The Ontologist and The Inference Engineer on Substack. Consulting Ontologist; IEEE Standards Editor IEEE Spatial Web Foundation; W3C Context Graph Community Group kurt@ontologist.io Copyright 2026 Kurt Cagle XML holonic graphs RDF 1.2 SHACL knowledge representation Active Inference large language models containment document object model semantic web

My introduction to XML came in 1996, motivated by a simple observation I made while working on two of my earliest books about the web. When a browser parses an HTML document, what it actually produces internally is a graph. Element identifiers become node identifiers; element types become concept types; attributes are either literals or references to other nodes. I noticed something further: the documents did not actually have to be valid HTML to be parseable — they only needed to conform to the Document Object Model specification. This meant that information could be encoded into the DOM graph without being displayed, and retrieved through the DOM node API, even before XPath existed as a language. My first published book, and the second I substantially wrote, was built on exactly this insight: the HTML DOM as a foundation for data storage and retrieval. By the time it appeared in 1998, the XML Working Group was actively developing the specifications that would follow, and the core instruments — XSLT, XML Schema, XPath, XQuery — were at least converging toward consensus. What I had stumbled onto was not unique to HTML. It was a structural fact about trees: a well-formed tree is a degenerate graph, and the moment you add cross-references — hyperlinks, ID/IDREF pairs, namespace prefixes — the tree admits the full complexity of a graph while pretending to be something simpler. This tension between the graph that a document actually is and the tree that it presents itself as would run, like a fault line, through everything that followed.

Not everyone who converged on XML in the late 1990s shared the same mental model of what it was for. Many within the W3C at the time had come out of the SGML community, and for them XML was fundamentally a document format — a way of encoding text with structure, provenance, and semantic annotation, fit for publication, archiving, and human reading. For others, myself included, XML was a data format — a self-describing, schema-validatable serialisation mechanism for structured information that happened to be human-readable. This was not a trivial disagreement, and it persisted through much of the XML community's active life. The document view carried with it something the data view tended to undervalue: the concept of a document as a collection of enclosures. A document contains sections; sections contain paragraphs; paragraphs contain phrases. The tree that these enclosures create has an intrinsic narrative temporality built in. Items deeper in the tree have less generality and more specificity. They also carry a directionality — items that appear earlier in document order carry an implicit temporal priority over items that appear later. Most people who worked with XML documents never fully examined this assumption. The tree is not merely a structural hierarchy; it encodes a time vector. This was XML's greatest strength: containment, narrative structure, and serialisability were bundled together into a coherent whole. It was also, as I came to understand, its greatest weakness. The containment model made multiply-scoped annotations — the ability to say that a given span of content belonged simultaneously to two or more overlapping structures — cumbersome to the point of being practically unusable. I worked with Micah Dubinko to develop the RDFa specification as a potential stopgap: a way to embed RDF triples into (X)HTML using the existing attribute machinery. The containment model proved problematic there as well, for much the same reason. And by then a different wind was blowing: streaming was beginning to replace file-centric storage as the dominant paradigm, and the document as a discrete, bounded whole was losing its privileged position. The fault line had not closed. It had merely moved.

Three major innovations defined the mature XML stack, and each one pushed the boundary of what was representable while revealing, at its limit, the same underlying problem.

XSLT was revelatory when I first encountered it in the late 1990s, through its inventor James Clark. It built upon XPath expressions — essentially graph traversal patterns — to identify structural shapes within a source document and apply transformation templates to produce output. Its stated purpose was modest: convert document-like XML to HTML or XSL Formatting Objects for rendering. In practice it became one of the two great workhorses of the XML stack, and its actual operation was considerably more interesting than its stated purpose suggested. An XSLT stylesheet is a declarative description of shape transformations on a graph. You describe what you are looking for — a path, a context, a pattern — and what to produce when you find it. The system handles the traversal. This is not transformation in a mechanical sense; it is closer to a projection — a mapping from one graph representation to another, with selective preservation of structure. By 2026, XSLT had grown fully capable of working with JSON and other structured formats, confirming what practitioners had always known: the document was a pretext. The graph was the point.

XML Schema Definition language arrived to address a real need: the data-centric community required a formal mechanism for constraining the structure and content of XML documents, and the inherited SGML tooling (DTDs) was inadequate for the task. I was involved at the margins of XSD's development and have written extensively about it since. What XSD introduced, beneath its considerable complexity, was a simple and profound idea: every element definition is a set of embedded assertions. To say that an element of type xs:date must contain a value matching a particular pattern is to assert a constraint that any conforming document must satisfy. XSD moved the community toward constraint-based modelling in a way that would echo forward through SPARQL, SPIN, and ultimately SHACL. The weakness of XSD, viewed in retrospect, was that its constraints were local to the document. The assertion that a given element must be of a given type could only be evaluated against the document that contained it. Cross-document constraints — the kind that arise naturally when information is distributed across multiple resources — were outside its scope.

XQuery represented a shift in thinking away from the XML core language toward a more declarative, Scheme-influenced query language. FLWOR expressions — For, Let, Where, Order By, Return — provided a functional pattern that could traverse and restructure XML with considerable power, and these patterns were subsequently retrofitted into XSLT. More significant than the language itself was what XQuery implied about the data model. The document was replaced by the forest: an XQuery database could hold millions of documents, each conforming to a particular schema, and queries could range across all of them. You were searching for shapes within the schema space; you were querying a distributed graph rather than a single tree. But cross-document navigation — moving from a conceptual node in one document to a related node in another — remained genuinely painful. The forest was not a graph. It was a collection of trees that happened to share address space. The joins were expensive, the cross-references were fragile, and the fundamental unit of identity was still the document, not the concept.

The Semantic Web working groups within the W3C took a different approach: rather than extending the XML containment model outward, they abandoned it almost entirely. RDF moved from XML's highly denormalised, order-sensitive world to a highly normalised, order-free model of subject-predicate-object triples. Everything that existed was a node; everything that related nodes was an edge; there were, in principle, no documents, only graphs. This generated its own trajectory — OWL for ontological reasoning, SPARQL for graph query, SPIN for rule expression, eventually SHACL for constraint validation, and with RDF 1.2, named graphs and reification mechanisms that finally gave RDF a first-class way to talk about its own triples. The gains were real. The Open World Assumption, the IRI namespace, the separation of schema from instance — these were genuine advances over the XML model. But the losses were also real. Natural ordering disappeared; the time vector that the document model had encoded implicitly had to be reconstructed explicitly, through prov: annotations or temporal predicates, and it was never as natural. The containment model, for all its inflexibility, had provided a free serialisation of context. In RDF, context had to be earned.

There is a further tension in the semantic web that has never been fully acknowledged, and I believe it contributed more than is commonly recognised to the semantic web's failure to achieve the transformative impact its architects anticipated. A URL is an address. It locates a resource within a specific infrastructure — DNS, TCP/IP, HTTP — that has quasi-physical, geospatial properties. The web is fundamentally a spatial system: servers have locations, documents live at addresses, retrieval is a traversal of physical and logical topology. An IRI is an identifier. It is a label within a theoretically infinite, topologically open conceptual graph. It does not point to a location; it names a thing. The thing may or may not have a representation retrievable at the address that happens to share its form. These are not the same kind of entity, and conflating them — as the semantic web's Linked Data conventions did, with their requirement that IRIs be dereferenceable HTTP URIs — imported a set of infrastructure assumptions into a conceptual model where they did not naturally belong. The semantic web stalled partly because it asked people to maintain conceptual identity and geospatial address in the same token, for every node in every graph, indefinitely. That is a significant cognitive and operational burden, and it was never sufficiently justified by the benefits. The distinction matters now more than ever, as the Spatial Web emerges as a domain where the geospatial and conceptual genuinely need to be related — but carefully, explicitly, and with their differences preserved rather than elided.

Large language models arrived, to the broader world, seemingly fully formed. In practice their ancestry was visible through the 2010s — from statistical natural language processing, through attention mechanisms, through the transformer architecture — but the sudden capability jump of the early 2020s felt like an interruption rather than a continuation of the story. I will not rehearse how attention transformers work. But I want to offer a metaphor that I believe is more apt than most. A latent space, constructed by embedding tokens as high-dimensional vectors and learning their relationships through training, can be understood as an overlapping manifold of narratives. The pattern-matching that a language model performs is almost entirely drawn from textual training data — which is to say, from the accumulated record of human discourse, which is itself an enormous, highly redundant, inconsistently structured graph of assertions, stories, arguments, and descriptions. An LLM, in this view, creates a compressed representation of potential conversations — constrained by the ordered token stream of the prompt, which acts as a prior — and then collapses that representation into a serialisation. It is not entirely unlike an XSLT transformer: given a source graph (the latent space) and a query (the prompt), produce a result (the response) by applying learned shape transformations. The difference is one of scale, context-sensitivity, and the irreducible fuzziness of the learned representations. This is not a criticism. The fuzziness is a feature. LLMs can interpolate, generalise, and produce plausible outputs in domains they have never explicitly seen. What they cannot do, by themselves, is guarantee that those outputs conform to any external constraint. They have no internal Domain Graph. They have no Markov blanket that enforces a boundary between what they know and what they invent. They confabulate not because they are broken but because nothing in their architecture prevents it. This is the problem that the holonic graph is positioned to address.

Arthur Koestler explored the containment problem in The Ghost in the Machine (1967) and in the follow-up Janus: A Summing Up (1978). He was not writing about markup languages — he was writing about biological organisation, psychological cognition, and social structure — but he identified something that applies with equal force to knowledge representation systems. Human cognition, Koestler observed, cannot handle infinities. The mind, left to its own devices, organises the world into things that contain and things that are contained. This whole-part dialecticalism — every structure simultaneously a whole with respect to its parts and a part with respect to the larger structure that contains it — he termed the holon. A holarchy is a structure composed entirely of holons, nested arbitrarily deeply, with each level complete at its own scale. Consider the question seriously: what are the boundaries of a book? Not its physical covers — those are manifestations of a boundary, not the boundary itself. The information boundary of a book is the set of conceptual edges that determine whether a given assertion is inside or outside that book's scope. These edges are not fixed; they shift depending on who is reading, what they already know, and what questions they are asking. The same question applies to a country, a building, a field of study, a scientific theory, a software system. Where are the edges? What happens at them? Humans navigate holonic boundaries constantly and mostly unconsciously. Move from room to room in a house and your brain performs a subtle model reset at each threshold. The limbic system registers the liminal crossing; uncertainty briefly rises; the world model is refreshed. This is not a quirk of neuroscience — it is the cognitive mechanism by which bounded contexts are maintained. It is, in Karl Friston's Active Inference framework, the update signal that fires when sensory prediction error at a boundary exceeds a threshold. The XML stack addressed the boundary problem imperfectly and inconsistently, because the boundary was never a first-class citizen of the model. The document boundary was assumed, not declared. The namespace boundary was a labelling convention, not an enforced constraint. The schema boundary was local, not distributable. Every advance in the stack was, in part, an attempt to make the boundary more explicit and more manageable — and every advance hit the same wall.

The convergence of RDF 1.2, SHACL 1.2, and named graphs now provides, for the first time in the history of the semantic stack, the formal apparatus to make boundaries first-class objects in a knowledge graph. The Holonic Graph Architecture (HGA) is a four-layer model that decomposes every knowledge unit — every holon — into four distinct graph perspectives: Layer 1: Scene Graph (interior/immanent). The entities, events, and local state that constitute the holon's internal world — the things that exist from the holon's own perspective. This is the document's content, the database's records, the model's instances. Layer 2: Domain Graph (boundary/normative). The constraints, type definitions, and inference rules that govern what may exist within the holon and how it may interact with its environment. This is where SHACL shapes live. This layer is structurally equivalent to what Karl Friston terms a Markov blanket — the statistical boundary that separates internal states from external states while permitting selective, typed interaction through input and output portals. A SHACL constraint violation at this layer is not merely a validation error; it is a prediction error, a signal that the holon's model of its environment is out of alignment with observed data. Layer 3: Context Graph (relational/situational). The cross-holon relations that position this holon within larger knowledge structures. Where the Scene Graph is the view from inside, the Context Graph is the view from the boundary outward — the holon's participation in the world beyond itself. Layer 4: Holonic Graph (meta-level/compositional). The governance layer: how this holon composes with others, how sub-holons are spawned, how the holarchy is structured and maintained. The tension between document and data that animated the XML debates maps cleanly onto this architecture. The document's time vector and containment structure are properties of the Scene Graph — the interior, ordered, narrative representation. The data community's normalised, reference-based model is the property of the Context Graph — the relational, cross-boundary view. These are not competing models. They are different layers of the same holonic structure, appropriate to different epistemic perspectives.

One of the genuinely hard problems in knowledge representation is what might be called the discursive space problem: the same entity, viewed from different contexts, may have legitimately different and mutually contradictory properties. An employee is simultaneously a cost centre to Finance and an intellectual asset to Research. A disputed territory is simultaneously sovereign to two nations. A historical event is simultaneously a liberation and an occupation. The correct response to such contention is not to average the views into a single consensus representation — that produces a nonsense result. Nor is it to refuse to model the entity until the contention is resolved. The correct response is to model the contention itself: to represent each view within its own bounded holonic context, with explicit portal interfaces that mediate between them, and to create a projection graph in a third, meta-level holon that logs the contention and provides a traceable resolution mechanism. This is precisely what the XML containment model could not do elegantly. Overlapping hierarchies, competing annotations, multiply-valid interpretations of a single resource — these broke the tree. In a holonic graph, they are first-class structural features.

The most consequential application of holonic graph architecture in the near term is not in knowledge management or decision support, significant as those are. It is in the governance of neural systems. Large language models, as noted, have no internal boundary enforcement. They are extraordinarily powerful shape-transformers operating over a latent space of human discourse, but they cannot, by themselves, guarantee that their outputs conform to any external constraint. They hallucinate not because they are careless but because their architecture has no mechanism equivalent to a Domain Graph — no Markov blanket that enforces the distinction between grounded assertion and confabulated plausibility. SHACL shapes applied at the boundary of a holonic context graph provide exactly this mechanism. They do not constrain what an LLM can generate in its interior; they constrain what an LLM-generated output can assert as ground truth within a governed knowledge structure. The holonic boundary is the governance layer. The LLM operates within it as a powerful but untrusted sub-symbolic component; the Domain Graph determines what of its output may be admitted, and under what conditions. Without this, there is no AI governance worth the name — only guardrails that guard at the surface while the interior remains ungoverned. The holonic graph provides the interior governance layer that the neural stack cannot provide for itself.

In 1996, I noticed that an HTML document was a graph pretending to be a tree. Everything that followed — the XML debates, the schema wars, the semantic web, the neural interruption — was an elaboration of that observation, one layer at a time. The document people were right that containment encodes meaning. The data people were right that normalisation enables reasoning. The semantic web architects were right that identity should be decoupled from address. The neural network researchers were right that learned representations can generalise across domains in ways that rule-based systems cannot. None of them were wrong. They were each describing a different layer of the same holonic structure, and the disagreements arose not from error but from incompleteness — from the absence of a framework that could hold all four perspectives simultaneously without collapsing them into each other. Koestler had the framework in 1967. It took the rest of the stack thirty years to catch up. It is a long way from hand-built pseudo-HTML on a green-screen terminal, but it is a continuous thread. Every conference, every working group, every specification, every book contributed a layer. The holonic graph is not the end of the journey — it is the point at which the journey becomes legible as a single coherent arc. For a community that has spent thirty years building the pieces, that seems like a reasonable place to arrive.

Koestler, Arthur. The Ghost in the Machine. London: Hutchinson, 1967. Koestler, Arthur. Janus: A Summing Up. London: Hutchinson, 1978. Clark, James, ed. XSL Transformations (XSLT) Version 1.0. W3C Recommendation. 16 November 1999. https://www.w3.org/TR/xslt Friston, Karl. The free-energy principle: a unified brain theory? Nature Reviews Neuroscience 11 (2010): 127–138. doi:10.1038/nrn2787. Genette, Gérard. Narrative Discourse: An Essay in Method. Translated by Jane E. Lewin. Ithaca: Cornell University Press, 1980. Champin, Pierre-Antoine, et al. RDF 1.2 Concepts and Abstract Syntax. W3C Working Draft, 2024. https://www.w3.org/TR/rdf12-concepts/ Knublauch, Holger, and Dimitris Kontokostas, eds. SHACL 1.2: Shapes Constraint Language. W3C Working Draft, 2024. https://www.w3.org/TR/shacl12/ Cagle, Kurt. Holonic Graph Architecture Core Ontology (v0.9.0). 2026. https://github.com/kurtcagle/holon-graph