Grounding AI with Wittgenstein: From Language-Games to Epistemic Honesty

Press enter or click to view image in full size

Image generated with OpenAI’s DALL·E

“What is your aim in philosophy? To show the fly the way out of the fly-bottle.”
L. Wittgenstein, Philosophical Investigations, §309

TL;DR

LLMs hallucinate because they lack what Wittgenstein called “public criteria for correctness”, they master word patterns without the social practices that give language meaning. This post introduces LGDL (Language-Game Description Language), a framework that grounds AI in bounded “language-games” (like medical triage or contract review) rather than trying to master all of human language at once.

Key ideas:

• Meaning comes from use in specific practices, not universal patterns
• AI should know when it doesn’t know (epistemic honesty)
• Each domain has explicit rules, confidence thresholds, and negotiation strategies (language-games)
• An open-source MVP (LGDL) demonstrates these principles with three modes: training data generation for fine-tuning, deterministic interpretation for compliance, and runtime agents for production.

The goal isn’t perfect AI, but AI that negotiates uncertainty transparently instead of hallucinating silently.

Introduction

In the rapidly evolving world of artificial intelligence, Large Language Models (LLMs) such as GPT-5, Claude 4 Opus, or Grok have dazzled us with their ability to generate human-like text, permanently changing how we interact with computers. Yet beneath this fluency lies a persistent problem we know very well: “hallucinations.” At times, models confidently produce plausible but incorrect information. This probabilistic behavior creates unacceptable risks in high-stakes domains such as healthcare, finance, law, and emergency services, where mistakes carry severe consequences. Existing frameworks try to manage uncertainty through retries or validation loops, but they fail to confront the deeper issue: LLMs do not know when they do not know.

What if this is not merely a technical glitch, but a profound philosophical problem? Drawing on Ludwig Wittgenstein’s Philosophical Investigations, we can view hallucinations through the lens of his argument about the impossibility of a private language (PI §§243–315). Wittgenstein was analyzing human sensations and rule-following, not statistical models, but the analogy is instructive: when a system produces language without shared practices to anchor correctness, its outputs risk drifting into the same kind of groundlessness he warned against. The same work also offers an alternative: to understand language as a series of “language-games” (PI §23), where meaning is not defined a priori but arises from patterns of use within shared practices.

In this post, I will explore these philosophical foundations not as a scholarly exercise, for which I would not be qualified, but as practical inspiration for system design. I will then introduce the Language-Game Description Language (LGDL), a software framework that embeds AI systems in specific, bounded language-games to achieve genuine grounding. My contention is that LGDL offers a promising path forward. An open-source MVP is available today, not as a finished product, but as an early proof of concept, a starting point for experimentation and collaboration.

You can explore the implementation on GitHub:

This framework is speculative: Wittgenstein wrote about human minds, not machine architectures, so the analogies must be tested, not assumed.

Wittgenstein’s Insights: Why Philosophy Matters for AI

Wittgenstein’s Philosophical Investigations is not a book of technical definitions but an invitation to look differently at how language actually works. Several of his key insights about language, far from being abstract, may give us some clues of why LLMs fail, and why hallucination may not just be a bug but a structural feature of their design.

Meaning as Use (PI §43)

Perhaps Wittgenstein’s most famous dictum is: “For a large class of cases — though not for all, the meaning of a word is its use in the language.” Meaning is not stored inside words as a hidden essence; it is established through use in practice. Calling something a “pain” or a “checkmate” only makes sense within specific activities that give those words their role.

LLMs, by contrast, learn statistical correlations among words divorced from their direct practical use.

Embeddings bridge the gap somewhat, they’re not “completely divorced” from use, but they’re a map, not the territory.

They can reproduce the form of language but lack the practices that make words meaningful. This is why they can sometimes output fluent but groundless answers: they have tokens without use.

Language-Games and Forms of Life (PI §23)

Wittgenstein introduces the idea of language-games to emphasize that speaking is inseparable from human activities: “The speaking of language is part of an activity, or of a form of life.” Asking for medical advice, giving directions, or negotiating a contract are different games, each with their own rules, roles, and criteria for success.

Generic LLMs attempt to master all games simultaneously, but this collapses the boundaries that give words their sense. A model may apply patterns from casual conversation to legal reasoning, or from fiction to medical triage, without recognizing the shift in rules. This may be the root of many hallucinations: language used outside the game that gives it sense.

Family Resemblance (PI §§65–71)

When Wittgenstein asks what all “games” have in common, he concludes there is no single essence but a “complicated network of similarities overlapping and criss-crossing.” Our categories are not strict sets but flexible families of resemblances.

For AI, this means natural language categories are inherently fuzzy. Patients may describe “crushing chest pain,” “an elephant on my chest,” or “pressure in the chest.” Each resembles the other without being identical. Systems that require rigid categories break down; systems that can operate across resemblances become robust.

