Semantic Intent as Governance Primitive

Abstract

Background: Shatny (2025) established Semantic Intent as Single Source of Truth (SSOT) — a unified pattern combining semantic anchoring (WHAT) and intent mapping (WHY) into an immutable governance contract for AI-assisted development. That work addressed a two-party problem: one developer, one AI assistant, one codebase.

Problem: As AI systems evolve from coding assistants to autonomous agents operating in multi-agent pipelines, the governance problem changes in kind, not just in scale. Multiple agents — each stateless, each operating without memory of prior sessions — must coordinate without a human mediating every decision. The question is no longer how a developer keeps an AI anchored. It is how agents keep each other anchored.

Contribution: This paper extends the Semantic Intent SSOT thesis to multi-agent systems, proposing Semantic Intent as a governance primitive — a cross-agent contract with three required properties: immutability, addressability, and provenance. We draw on a working ecosystem of five independently developed tools (Rune Protocol, Wake Intelligence, RECALL, Mere, EMBER) as empirical evidence that this primitive emerges naturally from practice, and examine authorship attribution and generative UI as two consequences that become tractable only once the primitive is in place.

Keywords: semantic intent, agentic systems, governance primitive, multi-agent coordination, authorship attribution, generative UI, temporal memory, reactive binding

1. Introduction

In September 2025, the problem driving the original SSOT paper was concrete: an enterprise reporting system where executive briefs and full reports generated identical PDF output despite different content types. Weeks of debugging had failed. The root cause was a semantic violation — the analysis domain was overriding the document type domain — and the fix was to unify WHAT and WHY into an atomic semantic contract, protected by immutable governance [1].

The lesson was generalizable: when AI assists with code generation, refactoring, or architectural decisions, the primary failure mode is not incorrect logic. It is semantic drift — the gradual divergence between what a developer intended and what successive AI-assisted transformations produce. The SSOT pattern provided a structural answer: declare intent explicitly, co-locate it with the artifact it governs, make it immutable, and AI has something stable to read rather than something ambiguous to reconstruct.

Eight months later, the problem has evolved.

AI is no longer positioned primarily as a coding assistant responding to prompts. Production systems now deploy AI agents that generate artifacts, evaluate outputs, trigger downstream actions, and pass context to other agents — without a human in the loop at each step. The two-party model (developer + assistant) is being replaced by pipeline models where an orchestrating agent delegates to specialist agents, each of which may produce artifacts that feed the next.

In this architecture, the SSOT pattern remains necessary but is no longer sufficient. An individual agent reading a well-annotated codebase can reconstruct intent from structural declarations. But when Agent B receives a context package from Agent A, it has no memory of why Agent A made the decisions it made. It cannot distinguish a governance constraint from an optimisation preference. It cannot know whether a prior decision was made by a human, an upstream agent, or a machine-generated pipeline step. And it has no mechanism for preserving its own reasoning in a form that Agent C, operating later, can access.

Semantic drift in the multi-agent case is not a code-level problem. It is a coordination problem. The governance contract must operate at the layer where agents communicate, not just at the layer where humans write code.

This paper proposes Semantic Intent as that governance contract — not as a pattern to be applied, but as a primitive to be implemented at the infrastructure level.

2. The Agentic Shift

2.1 From Tool to Agent

The distinction between an AI tool and an AI agent is structural. A tool responds to a prompt and produces output. An agent maintains goals, takes sequences of actions, evaluates intermediate results, and coordinates with other agents to achieve outcomes that neither could achieve alone.

In the tool model, governance is a human responsibility. The developer reads AI output, evaluates it against intent, and decides whether to accept it. Semantic drift is caught in review.

In the agent model, governance cannot wait for human review at every step. Agents produce artifacts that immediately become inputs to downstream agents. By the time a human reviews the final output, many intermediate decisions have already been made, compounded, and rendered difficult to trace. Review is retrospective rather than preventive.

This shifts the governance problem from evaluation to contract enforcement. The contract must be in place before the agent acts, not reviewed after.

2.2 The Multi-Agent Coordination Problem

Consider a representative pipeline: an orchestrating agent delegates a code analysis task to a specialist agent, which produces a structured finding. A second specialist agent uses that finding to generate a migration plan. A third agent executes the first step and logs the result. A fourth agent prepares a human-readable summary.

