AI Will Invent Languages Between Worlds

Artificial intelligence is moving through a sequence of abstraction layers. Prompt engineering asked how we should speak to a model. Context engineering asks what information, memory, tools and rules should surround it. Ontologies and semantic layers make the objects and relationships in a domain explicit. These techniques leave a harder problem unresolved: what happens when meaning must cross between domains that do not share the same representation?

Biology does not naturally speak TypeScript. A legal obligation is not a database transaction, and human intention is not executable software. Yet AI systems are increasingly expected to move between these layers. The challenge is not simply whether a model can read both sides. It is whether the translation can be engineered so that the relationships that matter survive the journey. That is the problem synthetic language engineering addresses.

Editor's note: In linguistics, a “synthetic language” is a language that expresses grammatical relationships through inflection or morphology. This note uses synthetic language engineering in a different, explicitly technical sense: the design of representational contracts that connect distinct computational, scientific or institutional domains.

Language is bigger than words

Language is more general than speech or code. It supplies distinctions, relationships and composition rules, plus enough shared structure for one participant to produce something another can reconstruct. Mathematics, music and programming languages all do this differently: a structure is expressed in one place and recovered somewhere else without becoming arbitrary.

Humans have traditionally carried much of the translation between domains. A clinician explained a requirement to an analyst, who turned it into a specification, which an engineer translated into code. Each boundary gave meaning another chance to narrow or drift. AI makes more of these boundaries traversable by machines, but fluency across representations does not prove fidelity. A plausible output can still drop a constraint, change the scope of a term or promote uncertainty into fact. Synthetic language engineering treats that translation as something to design and test, not as an incidental side effect of generation.

An ontology describes a world; a synthetic language connects worlds

Ontology engineering defines what exists in a domain and how those things relate. The W3C's OWL 2 standard provides a formal language for expressing classes, properties, individuals and relationships [1]. AWS documents an ontology-driven semantic layer for agentic AI in which ontologies, symbolic reasoning and virtual knowledge graphs provide shared context for agents [2]. Both make domain meaning more explicit and checkable.

An ontology, however, remains a model of a particular world. Suppose a physician says, “Reduce this patient's risk.” That intention may cross clinical knowledge, patient data, institutional policy, legal authority, software permissions, predictive models and human approval. Risk may be a probability in one representation, a clinical category in another and a threshold on action in a third.

A synthetic language is the engineered bridge across those layers. It does not collapse every domain into one vocabulary. It specifies what must remain recognizable while the representation changes: the relationship being carried forward, the transformation taking place, the constraints that still apply and the evidence that must return before the result can be trusted.

Conceptually, the path looks like this:

HUMAN INTENTION
        ↓
DOMAIN ONTOLOGY
        ↓
SYNTHETIC LANGUAGE
        ↓
MACHINE REPRESENTATION
        ↓
EXECUTABLE BEHAVIOUR
        ↓
OBSERVED CONSEQUENCE

Generation can move down this stack quickly. Establishing what survived is the harder job.

Translation survival

Those representations of risk are not identical, and they should not be. Each fits a different domain. The narrower engineering requirement is that the load-bearing relationships do not silently disappear as the concept moves among them.

We call that requirement translation survival. A translation survives when the relationships, constraints, provenance, uncertainty and consequences relevant to the task remain available after the representation changes. The output need not resemble the input, but the system should show which meaning was preserved, deliberately narrowed or lost.

This is more than format conversion. Changing JSON into XML transforms a representation. Converting a biological observation into a software action while retaining scientific uncertainty, authorization requirements and evidence lineage transforms a structure. A syntactically valid result can still be semantically wrong.

The idea extends Software Is Not Dead. We Have Barely Invented It.: as implementation becomes easier to generate, the durable engineering object moves above source code. Meaning, authority and invariants must constrain whatever implementation is produced. Synthetic language engineering lets those constraints travel.