Uncertainty and Agreement in Judgment (PI §242)

Wittgenstein notes that communication requires more than shared definitions: it requires shared judgments about when words apply. “It is what human beings say that is true and false; and they agree in the language they use. That is not agreement in opinions but in form of life.” (PI §242). In other words, meaning is sustained by a background of practices and convergences that go deeper than dictionary entries.

LLMs, by contrast, produce text with the same surface confidence whether the underlying probability is high or low. They present outputs as if the required agreement already existed, when in fact there is no shared “form of life” to ground those judgments. This is not simply a matter of probabilistic weakness, but of lacking the very conditions that make certainty or doubt intelligible in human language-games.

Any responsible AI system must therefore make its uncertainty explicit; exposing thresholds, asking clarifying questions, or negotiating meaning, rather than simulating the settled tone of human judgment where none is possible.

The Private Language Problem (PI §§243–315)

Wittgenstein’s most radical claim is that a truly private language, one referring only to inner sensations is impossible, because there would be no public criteria for correctness. “Whatever is going to seem right to me is right. And that only means that here we can’t talk about ‘right.’” (PI §258).

Of course, Wittgenstein was analyzing human experience, not statistical models. But his insight still offers a useful lens. LLMs operate on patterns internal to their training data and embeddings; when they generate text that sounds plausible but has no external grounding, the situation parallels what Wittgenstein warned against: language cut off from shared practices.

This is not to suggest hallucinations are the private language problem in disguise. Rather, the analogy helps explain why hallucinations are not just bugs to be engineered away but symptoms of systems lacking public criteria for correctness. As Ryan Michael Miller argues in Does Artificial Intelligence Use Private Language? (2022), even advanced AI systems like deep learning networks cannot sustain a purely private language ; their states only become meaningful in relation to shared context, and that shared context reintroduces the possibility of error.

Why This Matters for AI Design

Taken together, these insights may reveal why hallucinations cannot be completely eliminated by more data or bigger models. They arise from a deeper contradiction: the attempt to create universal, context-free linguistic competence in a medium where meaning is always context-bound, social, and public.

This is where LGDL begins; not as an incremental improvement, but as a reorientation. By designing AI systems as participants in specific language-games, with rules, roles, criteria, and uncertainty management, LGDL begins to translate Wittgenstein’s philosophy into technical architecture, showing how his insights can inspire new design patterns for AI.

Introducing LGDL

The Language-Game Description Language (LGDL) is a new programming paradigm for designing AI agents that know when they don’t know. It looks like a small domain-specific language, but its purpose is large: to take Wittgenstein’s insights about language and turn them into executable constraints for conversational AI.

Instead of relying on a single, universal model that tries to cover all of human conversation, LGDL lets us define bounded “games”: domains such as medical triage, customer support, or financial compliance. Within each game, we specify the participants, the conversational “moves” they can make, the confidence thresholds that govern decisions, and the external capabilities that ground those moves in real-world practice.

An LGDL specification can be used in two ways:

1. As training data generation: producing thousands of realistic conversations that teach a model not only what to say but how certain it should be, when to negotiate, and when to escalate.
2. As a runtime contract: compiled into an interpreter that ensures every move follows the domain’s rules, logs confidence, and enforces safety (e.g. never guessing with cardiac symptoms, always escalating pediatric emergencies).

In practice, this means domain experts such as clinicians, lawyers, financial advisors, can encode their expertise directly as conversational rules without writing general-purpose code. LGDL aims to be a bridge: a language for describing the form of life in which an AI agent participates. The MVP only scratches the surface, but it shows how such a bridge could be built. And when LGDL specifications are used to generate training data or fine-tune even relatively small models, the result is not unlike today’s specialized LLMs, except that here the specialization is grounded in Wittgenstein’s account of how language “works”: as use, as rule-governed practice, as public activity rather than private representation.

How LGDL Embeds Wittgenstein’s Philosophy

LGDL is not just a programming tool; it is an attempt to operationalize Wittgenstein’s account of how language works. Each of its core features is deliberately shaped by an insight from the Philosophical Investigations.

1. Language-Games as Bounded Competence

Wittgenstein observed that speaking is inseparable from an activity or “form of life” (PI §23). LGDL formalizes this with the concept of a game: a bounded conversational context such as medical triage, legal review, or customer support. Within a game, the participants, roles, and outcomes are defined explicitly. This prevents models from drifting across contexts and using words outside the practices that give them meaning.

2. Moves: Meaning as Use

For Wittgenstein, “the meaning of a word is its use in the language” (PI §43). LGDL encodes this by making the move its basic unit of design. A move specifies not only how a pattern of language is recognized but what follows from it — ask a question, call a function, escalate to a human. Meaning here is inseparable from what the system does.

3. Confidence as Agreement in Judgment

