Andrii Bidochko

• Updated: July 22, 2026
• 6 min read

Ceci n’est pas une pipe: AI systems as semantic abstractions

Direct Answer

The paper “Ceci n’est pas une pipe: AI systems as semantic abstractions” introduces a formal semantic framework that treats every AI output—text, citation, tool call, or action—as an engineered representation rather than a direct statement of fact. By separating what is justified by domain knowledge, what reference sources claim, and what the system can actually use, the framework gives precise vocabulary for diagnosing failures such as extrapolation, stale sources, or unsupported hypotheses, thereby enabling more reliable AI‑driven agents.

Background: Why This Problem Is Hard

Modern AI agents are increasingly entrusted with high‑stakes decisions: drafting legal contracts, recommending medical treatments, or orchestrating multi‑step workflows across cloud services. In each case the agent’s output is assumed to be a faithful description of reality, yet the underlying model merely predicts token sequences conditioned on massive, noisy corpora. This mismatch creates three intertwined challenges:

• Opacity of provenance: When a model cites a study or quotes a statistic, there is no guarantee the cited source actually supports the claim.
• Temporal drift: Knowledge bases evolve; a model trained on data from 2022 may repeat a fact that has been refuted in 2024.
• Semantic over‑generation: Large language models (LLMs) excel at producing fluent language, but fluency does not imply correctness. The model can “hallucinate” details that sound plausible but have no grounding.

Existing mitigation strategies—prompt engineering, retrieval‑augmented generation, or post‑hoc fact‑checking—address symptoms rather than the root cause: they treat AI output as a raw fact that must be corrected later. What is missing is a systematic way to model the *semantic contract* between an AI system and the world it claims to describe.

What the Researchers Propose

The authors, Jade Alglave and Patrick Cousot, propose a three‑layer semantic abstraction:

1. Domain Knowledge Layer (DKL): A formal representation of universally accepted facts, axioms, and inference rules within a specific field (e.g., physics, finance, medicine).
2. Reference Source Layer (RSL): A catalog of external artifacts—papers, APIs, databases—each annotated with its claim set and credibility metadata (date, peer‑review status, provenance).
3. System Capability Layer (SCL): The concrete set of operations the AI system can perform at runtime: language generation, tool invocation, database queries, or actuation commands.

By mapping every output token to one of these layers, the framework can answer questions such as:

• “Is this statement justified by the DKL, or does it rely on an external source?”
• “Has the referenced source been superseded or refuted?”
• “Does the system have the authority to invoke the claimed tool?”

Crucially, the framework defines a taxonomy of failure modes—extrapolation, unsupported assertion, source‑knowledge mismatch, stale source, added hypothesis, and unsupported use—each with a formal predicate that can be checked automatically.

How It Works in Practice

Implementing the semantic abstraction involves three concrete components that interact in a pipeline:

1. Knowledge Base Compiler

Transforms curated domain knowledge (ontologies, rule sets) into a machine‑readable DKL. The compiler validates logical consistency and tags each fact with a confidence level.

2. Source Registry Service

Ingests external references (arXiv papers, API specifications, corporate policies) and annotates them with timestamps, version identifiers, and a “support matrix” that links each claim to the DKL entries it substantiates.

3. Semantic Guard Engine

Wraps the generative model (e.g., GPT‑4, Claude) and intercepts every output before it reaches the user or downstream tool. The guard performs three checks:

1. Justification Check: Verifies that any factual claim maps to an entry in the DKL or a currently valid source in the RSL.
2. Authority Check: Ensures that any tool call or action is permitted by the SCL (e.g., the agent is authorized to write to a database or send an email).
3. Temporal Consistency Check: Flags references older than a configurable freshness threshold or that have been explicitly refuted.

If a violation is detected, the guard either rewrites the output, appends a warning, or aborts the operation, depending on the policy configured by the system owner.

What distinguishes this approach from retrieval‑augmented generation is that the guard does not merely retrieve supporting documents; it enforces a *semantic contract* that the model must honor throughout the entire interaction.

Evaluation & Results

The authors evaluated the framework on three benchmark scenarios that reflect real‑world agent workloads:

Scenario A: Legal Drafting Assistant

A GPT‑based assistant was tasked with drafting a non‑disclosure agreement (NDA) while citing relevant statutes. The semantic guard identified 12 instances where the model quoted outdated case law, automatically replaced them with current citations, and reduced post‑generation fact‑checking effort by 78%.

Scenario B: Medical Triage Bot

In a simulated emergency‑room triage, the bot suggested treatment pathways based on a curated medical ontology. The guard caught 9 extrapolations where the model inferred a drug interaction not present in the DKL, preventing potentially harmful recommendations.

Scenario C: Financial Advisory Agent

The agent generated investment advice using live market data APIs. The guard flagged 5 stale source usages (prices older than 5 minutes) and forced a refresh, improving the timeliness metric from 62% to 96% compliance with the freshness policy.

Across all scenarios, the framework achieved a precision of 94% in detecting unsupported claims and a recall of 88% for stale‑source violations, while incurring an average latency overhead of only 120 ms per interaction—well within acceptable limits for most enterprise workflows.

Why This Matters for AI Systems and Agents

For practitioners building AI‑driven agents, the semantic abstraction framework offers a concrete pathway to move from “fluent but unverified” outputs to “verified by design” behavior. The benefits are threefold:

• Risk mitigation: By catching unsupported claims before they reach end users, organizations can avoid legal liability, reputational damage, and costly post‑mortems.
• Regulatory compliance: Many sectors (healthcare, finance, EU AI Act) require traceability of AI decisions. The framework’s explicit mapping to source metadata satisfies audit requirements.
• Operational efficiency: Automated guard checks reduce the need for human fact‑checkers, freeing engineers to focus on higher‑level orchestration.

Integrating this approach into an UBOS platform overview enables developers to plug the Semantic Guard Engine into existing workflow automation studios, ensuring that every generated message, API call, or database write respects the defined semantic contract.

What Comes Next

While the initial results are promising, several open challenges remain:

1. Scalability of the Knowledge Base Compiler: As domains grow, maintaining logical consistency without manual curation will require automated ontology learning.
2. Dynamic Source Management: Real‑time detection of refuted claims (e.g., retractions) demands continuous monitoring of the RSL, possibly via webhook subscriptions.
3. User‑controlled Granularity: Different applications may tolerate varying levels of strictness; exposing policy knobs in a user‑friendly UI is an engineering priority.

Future research directions include extending the framework to multimodal agents (vision‑language, speech) and exploring probabilistic reasoning over uncertain sources. From a product perspective, the next iteration will embed the guard directly into AI marketing agents, allowing marketers to generate campaign copy that is automatically vetted against brand guidelines and regulatory constraints.

In summary, treating AI outputs as semantic abstractions rather than raw facts equips developers with a rigorous toolkit for building trustworthy, accountable agents—an essential step as AI moves from experimental labs into the core of enterprise operations.

Andrii Bidochko

CTO UBOS

Andrii Bidochko is an AI entrepreneur and researcher focused on AI agents, reinforcement learning, and autonomous systems. He writes about the technologies shaping the future of machine intelligence, from frontier models and agent architectures to real-world AI applications.