Glages: Why the Model Is Code

Glages is a formal-model production technology for creating explicit, machine-checkable Glages Models from generalized domain knowledge. The Glages Model Factory provides the production system for creating, verifying, composing, specializing, packaging, releasing, and maintaining them systematically.

At the model-paradigm level, Glages Models can be described as a new type of AI model: explicit formal, machine-checkable models whose stable meaning can be inspected, verified, reused, composed, and specialized independently of the probabilistic model that may help produce them.

That combination immediately raises a practical engineering question: if a formal model is supposed to become a working computational asset, what does the model physically become?

In the selected Glages Language architecture, the semantic source of truth is typed code. The model does not remain only as a document that another system must reinterpret later. Its concepts, relationships, possible states, required-fact contracts, Process definitions, conditions, permitted changes, Result values, declared operations, and stopping boundaries become software structure that can be compiled, analyzed, tested, versioned, and reused.

For a released model version, the verified typed Glages Model structure defines the Stable Formal Structure of the modeled world for that exact released Glages Model version. Runtime State can change from case to case, and different compatible Execution Mechanisms can act within it, while the released model preserves the versioned meaning that software is required to respect.

This does not mean that a released Glages Model is merely a C# source file. The released product also carries identity, version information, dependencies, its Formal Model Interface, verification and adequacy metadata, documentation, compatibility information, and package integrity information. For Glages Model semantics, the typed Glages source is the semantic source of truth. Binding external constraints retain their own evidence authority through the applicable Binding Domain Evidence and provenance record. After release, the verified package is the distributable form of the released Glages Model product.

A Model Must Have a Machine-Readable Form

The Glages Model Factory begins with generalized domain knowledge represented through Domain Evidence, together with Glages Model assets in the Accepted or Released lifecycle state where relevant, and turns candidate meaning into formal machine-checkable structure. AI-assisted material remains candidate production material until it is represented formally and evaluated through Program Acceptance.

A Glages Model plays a different role from its production evidence. It must expose enough machine-checkable structure that software can determine what concepts exist, what facts are required, what states and changes have formal meaning, what operations are declared, which Result values are possible, and where the model stops. Binding external constraints represented in that structure retain their evidence authority through the applicable Binding Domain Evidence and provenance record. That requires machine-checkable structure rather than prose alone.

A working model therefore benefits from engineering properties that ordinary software development already handles well: explicit types and relationships, compiler-visible structure, machine-checkable contracts, static analysis, tests, version control, reusable libraries, and dependency tracking. Glages uses those properties to make important operational meaning inspectable by software.

Why C# Is the Selected Host Representation

The selected Glages Language architecture is:

C# host syntax and type system
+
Roslyn compiler and semantic infrastructure
+
.NET runtime
+
restricted Glages language semantics
+
one unified Glages language system
for model definition and programming inside the model

C# is the selected host-language foundation for the current Glages Language architecture.

The Glages decision concerns the full production environment. C# provides a mature strongly typed language, Roslyn provides programmatic access to compiler syntax and semantic information, and .NET provides a mature cross-platform runtime and software ecosystem. Microsoft documents Roslyn specifically as a compiler platform that exposes syntax trees, semantic models, diagnostics, analyzers, and source-generation capabilities through APIs.

Those capabilities matter because Glages needs software not only to execute code but also to inspect and reject candidate model structures before Program Acceptance can move a candidate Glages Model into the Accepted lifecycle state.

The Production Environment Matters More Than a Language Contest

A Model Factory has different requirements from a one-off application. Systematic production of Glages Models requires a connected environment for typing, compilation, semantic analysis, static verification, source generation, testing, debugging, package management, deployment, and long-term maintenance.

Glages should concentrate proprietary engineering on the part that is genuinely new: formal model semantics, restrictions, verification, Model Adequacy, composition, specialization, model libraries, production methodology, and release discipline. Mature general-purpose infrastructure can supply the rest.

This supports a broader production principle:

A model factory should be built on a software factory.

At this stage, the principle is architectural. Glages can create a new production layer without first rebuilding the software industry underneath it.

Code Creates an Independent Verification Surface

Suppose an LLM proposes a candidate model fragment. If the result remains only natural-language output, any downstream system must interpret that output again. Once candidate meaning is represented as typed formal source, a different class of mechanisms becomes available.

The source can be compiled, inspected semantically, checked by Glages analyzers, compared with Model Library contracts and dependencies, tested, versioned, and rejected before Program Acceptance. The production relationship becomes:

AI proposes candidate structure
↓
formal source represents the candidate
↓
independent software mechanisms inspect it
↓
candidate may be accepted or rejected

The model is therefore not trusted because the LLM sounded convincing. It must survive an acceptance system whose authority is separate from the generator.

Code Is the Semantic Source Within the Released Product

The distinction between semantic source and released product is important. A released Glages Model product includes:

typed formal model source
+
Formal Model Interface
+
model identity and version
+
dependency information
+
verification metadata
+
adequacy metadata
+
compatibility information
+
documentation
+
package integrity information

The typed Glages source carries the formal model meaning. Package construction and package and integrity checks produce the verified release package, and Release moves the model into the Released lifecycle state together with that package.

The phrase "the model is code" describes semantic authority: typed Glages source carries the model meaning. The released product additionally includes the versioned, verified packaging and product metadata required for durable distribution and reuse.

Why the Human Workforce Still Matters

A factory eventually has to be staffed. Some work requires specialized Glages expertise, including formal semantics, analyzer design, verification architecture, composition, specialization, and Model Adequacy. Much of the surrounding engineering remains recognizable software work: typed model implementation, testing, diagnostics, tooling, package maintenance, compatibility work, and production engineering.

Using a mainstream engineering platform allows Glages to build on a mature professional C#/.NET ecosystem rather than requiring a new general-purpose programming ecosystem before model production can scale. The industrial advantage is the existing combination of professional communities, tooling, training, and maintenance practices.

That affects hiring, cost, training, and long-term maintainability. The production-economics argument becomes stronger when the Model Factory is viewed as an industrial system rather than as a language project.

A New Type of AI Model With a Familiar Physical Form

The unusual part of Glages is not that code exists. The unusual part is what the code represents, how it is produced, and what authority it receives.

Modern AI can help transform generalized domain knowledge into candidate formal structure. The selected C# / Roslyn / .NET architecture gives that structure a physical software form that can be examined independently. The division of labor is:

LLM
helps construct candidate meaning

Glages Language
expresses that meaning formally

Program Acceptance
checks the candidate and moves the Glages Model into the `Accepted` lifecycle state when successful

Model Factory
establishes Model Adequacy

package construction
produces a candidate release package

package and integrity checks
produce a verified release package

Release Eligibility
determines whether the accepted model and verified release package satisfy the requirements for Release

Release
moves the model into the `Released` lifecycle state

released Glages Model
becomes the reusable product

This is why the model is code: the model must become something that machines can inspect without asking another probabilistic system to reconstruct its meaning.

Verification Follows Formal Representation

Once candidate meaning has a formal software representation, the production system can reject invalid artifacts through compiler checks, Glages analyzers, semantic verification, and the deterministic Program Acceptance path. Formal representation therefore creates the independent verification surface that separates candidate generation from the machine-checkable meaning of an accepted artifact.

Sources

• Microsoft, .NET
• Microsoft, .NET and .NET Core official support policy
• Microsoft Learn, The .NET Compiler Platform SDK