Wittgenstein stressed that communication relies on shared judgments (PI §242). LGDL requires every move to declare a confidence threshold. If confidence falls below that threshold, the system does not guess; it negotiates, clarifies, or escalates. This makes epistemic uncertainty visible and actionable, replacing overconfident guesses with public criteria for judgment.

4. Family Resemblance in Pattern Recognition

Concepts such as “game” have no single essence, only overlapping similarities (PI §§65–71). LGDL embraces this by supporting multiple pattern types: strict, fuzzy, learned, and context-sensitive. A symptom like “chest pain” may appear as “tightness,” “pressure,” or “an elephant on my chest.” These variations are handled as family resemblances rather than treated as mismatches.

5. Negotiation as Epistemic Repair

When understanding is incomplete, Wittgenstein insists that we repair it through interaction, not through solitary definition. LGDL builds this into its control flow: “when uncertain” clauses instruct the system to negotiate, clarify, or escalate. This transforms potential hallucinations into structured dialogues that restore mutual understanding.

6. Learning from Use

Since meaning arises in practice, competence grows from participation. LGDL specifications can include learning rules: successful moves boost their confidence; failed ones trigger negotiation or escalation. Over time, the system evolves by remembering what worked, just as human understanding does.

7. Forms of Life Through Capabilities

Finally, Wittgenstein’s “forms of life” remind us that language is embedded in the broader activities of human institutions. LGDL connects moves to capabilities: APIs, databases, MCP servers (Model Context Protocol), external systems; so that words are tied to actions with public criteria for success. When a model says it will “notify a physician,” that isn’t metaphorical; it triggers a real capability call.

Together, these principles suggest that LGDL could grow into more than a design pattern: a way to discipline models into the public practices that make language meaningful. Instead of simulating universal competence, LGDL-trained LLMs and agents achieve bounded, auditable competence that reflects both philosophical insight and engineering necessity.

LGDL and Specialized Models: A Principled Path to Small, Competent LLMs

One of the most effective ways practitioners already manage hallucinations is by training or fine-tuning specialized LLMs: models tuned on legal corpora, medical records, financial regulations, or technical documentation. These smaller models often outperform general-purpose giants in their own domain, precisely because they “know less” but within the right boundaries.

LGDL takes this intuition further, and grounds it philosophically. Instead of treating specialization as just more data on top of a base model, LGDL provides a formal language for encoding the rules of a practice:

• Games define the boundaries of competence, making explicit what the agent can and cannot do.
• Moves turn domain expertise into conversational rules tied to concrete outcomes.
• Confidence thresholds ensure the model does not exceed its authority.
• Learning mechanisms let patterns strengthen only through successful use.

By compiling LGDL specifications into training data or fine-tuning sets, even relatively small models can be equipped with domain-specific competence that is philosophically grounded rather than heuristically patched. Where specialized models today risk reproducing the same epistemic overconfidence as their larger cousins, in principle, LGDL-trained models could give even small, specialized models a structure that encourages negotiation, escalation, and humility rather than unchecked guessing. At this stage, this remains an aspiration: demonstrating it rigorously will require benchmarks and case studies.

This opens a practical path: small, efficient models that are safer to deploy in real settings: from triage assistants in clinics, to compliance bots in finance, to contract review tools in law, because their competence is shaped by the very conditions Wittgenstein identified as making language meaningful in the first place.

LGDL as an Interpreter: Deterministic Understanding of Conversations

LGDL can be used not only to generate training data but also to interpret conversations directly. In this mode, an LGDL specification is parsed into an abstract syntax tree (AST) and compiled into an intermediate representation. The interpreter then executes the rules deterministically and it matches user input against declared patterns, evaluates confidence thresholds, and dispatches the corresponding actions.

The advantage of the interpreter approach is transparency and auditability. Every conversational turn is processed by explicit rules that can be inspected, tested, and versioned. Domain experts can write or edit LGDL games, and the interpreter ensures that conversations unfold only within those specified boundaries.

For example, if a patient describes “pressure in the chest,” the interpreter can match this to a triage move marked as “fuzzy” and evaluate whether the match confidence exceeds the required threshold. If not, the interpreter enforces the “when uncertain” clause — perhaps escalating to a human nurse. The key is that the rules are not hidden inside a neural network; they are encoded in the LGDL specification and executed deterministically.

This makes the interpreter mode particularly useful in testing, compliance, and regulated environments. You can run conformance suites, check for unreachable moves, verify that escalation always occurs in low-confidence scenarios, and ensure that sensitive information is tagged and handled correctly. In short, the interpreter shows how LGDL could function as a transparent execution engine for conversational rules, especially in testing and compliance contexts.

LGDL as a Runtime Agent: Safe, Negotiating AI in Production