At each handoff, context is passed but reasoning is lost. Agent 2 knows what Agent 1 found — it does not know why Agent 1 prioritised that finding over others, what constraints Agent 1 was operating under, or whether the finding represents a hard requirement or a suggestion. A misreconstruction at step 2 propagates through steps 3 and 4 as if it were ground truth.

2.3 What the Problem Requires

A solution to multi-agent semantic drift must satisfy three requirements:

3. Semantic Intent as Governance Primitive

3.1 Definition

A governance primitive is a structural unit — below the level of a pattern or framework — that can be composed to build governance systems, referenced by any layer of a stack, and relied upon as a stable contract.

In the context of multi-agent systems, Semantic Intent as a governance primitive is defined as:

Three properties are required for the primitive to function:

3.2 Relationship to the SSOT Pattern

The SSOT pattern [1] addressed immutability at the code level: a semantic contract frozen at the moment of declaration, protected against modification by transformation layers. The governance primitive extends this in two directions.

First, it adds addressability as an explicit requirement. In the code-level pattern, intent was co-located with the code construct. In the multi-agent case, intent must be queryable across systems — by agents with no access to the original codebase, operating in different contexts, at different times. Structural addressability means the intent is a named, dereferenceable resource, not an inline annotation.

Second, it adds provenance as a first-class property. The SSOT pattern did not distinguish who declared an intent — the developer was the implicit single author. In multi-agent systems, authorship is a governance question. A constraint approved by a human risk committee has different standing than an optimisation inferred by an agent. Provenance makes this distinction tractable.

4. Empirical Evidence: An Ecosystem in Convergence

The strongest argument for Semantic Intent as a governance primitive is not theoretical. It is the observation that five independent tools — built for different purposes, by the same author, across eight months — all converged on the same structural answer to the same underlying question.

None of these tools were designed as a system. Each solved an immediate problem. The convergence was discovered retrospectively, and it is the convergence itself that constitutes the evidence.

4.1 Rune Protocol: The Binding-Level Primitive

Rune Protocol [2] is a reactive binding grammar expressed through four sigils: @ (read), ~ (sync), ! (act), ? (intent). The ? sigil is the governance primitive at the binding level — a named, co-located, runtime-queryable field that lives in the same commit as the binding it governs and travels through transformation layers intact.

// rune.schema.json
{
  "bindings": [
    {
      "id": "risk-threshold",
      "sigil": "~",
      "intent": "Approved by risk committee Q1-2025. Floor of 0.10 non-negotiable — below that, position sizing model breaks.",
      "metadata": { "author": "human", "approved": "2025-03-14" }
    }
  ]
}

A rune.schema.json is a machine-readable governance contract: immutable (versioned in git), addressable (queryable by binding ID), carrying provenance (metadata.author).

4.2 Wake Intelligence: Temporal Governance

Wake Intelligence [3] is a five-layer temporal intelligence MCP server that preserves the causal history of decisions across sessions — solving the temporal gap: the space between a decision made at one point in time and an agent beginning a new session with no memory of it.

Wake v3.5.0 introduced ingest_rune_manifest — a tool that ingests a rune.schema.json and saves every ? annotation as a Wake causal context. Governance declared in Rune becomes temporal memory in Wake: the binding ID is the node identifier, the ? intent annotation is the causal rationale, and the causal chain is traversable from any downstream session.

4.3 RECALL: Authorship as Compile-Time Constraint

RECALL [4] is a COBOL-inspired publishing language for structured artifacts. Its governance contribution is CREATED-BY: an enum field that accepts exactly three values (Human, AI compositor, AI agent). A RECALL document that does not declare authorship does not compile. Authorship is not a tag applied after the fact — it is enforced structurally, at creation, and travels with every derivative the pipeline produces.

4.4 Mere: Reactive Governance at the UI Layer

Mere [5] is a workbook format using the same four Rune sigils, predating their formalisation as Rune Protocol. Mere is the origin point: the sigils were discovered in Mere, extracted as Rune Protocol, and formalised as a governance primitive. The UI layer is where the primitive was first put into practice.

4.5 EMBER: Intent Declarations for the Third Reader

