LLMs & Language

The author's coinage for a large language model, short for Language Emulation Machine. The name is the argument: the model does not possess language the way a speaker does — it emulates the systematic use of signs, syntax, semantics, and pragmatics, reproducing their outward behavior from learned numerical patterns.

Signs (the carriers of meaning), syntax (the combinatorial structure), semantics (what expressions mean), and pragmatics (how situation fixes meaning). Each has a counterpart inside the model: tokens and numerical representations, learned structural regularities, learned contextual associations, and runtime context.

That meaning is fixed by situation, not by the sign alone. The word “bank” denotes a financial institution in one context and the edge of a river in another. Pragmatics — the runtime context — selects the reading. The model does the same work with its context window that a speaker does with a situation.

Signs become tokens and numerical representations; syntax becomes learned structural regularities absorbed from training text; semantics becomes learned contextual associations between those representations; pragmatics becomes the runtime context — the prompt, the conversation, the task. Nothing is declared; everything is encoded.

Nothing is false about it, but it undersells what the prediction machinery achieves. Next-token prediction is the training objective; language emulation — reproducing the systematic behavior of signs, syntax, semantics, and pragmatics — is what that objective produces at scale. “Langulator” names the product, not the mechanism.

Meaning that is encoded but not declared. In an LLM, what a token “means” exists only as patterns across numerical representations — recoverable by running the model, unavailable to inspection, and closed to deterministic inference. Fluent, approximate, and fundamentally probabilistic.

Meaning that is identified and declared: entities named by URIs, relationships stated as RDF triples, vocabularies shared through ontologies. Explicit semantics are machine-computable — a logic engine can apply rules to them and derive conclusions that follow necessarily.

The difference between the two kinds of semantics. An LLM associates “Paris” with “France” through learned contextual association — strong, fluent, and implicit. Explicit semantics instead declares the relationship (Paris is the capital of France) as an identified, declared, machine-computable fact that logic can build on.

The central image: language describes the world the way a map describes terrain. A map is useful precisely because it leaves things out — and dangerous when mistaken for the ground itself. Confusing an LLM's fluent map for the territory is the characteristic failure mode.

Five layers, loosely coupled: the LLM handles probabilistic natural-language work; RDF, Linked Data, and ontologies supply explicit machine-computable semantics; logic supplies deterministic inference; the agent harness supplies controlled action and skill/tool selection; data spaces — databases, knowledge bases, filesystems, APIs — supply ground truth.

Agents act, and acting on implicit semantics alone means acting on approximations. Grounding the agent's entities and relationships in explicit, identified, declared semantics gives it something deterministic to stand on: the fluent layer interprets intent, the precise layer constrains what may be concluded and done.

Not smarter models — the point is that raw capability was never the gap. The missing piece was the explicit semantic layer that lets machine intelligence be checked, grounded, and composed: identified entities, declared relationships, and logic. LLMs don't make explicit semantics obsolete; they make explicit semantics easier to use.