Beyond deterministic interpretation, LGDL can also serve as the contract layer for a live AI agent. In this runtime mode, the LGDL specification is integrated with a language model, state management, and external capabilities. The runtime agent evaluates input through a cascade of pattern matchers, fast lexical checks, semantic similarity scoring, and makes calls to an LLM when they are needed for nuanced interpretation.

The critical innovation here is that uncertainty is computable. At every stage, the agent compares its confidence against thresholds defined in the LGDL game. High-confidence matches proceed with the prescribed actions, while low-confidence matches trigger negotiation, clarification, or escalation. This ensures that the agent never “hallucinates” silently; it always falls back on safe conversational repair strategies.

Runtime agents built this way can also connect to real-world capabilities such as hospital record systems, financial compliance checks, scheduling APIs; this way linguistic moves are grounded in verifiable actions. The runtime maintains both ephemeral state (the flow of a single conversation) and persistent state (what has been learned across sessions), allowing agents to evolve safely without retraining the underlying model.

The result is a production-grade conversational system that combines the adaptability of LLMs with the reliability of rule-based governance. Negotiation becomes the default response to uncertainty, audit trails are automatically generated, and policies such as rate limits or data-handling rules are enforced by the runtime.

For high-stakes domains, this points to LGDL’s potential as a foundation for AI agents that are more transparent, governable, and aligned with institutional practices, though today’s MVP is only a first sketch of that future.

Confidence: How the Runtime Decides

A central question for any LGDL runtime agent is how confidence is computed. Unlike LLMs, which return a flat distribution of next-token probabilities, LGDL treats confidence as an explicit, multi-signal decision process.

At a high level, the runtime follows four steps:

1. Candidate retrieval (fast): The agent first checks simple lexical patterns and then runs a semantic similarity search against a vector index of patterns for the current game. This yields a short list of candidate moves.
2. Scoring (composable): Each candidate is scored along multiple dimensions, including lexical match strength, embedding similarity, dialog context, and feasibility of required capabilities. If latency budget allows, heavier checks (like cross-encoder reranking or natural-language inference with an LLM) can be run on the top candidates.
3. Aggregation (calibrated): The individual scores are combined through a calibration model (e.g., logistic regression or isotonic regression) trained on labeled examples generated from LGDL specs. Out-of-distribution detection is also applied: if the input is too far from any exemplar, confidence is capped and the move is routed to negotiation.
4. Decision policy: Each move declares a confidence threshold (low, medium, high, critical). If the top candidate’s score clears that threshold, the confident path executes. If not, the “when uncertain” clause is triggered and starting negotiation, clarification, or escalation.

Training the calibration model starts from the LGDL specifications themselves. Each move definition can generate labeled positive and negative examples (e.g., “chest pain” as a positive for cardiac_assessment, “headache” as a negative). These examples form the initial training set for a simple classifier (logistic regression in the MVP). As more conversations are run in shadow mode, additional data can be added to refine the calibration.

For a concrete look, see the tests/test_confidence.py file in the LGDL MVP repo, where candidate moves are scored, calibrated, and compared against thresholds.

This approach makes confidence a first-class policy element, not an afterthought. It ensures that epistemic limits are explicit, inspectable, and enforceable at runtime.

LGDL in Practice: From Specification to Execution

LGDL is not just a thought experiment. A first MVP of the interpreter and runtime agent is already available as a proof of concept, open source at github.com/marcoeg/LGDL. This implementation uses a small working subset of the full grammar to parse and execute LGDL specifications. The complete grammar itself is written in EBNF and published in the repository (see here).

This mreans developers and domain experts can already: write LGDL games in a structured, validated syntax; parse them deterministically with the interpreter; un them inside a runtime agent that enforces confidence thresholds, negotiation, and escalation rules.

With this foundation in place, LGDL can be applied both as a deterministic interpreter for testing and compliance and as a runtime layer for production AI agents.

Transition

The real reason LGDL matters is not just engineering ingenuity. Its features were designed as translations of Wittgenstein’s insights into code. Each construct like games, moves, confidence thresholds, negotiation strategies, capabilities, reflects the way Wittgenstein described language: as use, as practice, as public, as game-bound.

From Wittgenstein to Engineering: Making Philosophy Operable

LGDL’s design is guided by Wittgenstein’s findings in the Philosophical Investigations: meaning is public, use-bound, and game-relative. These insights create a design obligation for AI: agents should act within specific practices that supply criteria of correctness, not in a context-free “universal language.”

LGDL encodes that obligation into language constructs, runtime behaviors, and measurable outcomes.The MVP shows how these philosophical ideas can begin to be encoded as engineering practice, an early experiment in how philosophy might be made into engineering practice.

1. Language-games as bounded competence

A game in LGDL is a formal container for a practice: roles, permissible actions, and the rules that govern success and escalation. Instead of a model that tries to be universally competent, you author competence for one domain at a time, for instance: triage, claims intake, contract review. This prevents meaning from drifting across contexts and makes “what counts as correct” explicit.