Meaning is operational

Operational systems care about more than dictionary definitions. They care about what an expression makes possible: whether it opens a branch, requires evidence, blocks an action or triggers a human decision. A bank's concept of authorized matters because some actions become possible and others remain prohibited.

A synthetic language must therefore represent relations, boundaries and return conditions, while allowing two domains to classify the same situation differently. This is closely related to cognition engineering, which designs the conditions under which humans, models, tools, memory and software transform information into action. Synthetic language engineering focuses on the contract at the boundary: what one domain emits, what another may reconstruct and what must remain visible between them.

Context engineering is not the end of the stack

Google Cloud defines context engineering as managing the information available to an AI system, including instructions, memory and dynamic data [3]. The Model Context Protocol standardizes how AI applications receive resources, prompts and tools from external systems [4]. These are important layers, but neither guarantees semantic compatibility. A tool and an agent can exchange a valid message while meaning different things by customer, risk, evidence or approved.

Context engineering determines what enters the active field. Ontologies and semantic layers make domain structure explicit. Protocols expose resources and capabilities. Synthetic language engineering asks how meaning can move lawfully among them. The missing object is a translation contract that carries intention, scope and authority forward.

Programming may move above implementation

Programming languages were largely designed around human intention and machine execution. Synthetic languages can connect more endpoints: biology and software, chemistry and manufacturing, law and institutional action, or scientific theory and experiment.

The goal is not a universal vocabulary. It is to preserve invariant relationships while each domain keeps its own realization. A scientific observation should remain an observation when it enters a workflow; it should not become a command merely because software can execute one. Engineers may consequently spend less time describing every operation and more time defining the semantic conditions from which valid behaviour can be generated. Code remains essential, but the deeper artifact is the structure every implementation must preserve.

Machine-created abstractions require archaeology

Abstraction helps humans work within limited attention and working memory. We name a complicated structure, then use that name without reconstructing the whole structure each time. AI systems may eventually create similar symbolic shortcuts for recurring transformations. This is a design possibility, not an established outcome, and it is useful only if the compression remains inspectable.

A machine-created symbol whose derivation cannot be reconstructed is unauditable. The system must be able to descend from the symbol to its source expressions, transformations and evidence. When that descent fails, the failure should remain visible rather than being replaced by a plausible explanation. People need not understand every symbol immediately, but the system must preserve an accountable route back to meaning.

A language that can cause action needs jurisdiction

Once a synthetic expression can modify a record, schedule a machine or move money, it needs more than a definition. It needs jurisdiction: where it is valid, what evidence supports it, what uncertainty remains, what it may change and who may promote it into action.

The Semantic Warrant Layer addresses the authorization side of that boundary. Synthetic language engineering asks the corresponding representational question: which meanings and constraints must remain attached while an authorized transformation proceeds?

The practical rule is simple. Translation failure should be a first-class result, not a hidden hallucination. A system that cannot preserve the required relationship should abstain, request clarification or return the mismatch for review instead of substituting a nearby meaning and continuing toward action.

Languages between worlds

The first wave of modern AI taught machines to operate inside human language. The next may require representational systems through which distinct domains can work together without pretending they are the same. Biology need not become software, law need not become a database schema, and human intention must not be mistaken for executable authority.

Synthetic language engineering is not a replacement for prompts, context, ontologies, protocols or programming languages. It is the connective discipline that asks what must survive when one representation becomes meaningful inside another. The next important programming language may be designed for more than programming a computer: it may let two worlds express the same load-bearing relationship in different forms while preserving what must remain true when that relationship becomes executable.

References

1. W3C, OWL 2 Web Ontology Language Document Overview.
2. Amazon Web Services, Semantic Layer for Agentic AI Using Ontology, Symbolic Reasoning, and Virtual Knowledge Graph.
3. Google Cloud, What Is AI Context Engineering?.
4. Model Context Protocol, Specification.