Glages: From AI Output to an Accepted Glages Model

The most important role of a large language model in Glages may be to help manufacture the model rather than reconstruct the complete process every time the process runs.

Modern LLMs can work across broad bodies of source material and learned patterns to compare formulations, identify candidate concepts, propose formal structures, generate software fragments, and respond to diagnostics. Glages uses those capabilities during model production while keeping Domain Evidence, Glages Model assets in the Accepted or Released lifecycle state, and Glages verification as the authoritative production basis.

The production relationship is:

AI output
→ candidate material

A candidate Glages Model enters the Accepted lifecycle state only after it has been represented formally and has passed Program Acceptance.

Model Production Starts With Generalized Domain Knowledge

The 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. Large language models process those production inputs and generate candidate structures, questions, comparisons, tests, and formalizations. Their output remains candidate production material rather than evidence authority.

Domain Evidence is divided into two classes. Binding Domain Evidence includes applicable law, regulation, mandatory standards, governing network or protocol rules, and other mandatory external constraints. Informative Domain Evidence may include public documentation, research, reference literature, verified public or generalized cases, and reproducible abstract cases.

Existing accepted or released Glages Model assets are reusable production inputs rather than Domain Evidence. Factory tests and corrections are also reusable production assets.

A binding constraint must remain traceable to the authoritative source that establishes it. LLM-recalled material, summaries, and secondary descriptions can support discovery and interpretation, but they do not by themselves establish a binding constraint.

This source discipline matters because the Factory is producing reusable models of declared classes, not reproductions of one organization's local process. The model must be able to stand independently of a particular recipient implementation.

AI Is a Candidate Generator

An LLM can help identify possible concepts, compare terminology, propose states, draft relationships, suggest rules, generate tests, locate apparent contradictions, and propose formal code. This capability changes the economics of model construction because it reduces the manual effort required to explore a large body of generalized domain knowledge.

Probabilistic generation also creates uncertainty. The same flexibility that makes an LLM useful for exploration prevents it from becoming the final authority for formal model meaning.

Glages therefore makes AI output provisional by design.

Candidate Meaning Becomes Formal Source

The next step is to represent candidate meaning in the Glages Language. In the selected architecture, C# host syntax and type structure are combined with Roslyn, restricted Glages semantics, model libraries, analyzers, and verification rules.

Once candidate meaning becomes formal source, the production system can inspect it structurally through compiler, analyzer, semantic-verification, and Program Acceptance mechanisms rather than relying on probabilistic plausibility. This is where temporary AI output begins to become a durable software artifact, although the artifact is still only a candidate.

Program Acceptance

Program Acceptance asks:

Does this candidate Glages Model or Glages program satisfy the formal validity requirements for acceptance?

For a standalone candidate Glages Model, the core stages are:

Language Validity
→ Structural Validity
→ Model Semantic Validity
→ Accepted / Rejected

When an artifact includes or represents application software, Application Conformance also applies.

Language Validity establishes that the source conforms to the permitted Glages Language. Structural Validity checks whether required formal relationships and contracts are represented explicitly. Model Semantic Validity deterministically checks the semantic-consistency categories defined by the Glages verification architecture within the artifact's declared scope.

The stages are distinct because different mechanisms can prove different things. Program Acceptance is deterministic under the defined language, model, and verifier conditions.

The Accepted Lifecycle State Means Something Specific

An accepted Glages Model has crossed a meaningful boundary. It is no longer merely an AI suggestion; it is a formally valid Glages artifact under a defined verification context.

That accepted model can become a durable Model Factory production asset. It can be versioned, reused as a production input, used as an input to composition or specialization, tested again, documented, and compared for compatibility. For Glages Model semantics, the accepted typed model is the machine-checkable semantic source of truth. Binding external constraints retain their own evidence authority through the applicable Binding Domain Evidence and provenance record.

This separation also creates provider independence. A later production cycle may use another LLM vendor, another model version, a human programmer, or another candidate-generation mechanism. Accepted model meaning remains defined by Glages semantics and verification rather than by the generator that happened to produce the first candidate.

Program Acceptance and Model Adequacy Answer Different Questions

Program Acceptance establishes formal validity. It does not establish that the model covers enough of its declared process class to qualify for release.

A model may be internally coherent and still omit a common process variant, a mandatory regulation, an important failure path, a required relationship, or a recurring Result. Nothing inside the artifact may contradict anything else; the defect is what the artifact failed to cover.

Glages therefore separates two questions:

Program Acceptance
Is the model formally valid?

Model Adequacy
Is the accepted model sufficiently complete and competent
for its declared process class and scope?

This separation prevents the compiler and analyzers from being asked to prove the entire domain, while also preventing any formally consistent model from being treated automatically as a finished product.

After Program Acceptance, the Model Is a Factory Asset Before It Is a Product

An accepted model can already strengthen later production. It may become a parent for specialization, participate in composition, or supply reusable formal concepts to later models. Separately retained Factory assets such as Passing and Failing Model-Verification Cases, tests, corrections, and diagnostics can support verification, regression, and later production without becoming Domain Evidence.

Release as a reusable product comes later. The production path continues:

accepted Glages Model
→ Model Adequacy
→ package construction
→ candidate release package
→ package and integrity checks
→ verified release package
→ Release Eligibility
→ Release
→ released Glages Model

This distinction is a defining feature of the Glages architecture. It separates a formally valid accepted model from a released Glages Model product that has completed the full release path.

Why This Matters for AI Engineering

Many AI systems treat successful generation as the central event and add evaluation afterward. Glages treats generation as the beginning of a production pipeline.

The core transformation is:

Domain Evidence representing generalized domain knowledge
+
Glages Model assets in the `Accepted` or `Released` lifecycle state where relevant
→ AI-assisted candidate structure
→ Glages formal source
→ Program Acceptance
→ accepted Glages Model

AI remains central to the economics of production because it helps create and repair candidates quickly. What changes is authority.

AI can propose. Program Acceptance determines whether a candidate Glages Model enters the Accepted lifecycle state.

The Accepted lifecycle state therefore establishes a durable formal asset, while transition to the Released lifecycle state additionally requires Model Adequacy, verified packaging, positive Release Eligibility, and Release.