2. Moves: use gives meaning

If meaning is use, the unit of design isn’t a phrase, it’s a move: a trigger plus the actions that follow when the trigger is recognized. A move’s success is defined by what it does; ask, clarify, call a capability, escalate, not merely by what it says. That keeps language anchored to consequences.

3. Confidence as first-class epistemics

Communication requires agreement in judgment. LGDL makes this operational by letting each move declare a confidence threshold and by prescribing behavior when certainty is low. When confidence is above threshold, the system proceeds; when it isn’t, it negotiates, clarifies, or escalates. The result is epistemic honesty made executable.

4. Family resemblance encoded as pattern modifiers

Natural categories have blurred edges. LGDL patterns can be marked as strict, fuzzy, learned, or context-sensitive. This acknowledges overlap (“chest pain,” “pressure in chest,” “elephant on my chest”) without forcing brittle sameness, while still tying recognition to explicit confidence handling.

5. Negotiation as epistemic repair

When the system is uncertain, it doesn’t guess; it repairs the conversation. Negotiation prompts, choice menus, or targeted questions are first-class actions. This shifts failure from silent fabrication toward visible clarification.

6. Learning from use

Because meaning is shaped by practice, LGDL lets you strengthen patterns that led to successful outcomes and temper those that didn’t. The system improves through participation in the game, not through abstract generalities.

7. Forms of life via capabilities

Language takes place within institutions and tools. LGDL lets moves call external capabilities — look up records, measure vitals, check a policy, schedule a follow-up. Tying utterances to verifiable actions yields public criteria for correctness, short-circuiting “private” assertions.

A Minimal, Self-Contained Example

Here is a compact LGDL game that demonstrates these principles in a high-stakes context — emergency triage. It is intentionally small, but the same ideas scale to more complex domains.

What this buys us in practice

• Bounded competence: The agent cannot reinterpret casual chat as clinical advice; it only knows the triage game.
• Explicit uncertainty: If recognition isn’t confident enough, the path is to clarify and then escalate, not fabricate.
• Family resemblance: Strict/fuzzy/learned patterns capture real-world phrasing without diluting safety.
• Public criteria: Capability calls (notify, measure) tie words to verifiable actions.
• Evolvability: The learning block captures outcomes so patterns strengthen through use.

Why this design is safer and more auditable

• Fewer cross-context mistakes: Game boundaries reduce leakage of patterns from one domain into another.
• Measurable epistemics: Confidence thresholds, negotiation rates, and escalation rates become observable metrics rather than post-hoc explanations.
• Operational governance: Because moves, capabilities, and thresholds are specified, reviews and tests can target exactly where risk lives.

Beyond the Toy Example

The emergency_triage game shown here is intentionally compact, just a few moves, a handful of patterns, and some basic capability calls. Real-world triage would require dozens more moves, richer symptom vocabularies, edge-case handling, and integrations with hospital systems for vitals, records, and alerts. The purpose of the toy example is not to capture all that complexity, but to demonstrate how Wittgenstein’s principles map onto LGDL constructs. Scaling this approach to real domains is precisely the challenge the open-source project is now tackling.

For a fuller picture, the open-source repo includes an expanded medical example that shows how LGDL scales to more realistic scenarios, with critical, psychiatric, and pediatric pathways, negotiation flows, and escalation logic: Expanded Medical Example in the LGDL MVP repo

Extending to Model Training

Beyond serving as a runtime contract, the same LGDL specification can generate training data for fine-tuning smaller models. Thousands of conversation variants can be compiled automatically, giving even lightweight LLMs principled, domain-specific competence that is grounded in explicit rules rather than just more data.

Learning Without Drift

LGDL also includes a learning mechanism: “remember successful patterns.” But naive self-training would reintroduce the very biases and drifts LGDL is designed to prevent. To avoid this, learning is structured as propose-only, outcome-anchored, and gated by review.

1. Signals come from outcomes, not guesses: Only conversations with verified successful resolutions (e.g., clinician accepted the categorization, escalation was correct, a capability call succeeded) count as candidates for learning.
2. Candidates are constrained: New patterns are mined from successful phrasings or generated with controlled paraphrasing. They are attached to existing moves at low weight, without raising thresholds automatically.
3. Evaluation gates: Before adoption, candidates are tested against curated golden sets, slice checks (to catch bias), and leak tests (to ensure they don’t spuriously match other games). Calibration metrics (e.g., Brier score, which measures how well predicted probabilities match actual outcomes) must not degrade.
4. Human review and staged rollout: Any threshold changes or new strict patterns require human approval. New patterns are first enabled in shadow mode, then gradually rolled out while monitoring negotiation and escalation rates.
5. Guardrails for safety-critical moves: Critical moves (like cardiac chest pain escalation) never have thresholds auto-adjusted. They require explicit external validation before any learned variation can graduate to higher confidence.
6. Cross-game containment: Learned patterns remain scoped to their game unless deliberately exported, and simulations check that they don’t bleed into unrelated contexts.

