Balisage Paper: From XML to Holons

The Graph That Was Always There

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.

The Great Tension: Document vs. Data

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.

The Three Instruments

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.

The RDF Turn

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.

The Neural Interruption

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.

The Boundary Problem

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 Holonic Graph

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.

The Thread

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.