EMBER [6] is the Semantic Intent Language for legacy modernisation. Its semantic vocabulary (INTENT, DIMENSION, THRESHOLD, SIGNAL) is designed for the third reader — not the human who wrote the code, not the human who inherits it, but the AI agent that must understand and transform it. EMBER is an antecedent form of the governance primitive: intent declared in structure, co-located with the legacy artifact, readable by agents that have no other way to reconstruct the original reasoning.

4.6 The Convergence

These five tools were not designed as a system. The observation that each implements the same three-property governance primitive — immutability, addressability, provenance — is a retrospective finding, not a design specification.

The convergence is the evidence: when the same fundamental structure re-emerges independently across multiple problem domains, the structure is expressing something true about the problem, not something intentional about the solution.

5. The Authorship Dimension

5.1 Why Authorship Is a Governance Question

In traditional software development, authorship is a historical record — who committed which line, preserved in git blame. It is not a governance dimension because it does not affect how a system behaves at runtime.

In multi-agent systems, authorship becomes a runtime concern. When an agent receives a context package containing prior decisions, the question "who made this decision?" determines the decision's governance standing. A risk threshold approved by a human committee has different standing than a threshold inferred by an optimisation agent to minimise latency. Both may appear as structured data in the same context package. Without authorship, they are indistinguishable.

5.2 Three Independent Implementations

The authorship dimension appeared independently in three tools:

Three implementations, different syntax, different layers — the underlying model is identical: authorship is a structural field, declared at creation, enforced by the receiving layer, preserved through transformations.

5.3 The Auditor Mode

Wake's auditor personality mode is the query interface for the authorship dimension. An agent entering a new session can immediately distinguish which prior decisions are human-authorised constraints and which are agent-generated optimisations. The former are load-bearing. The latter are negotiable. Without this distinction, an agent has no way to determine which decisions it can override and which it must treat as invariants.

load_context({ project: "trading-engine", personality_mode: "auditor" })
// → human: 3 contexts (risk threshold, OAuth decision, compliance boundary)
// → ai-agent: 7 contexts (optimisation decisions, inferred preferences)
// → ai-compositor: 4 contexts (ingested from Rune manifest, pipeline-generated)
// → unattributed: 12 contexts (pre-v3.5.0 entries)

6. Generative UI as Derived Artifact

6.1 The Current State

The most visible early form of generative UI in production today is the HTML artifact produced by large language models during conversations. No developer pre-built a “customer churn risk dashboard” or a “causal graph explorer” — these are derived at runtime from the semantic context of the conversation. The rendering is a consequence of meaning, not a template lookup.

This is already happening. What is not yet in place is the infrastructure that makes it production-grade: persistent, auditable, reproducible, and tech-agnostic.

6.2 The Missing Infrastructure

The HTML artifact has four properties that prevent production use:

These are not properties of generative UI as a concept. They are properties of generative UI without a governance primitive.

6.3 What the Primitive Enables

When Semantic Intent is in place as a governance primitive, generative UI acquires the properties it needs for production use:

6.4 The Shifted Role

The conventional development model: a developer designs a UI, writes components, hardcodes the layout, and the data fills the slots. Intelligence is optional, applied at the margins.

The model the governance primitive enables: a developer declares a semantic contract. An AI agent derives the appropriate surface at runtime, based on the current state of semantic context — which data is active, which decisions are load-bearing, what the user is trying to accomplish. The developer's job shifts from designing interfaces to declaring contracts. The interface is the AI's output, not the developer's artifact.

“Tech-agnostic” in the original sense: the contract does not know whether it will be rendered as React, HTML, a voice interface, or a structured report. The rendering is downstream of the meaning.

7. Discussion

7.1 Relationship to the Prior Work

This paper does not supersede [1]. The SSOT pattern remains the correct description of the two-party problem: one developer, one AI assistant, one codebase. The governance primitive is an extension: the same underlying structure, operating at the layer where agents communicate rather than the layer where humans write code. The relationship is additive — a system that implements the governance primitive at the pipeline level still requires well-annotated code at the binding level.

7.2 On the Emergence of the Primitive

The five-tool convergence described in Section 4 was not designed. The author built each tool to solve an immediate, concrete problem. The observation that all five implement the same three-property primitive emerged from reflection, not specification.