Example:
Suppose a patient says:

“My chest feels like it’s being squeezed tight.”

The runtime resolves this confidently to the cardiac_assessment move and the outcome is validated (escalation was appropriate). From this, the system proposes “squeezed tight” as a new learned pattern attached to that move. The candidate is added at low weight and sent through evaluation gates (golden tests, slice checks, leak checks).

Only after review would it become active and it cannot raise the critical confidence threshold on its own. In Wittgenstein’s terms, the meaning of the new phrase emerges through its successful use in practice: the word ‘squeezed tight’ becomes meaningful for the agent not by definition but by its role in a shared activity, validated by outcomes.

The examples/medical/lgdl-medical-example-expanded.txt file in the LGDL MVP repo shows how moves can be marked with strict, fuzzy, and learned patterns, which the learning system extends cautiously.

This makes LGDL’s learning evolutionary but safe: it can expand its competence through use while preserving the principle of epistemic honesty. Drift is checked by explicit criteria, calibration, and human oversight.

Closing the Loop: From Hallucination to Grounding

Wittgenstein argued that a private language is impossible because there are no public criteria for correctness. Hallucinations in LLMs offer a parallel: models can generate fluent text that appears convincing, yet without shared practices to anchor correctness, the line between sense and mistake remains blurred.

LGDL addresses this by making those criteria explicit. A game defines the practice, a move ties recognition to action, a confidence threshold sets the limits of authority, and capabilities link words to verifiable outcomes. Negotiation and escalation are not fallback hacks but integral parts of the design, ensuring that when understanding falters the system repairs the interaction rather than fabricating an answer.

The emergency triage example shows this in practice. Instead of treating “pressure in the chest” as just another phrase, LGDL forces the agent to evaluate its confidence and either proceed safely or escalate. This is the opposite of private language: it is language situated in rules, consequences, and shared forms of life.

Seen this way, hallucinations are not mysterious glitches but the predictable outcome of systems attempting to use language without games, use, or grounding. LGDL reframes the problem and offers a principled starting point for building AI agents that at least begin to act as if they know when they don’t know.

A Note of Skepticism: Do Wittgenstein’s Ideas Translate?

It is fair to ask whether Wittgenstein’s analysis of human language-games can really be transplanted into software. His concerns were about how people follow rules, how our forms of life give words sense, and why a “private language” is impossible. LGDL borrows these ideas as design principles, but silicon is not the same as flesh-and-blood judgment.

Several counterarguments deserve mention:

• Human rule-following is not mechanical. Wittgenstein argued that following a rule is itself a practice, not a matter of interpretation alone (PI §§185–242). Encoding rules in LGDL may avoid regress in one sense, but it cannot recreate the lived background that makes rule-following intelligible among people.
• Forms of life are broader than institutions. A hospital protocol is one thing, but Wittgenstein’s “form of life” is the entire weave of cultural and social activity. LGDL can only model a thin slice of that reality.
• Certainty is not just probability. In On Certainty, Wittgenstein distinguished hinge certainties (framework conditions we do not doubt) from empirical knowledge. LGDL’s “confidence thresholds” may gesture toward this, but they remain engineered proxies.

In other words, LGDL should not be read as “Wittgenstein implemented in code.” It is better seen as a heuristic translation — taking inspiration from his insights about publicness, use, and practice, and applying them where they may illuminate design problems in AI.

Related Approaches

Other approaches tackle hallucination and grounding differently. Retrieval-Augmented Generation (RAG) constrains models by attaching external context, while hybrid symbolic/neural systems add structured reasoning on top of language models. LGDL shares the same goal of making AI safer and more reliable, but focuses on explicit conversational games and rules rather than context retrieval alone. These strategies are not mutually exclusive; in fact, LGDL could be layered on top of RAG pipelines or combined with hybrid methods.

Recent research also proposes language games as a pathway to overcoming the “data reproduction trap” in LLMs. Wen et al. (2025) argue that mechanisms like role fluidity, reward variety, and rule plasticity can keep models from stagnating by continually expanding their linguistic environment, drawing inspiration from Wittgenstein’s account of meaning as use.

Philosophical Grounding in Current Debates

LGDL is not alone in turning to philosophy for insight into how language models work and where they fail. A growing body of research is beginning to frame LLMs explicitly in Wittgensteinian or grounding terms.

• Private Language and AI: Ryan Michael Miller (2022) applies Wittgenstein’s private language argument to AI, arguing that without public criteria, machine-generated symbols risk drifting into meaninglessness. This reinforces LGDL’s focus on explicit games, moves, and confidence thresholds as ways of embedding public correctness into AI use.
• Dimensions of Grounding: Holger Lyre (2024) proposes that LLMs exhibit elementary grounding along three dimensions: functional (internal inferential roles), social (participation in human practices), and causal (reference via text as an indirect world model). LGDL resonates most strongly with the social dimension, since it encodes use and public forms of life as operational constructs, while also highlighting the causal limits of purely text-trained models.
• Surveying Philosophy of Language: Köhler, Brack, and Schlicht (2023) review LLMs through the lens of philosophy of language, covering Frege, Wittgenstein, Putnam, and others. They emphasize Wittgenstein’s view that meaning arises from use and argue that LLMs lack intrinsic intentionality: their “meaning” is derivative of interaction rather than internal representation. LGDL can be read as a response to this challenge, making use explicit through structured conversational practices.
• Language Games to ASI: Wen et al. (2025) argue that scaling language games with mechanisms like role fluidity, reward variety, and rule plasticity could overcome the “data reproduction trap” in LLMs and even open a pathway toward artificial superhuman intelligence. While LGDL is more modest, focused on domain-bounded safety, both projects share a commitment to Wittgenstein’s idea that meaning is use.
• Detecting Sloppy Games: Trevisan et al. (2025) introduce a “BS-meter” inspired by Margaret Masterman’s work under Wittgenstein, showing empirically that ChatGPT often defaults to language-games prioritizing fluency over truth. Their classifier provides evidence that without explicit correctness criteria, LLMs structurally tend toward “sloppy” uses of language — precisely what LGDL seeks to constrain.

Together, these threads suggest that philosophy is not just retrospective commentary on AI but an active resource for design. LGDL stands in dialogue with these approaches: modest in scope but aligned with a wider shift toward treating language-games, grounding, and public criteria as central to the next generation of AI systems.

Challenges and Open Questions

LGDL is still at an early stage, and while its principles are clear, several challenges remain open. Addressing them will be part of the ongoing development of both the language and the surrounding ecosystem.

Rule-Following and Interpretation Wittgenstein reminded us that rules never determine their own application (PI §§185–242). LGDL specifications are themselves rules, and the risk of misapplication always exists. The way forward is to treat specifications not as mere text but as executable contracts tied to verifiable outcomes. This helps prevent regress but raises important questions about how interpreters and agents will evolve as domains grow more complex.

Forms of Life Beyond Institutions LGDL has so far been described in terms of institutional practices — hospitals, compliance departments, legal offices. But Wittgenstein’s “forms of life” reach further, into the broader weave of human activity that makes language possible at all. How to embed AI systems into these deeper cultural and social contexts remains an open question.

Certainty and Framework Conditions Confidence in LGDL is not just a probability score. Some thresholds represent framework conditions that cannot be doubted within a game — for example, “escalate any suspected cardiac chest pain.” These resemble Wittgenstein’s “hinge certainties” (On Certainty) more than graded beliefs. Designing systems that can respect both probabilistic doubt and categorical certainty will be critical.

Learning Dynamics LGDL allows for pattern learning, but ungoverned learning risks recreating the same epistemic problems that plague large models. The current approach keeps learning “propose-only,” subject to human review. The challenge is to scale this without losing safety or slowing adoption.

Cross-Game Conversations Real interactions often cross boundaries — a medical triage conversation may turn into an insurance query. How to transition gracefully across games, or decide when to escalate to a human, is a design frontier for LGDL.

Scalability and Authoring Complexity Complex real-world domains can contain thousands of moves. Authoring such games by hand risks becoming unwieldy. Tooling like LGDL Studio will be essential, but questions remain about how to modularize and package games, manage versioning, and maintain safety at scale.

Performance Overheads Confidence evaluation, negotiation, and capability calls add latency. In critical domains, safety outweighs speed, but in consumer applications the trade-off may be more delicate. Engineering optimizations will be needed to make runtime agents both safe and responsive.

Empirical Parallels: The BS-Meter

These design challenges aren’t just theoretical. Recent empirical work has taken a Wittgensteinian angle on LLMs by asking whether their outputs drift into what Harry Frankfurt called “bullshit”: fluent but unmoored language. Trevisan and colleagues (2025) developed a “BS-meter,” a classifier trained to spot the sloppy language-games characteristic of ChatGPT outputs.

Inspired by Margaret Masterman, Wittgenstein’s student and an early AI pioneer, their system builds on her idea of a “semantic detector.” In practice, it can distinguish genuine scientific writing (e.g., Nature articles) from LLM-generated text. The key finding is that LLMs don’t just hallucinate randomly: their dialogue managers bias them toward certain language-games, often privileging fluency over correctness.

This work provides empirical backing for a core claim of LGDL. Without explicit criteria for correctness, systems tend structurally toward ungrounded language. LGDL’s goal is to make those criteria explicit through games, moves, and thresholds, so that what might otherwise look like “bullshit” becomes subject to public rules of use.