When the same structure appears independently across multiple implementations of a domain problem, it is expressing something the domain requires. The formal definition in Section 3 is an articulation of what the implementations already demonstrate.

7.3 Limitations

The ecosystem is young. The five tools have been deployed in production contexts at the scale of individual projects, not enterprise pipelines. The claim that Semantic Intent functions as a cross-agent governance primitive at scale — across large organisations, across AI systems from different vendors — remains to be tested empirically.

The authorship taxonomy (human / ai-agent / ai-compositor) is a starting point, not a complete model. Real pipelines involve agents acting under human oversight, agents acting semi-autonomously, and agents acting as pure compositors. The boundary between these categories is not always clear, and the governance implications of each remain underspecified.

The generative UI thesis has not been tested as a production architecture. The claim that a stable semantic contract enables reproducible, auditable, tech-agnostic UI derivation requires an implementation that does not yet exist in completed form.

7.4 Future Directions

Three directions are most immediate:

1. Formal specification of the governance primitive — analogous to the mathematical formalisation in [1], making the primitive composable and verifiable.
2. Cross-organisation semantic contracts — how Semantic Intent functions as a governance primitive across organisational boundaries, in vendor-client relationships, in regulatory contexts.
3. The generative UI toolkit — building the compositional layer that wires Wake, RECALL, Rune, and Mere into a coherent generative UI pipeline. The components exist; the integration is the work.

8. Conclusion

Shatny (2025) established Semantic Intent as Single Source of Truth: a unified WHAT+WHY contract, protected by immutable governance, that eliminates semantic drift in AI-assisted development. The result was a structural answer to a two-party problem.

The agentic era has changed the problem. Multi-agent pipelines require governance that operates at the layer where agents communicate — before decisions are made, not in review after. This paper has proposed Semantic Intent as a governance primitive defined by three properties: immutability, addressability, and provenance.

The empirical case rests on convergence: five independently developed tools — Rune Protocol, Wake Intelligence, RECALL, Mere, and EMBER — each arrived at an implementation of the same primitive from different directions and different problem domains. When the same structure appears independently across multiple implementations of a domain problem, it is expressing something the domain requires.

Two consequences follow directly from the primitive being in place. First, authorship becomes a tractable governance dimension: not a historical record, but a runtime property that determines the standing of prior decisions in a multi-agent context. Second, generative UI becomes a derived artifact of semantic state: not a template pre-built by a developer, but a surface produced by intelligence from a stable, machine-readable contract.

Semantic Intent was first a pattern. Then a SSOT. It is now a primitive. The difference is not semantic — it is architectural. A primitive is not applied to a domain; it is what the domain is built from.

References

1. Shatny, M. (2025). Semantic Intent as Single Source of Truth: Immutable Governance for AI-Assisted Development. semanticintent.dev. DOI: 10.5281/zenodo.17114972. ORCID: 0009-0006-2011-3258.
2. Shatny, M. (2026). Rune Protocol: A Reactive Binding Grammar for Human-AI Collaborative Systems. Zenodo. DOI: 10.5281/zenodo.20007883.
3. Shatny, M. (2026). Wake Intelligence MCP: A Five-Layer Temporal Intelligence Server for AI Agents. npm: @semanticintent/semantic-wake-intelligence-mcp v3.5.0. wake.semanticintent.dev.
4. Shatny, M. (2026). RECALL: A COBOL-Inspired Publishing Language for AI-Auditable Artifacts. npm: @semanticintent/recall-compiler v1.0.2.
5. Shatny, M. (2026). Mere: A Workbook Format for Self-Contained Reactive Applications. Zenodo. DOI: 10.5281/zenodo.19751778.
6. Shatny, M. (2026). EMBER: A Semantic Intent Language for Legacy System Modernisation. Zenodo. DOI: 10.5281/zenodo.19751387.
7. Anthropic. (2024). Model Context Protocol Specification. modelcontextprotocol.io.
8. Shatny, M. (2026). Strata: A Database Archaeology Methodology for Legacy SQL Systems. Zenodo. DOI: 10.5281/zenodo.19768151.

© 2026 Michael Shatny / semanticintent. Licensed under CC BY 4.0. ORCID: 0009-0006-2011-3258