Conclusion: Toward Epistemically Honest AI

We began with a philosophical problem: hallucinations are not quirks of probabilistic models but the predictable outcome of attempting language without context, without rules, without public criteria of correctness. Wittgenstein showed us why — meaning is use, language is game-relative, and a private language is impossible.

LGDL is an attempt to turn those insights into engineering practice. It offers:

• a way to fine-tune even small models with principled grounding,
• an interpreter for deterministic execution and compliance,
• a runtime agent that negotiates uncertainty safely in production,
• and a language whose constructs map directly to Wittgenstein’s principles.

The challenges remain significant: rule-following regress, the depth of forms of life, the balance between certainty and probability, the dynamics of learning, cross-game transfer, scalability, and performance. But these are not reasons for dismissal; they are the very frontiers where progress must happen.

What emerges is not just another chatbot toolkit but the beginnings of a paradigm for epistemic honesty in AI, early steps toward agents that know when they don’t know. The MVP is modest, but the principles behind it are ambitious.

This post is the first in a series documenting the progress of the LGDL project, which is open source and evolving in the open. If these ideas resonate, I invite you to comment and share your perspective, participate in the ongoing development, or reach out directly at [email protected].

Together, we can explore what it means to build AI systems that don’t just talk — but converse responsibly, within the games that give language meaning.

Roadmap: What Comes Next in This Series

This post has laid the philosophical and conceptual foundation for LGDL. In the coming installments, I will turn to the practical side: how the system is being built, tested, and deployed in the open beyond the elementary MVP. The series will sketch possible directions for LGDL’s growth, from richer grammar tooling to experimental fine-tuning pipelines and collaborative environments like LGDL Studio. The following are the early concepts and prototypes I would like to explore and develop together with the community:

The Language and the Grammar

• A closer look at the LGDL grammar in EBNF.
• How games, moves, patterns, and learning clauses are parsed into an abstract syntax tree and compiled into an intermediate representation.
• Early design choices and trade-offs between expressive power and safety.

The Interpreter and Conformance Testing

• How the MVP interpreter executes LGDL specifications deterministically.
• The two-stage pattern matching engine (lexical + semantic).
• A walkthrough of the conformance test suite: syntax, semantics, and runtime validation.

The Runtime Agent

• How LGDL integrates with state management, external APIs, and Model Context Protocol servers.
• Negotiation strategies in live conversations.
• Safety features such as policy guards, prompt-injection firewalls, and run manifests for auditability.

Learning and Evolution

• The “propose-only” learning engine with human review.
• Shadow testing against historical conversations and A/B testing in production.
• Metrics for learning effectiveness and regression prevention.

LGDL Studio

• A web-based authoring environment for domain experts.
• Syntax-aware editing, linting rules, visual flow diagrams, and compliance tagging.
• Collaborative workflows for reviewing and refining games.

Fine-Tuning and Deployment

• Generating training corpora from LGDL specifications.
• Fine-tuning pipelines for small, domain-specific models.
• Deployment considerations: latency, cost, and compliance in production environments.

This roadmap is ambitious, but the project is already underway. Each post will document real progress in the open-source repository and invite discussion from practitioners, researchers, and domain experts.

Further Reading

Ludwig Wittgenstein, Philosophical Investigations (1953).
Classic text introducing language-games, rule-following, and the private language argument. Sections §§185–315 are especially relevant.

Ludwig Wittgenstein, On Certainty (1969).
Posthumous notes exploring the relationship between knowledge, doubt, and “hinge certainties” — useful for thinking about confidence thresholds.

Ryan Michael Miller (2022). Does Artificial Intelligence Use Private Language?
Applies Wittgenstein’s private language argument to AI, suggesting that without public criteria, machine symbols risk meaninglessness.

Holger Lyre (2024). Understanding AI: Semantic Grounding in Large Language Models.
Proposes a three-dimensional model of grounding — functional, social, and causal — and argues LLMs exhibit elementary grounding in these senses.

F. Köhler, M. Brack, & T. Schlicht (2023). Large Language Models and the Philosophy of Language.
Surveys LLMs through classical philosophy of language (Frege, Wittgenstein, Putnam, Davidson), emphasizing that LLMs lack intrinsic intentionality and that meaning is derivative of interaction.

Yilun Wen, Zhenhailong Wang, & Shun Zhang (2025). Language Games as the Pathway to Artificial Superhuman Intelligence.
Suggests language-game mechanisms like role fluidity and rule plasticity as ways to overcome the “data reproduction trap” and expand model capabilities.

Andrea Trevisan, Hannah Giddens, Stuart Dillon, & Alan F. Blackwell (2025). The BS-Meter: A ChatGPT-Trained Instrument to Detect Sloppy Language-Games.
Empirical work inspired by Margaret Masterman and Wittgenstein, training a classifier to detect “sloppy” or ungrounded LLM outputs.