Glages: A Different Kind of AI Model

Artificial intelligence is currently discussed as though the word model has one obvious meaning.

A model is assumed to be a large learned neural network. It is trained on enormous quantities of data, stores statistical structure in its parameters, receives an input, and produces a prediction, continuation, plan, answer, or action.

That model class has produced extraordinary results. Large language models can interpret text, generate code, compare alternatives, use tools, and reconstruct patterns that were never explicitly programmed. World-model research is extending learned representation beyond language toward physical dynamics, prediction, and planning.[1][2]

But these are not the only possible forms of computational model.

There is another class of model whose purpose is different. Instead of learning a latent statistical representation and reconstructing meaning at runtime, it represents selected knowledge explicitly. Its entities, states, processes, relationships, conditions, actions, results, and boundaries can be inspected and checked directly. Its structure can be reused without asking a probabilistic system to infer the same meaning again.

Glages is a formal-model production technology for creating reusable, machine-checkable models from accumulated knowledge and source material.

The important claim is not that formal models should replace language models or world models. The claim is that modern AI may require several fundamentally different model classes, each suited to a different computational responsibility.

Glages develops the production of one of those classes.

Model Does Not Mean One Thing

The current AI market was shaped by foundation models because they solved a problem at an unprecedented scale.

A large language model converts enormous bodies of human-produced text and other data into a learned statistical representation. The same model can then perform many tasks that were previously separate software problems.

This created a natural tendency to equate progress in AI with improvements in one model family.

Yet AI research itself is already moving beyond that assumption.

Yann LeCun's JEPA research, for example, is based on a different objective. V-JEPA learns predictive representations in an abstract latent space rather than generating every observed detail, and V-JEPA 2 extends this line toward physical-world understanding, prediction, and planning.[1][2] The significance of this work is larger than any single benchmark. It demonstrates that a serious AI research program can begin from the premise that a different representation and learning objective is required for a different kind of intelligence.

This distinction matters for Glages.

Glages is not another attempt to train a general-purpose language model. It addresses a different problem:

How can accumulated knowledge and source material be converted into explicit, reusable, machine-checkable computational models?

That question leads to a different model architecture and a different production system.

Learned Models and Formal Models Solve Different Problems

A learned model is powerful because it can generalize from examples.

It can interpret an unfamiliar sentence, recognize a pattern, infer an unstated relationship, or propose a plausible solution. Its knowledge is distributed through learned parameters and activated probabilistically at runtime.

A formal model is powerful for almost the opposite reason.

It makes selected meaning explicit.

A formal model can state:

• what Entities exist within its scope;
• which Processes may occur;
• which states and relationships matter;
• which facts are required;
• which conditions permit or block an action;
• which changes are allowed;
• which results are valid;
• which situations remain outside the model;
• what must be preserved for verification or traceability.

The value comes from being able to determine these things without reconstructing them from statistical context during every execution.

The two forms are complementary.

A probabilistic model is useful when interpretation is uncertain.

A formal model is useful when operational meaning must remain stable.

A language model can interpret a customer's message.

A formal model can determine which facts must exist before a refund can be considered.

A vision model can recognize an object.

A formal model can define which actions involving that object are permitted in the current state.

A world model can predict likely physical consequences.

A formal model can represent mission rules, authority, required evidence, permitted transitions, and stopping conditions.

The question is therefore not which model class wins.

The question is which kind of model should carry which kind of meaning.

A Different Way to Turn Knowledge Into Computation

Foundation-model production follows a recognizable pattern:

large data corpus
→ training
→ learned probabilistic model
→ runtime inference

Glages proposes another production path:

accumulated knowledge and source material
→ candidate formal structure
→ machine-checkable representation
→ verification
→ reusable formal model
→ composition and specialization
→ application

The inputs may include policies, contracts, manuals, software behavior, APIs, database structures, logs, cases, existing code, and knowledge available through large language models.

The output is not another natural-language summary of those sources.

The output is a computational artifact whose structure can be checked independently of the language used to describe it.

This is why the word factory matters.

The long-term objective is not to handcraft one process model. It is to develop a system that can produce many models systematically, reuse verified structures, combine compatible components, specialize general models for narrower applications, and accumulate corrections across a growing model library.

A refund model is therefore not the scale of the idea.

It is one possible unit produced by the technology.

The larger idea is an industry of formal model production.

The Model Can Be Smaller Than the Intelligence That Produced It

One consequence of this architecture is easy to miss.

A powerful model may be used to produce a much smaller formal model.

That is not a reduction in value.

A frontier LLM may read hundreds of documents, compare terminology, identify candidate relationships, propose code fragments, or suggest tests. Once a stable relationship has been identified and formally represented, the runtime system may no longer need frontier-scale inference to use it.

This pattern already appears in recent research.

Compiled AI uses LLM reasoning during a compilation phase and then executes validated code artifacts deterministically without further model invocation.[3] Kintsugi uses an agentic editing loop to improve a typed executable knowledge base, but deploys the accepted knowledge base through deterministic symbolic execution with zero LLM calls at inference.[4] ATA separates offline knowledge ingestion, where an LLM produces a symbolic knowledge base, from online task processing, where a symbolic decision engine produces the result.[5]

These systems are different from Glages and from one another. They nevertheless demonstrate an important architectural possibility:

A probabilistic model can help produce a durable computational artifact whose later use does not require repeating the original probabilistic reasoning.

This direction also has an earlier software lineage. DSPy introduced a programming model in which declarative LM modules are compiled into optimized LM pipelines rather than hand-assembled prompt chains.[13] DSPy still executes language-model calls at runtime, so it is not a formal-model system, but it is an important predecessor of the broader idea that probabilistic model behavior can be separated from a compilation or optimization layer.

That possibility is central to Glages.

A Library Instead of One Universal Model

The dominant foundation-model strategy seeks broad capability in a relatively small number of very large models.

Glages has a different natural scaling pattern.

Its value can grow through the production of many explicit models:

payment
refund
reservation
delivery
approval
claim
repair
document verification
hotel operations
e-commerce
logistics
autonomous mission rules
device constraints
verification references
planning models
...

Each model may then be specialized.

A general payment model may be specialized for hospitality, insurance, e-commerce, or another application. A broad operational model may be reduced to the scope needed by a particular device, mission, organization, or software system.

This creates a different model economy.

The important asset is not one universal artifact expected to reconstruct everything.

The asset is a growing system of compatible models that can be:

• verified;
• reused;
• composed;
• specialized;
• corrected;
• connected to different execution mechanisms.

The library can become richer without requiring every application to carry the entire library at runtime.

This is especially important for systems with constrained compute, latency, connectivity, or certification requirements.

Formal Models Are Not New

The idea of formal computational structure is not new, and Glages should not be presented as though it invented it.

Computer science has long used formal specification, type systems, logic, state machines, model checking, classical planning, rules, static analysis, and executable models.

The relevant development is that modern AI changes the economics of constructing and maintaining these structures.

Historically, formalization was expensive.

People had to read source material, reconcile terminology, discover implicit assumptions, define structures, encode rules, build tests, and maintain correspondence between the formal representation and the changing real system.

For many business and operational domains, leaving a person inside the loop was cheaper.

Large language models change that calculation.

They can help read fragmented source material, identify candidate concepts, compare many formulations, translate natural language into formal representations, propose executable artifacts, and assist with repair.

Recent hybrid systems make this change visible.

LLM+P translates natural-language planning problems into PDDL and delegates planning to a classical planner.[6] Later work has gone further by using LLMs to construct explicit domain models and then using sound planners against the corrected formal model.[7] ARc formalizes natural-language policies into logical artifacts and performs symbolic verification against them.[8]

The new opportunity is not that formal models suddenly became useful.

It is that AI may make their production practical at a scale that was previously uneconomic.

Business Process Research Is Formalizing the Activity Itself

A separate research line is important because it approaches the same problem from business process management rather than from LLM architecture.

The 2026 Agentic Business Process Management: A Research Manifesto, written by eighteen researchers from the BPM and AI communities, argues that autonomous agents in organizations require explicit process frames and process awareness so that autonomy remains constrained and aligned with organizational goals.[14] Dumas, Milani, and Chapela-Campa similarly propose Agentic Business Process Management Systems in which agents sense process state, reason about improvement opportunities, and act within process-aware systems.[15]

A Formal Framework for Declarative Agentic AI in Business Process Analysis moves even closer to formal representation. Its AGO methodology defines Agents, Goals, and Objects using set theory and mathematical logic and organizes them into a Business Process Knowledge Base that supports structured querying, incremental updates, and automatic workflow generation.[16]

These works do not propose the Glages production architecture. Their importance is different. They show that the need to represent business activity explicitly is becoming a research problem in its own right, not merely an implementation detail of agent orchestration.

Enterprise Systems Are Also Moving Toward Explicit Operational Models

The same pressure is visible outside academic research.

Palantir describes its Ontology as an operational layer that combines data, logic, action, and security, and uses object types, action types, functions, and relationships to provide a shared operational foundation for humans and agents.[9][10]

Microsoft Fabric IQ describes its Ontology as a governed shared business model for teams, agents, and workflows. It defines business entities, relationships, properties, rules, and actions, and supplies agents with common definitions and governed context rather than exposing only raw tables and columns.[11][12]

These platforms are not Glages Model Factories.

They show something else that matters.

Large enterprise systems increasingly need a representation that is distinct from the LLM itself and that carries business meaning, relationships, rules, and permitted actions in a more explicit form.

That is practical evidence that the model problem exists.

Glages addresses the production problem behind it.

The Bitter Lesson Is an Important Objection, Not a Refutation

Any proposal for explicit formal structure must address Richard Sutton's Bitter Lesson: historically, general methods that scale with computation have often displaced systems built around large amounts of hand-engineered domain knowledge.[17]

Glages should not be positioned against that lesson.

The factory is not based on manually encoding expert intuition into a fixed handcrafted intelligence. It uses scalable learned models precisely because they are powerful tools for reading, comparing, proposing, translating, and repairing candidate structures. The explicit model is retained only where stable operational meaning, constraints, or reusable relationships need to survive independently of runtime inference.

The relevant division is therefore not:

learning
versus
human-designed knowledge

It is:

learning and search
for discovering or constructing candidates

plus

explicit verified structure
for what must remain stable, inspectable, and reusable

The open empirical question is where that boundary should lie for each application. Glages does not require a universal answer.

What Glages Adds

Several existing lines of work already demonstrate pieces of the architecture:

• learned models can translate natural language into formal structures;
• formal planners can outperform direct LLM planning when a valid domain representation exists;
• symbolic verification can provide stronger correctness properties than unrestricted language-model judgment;
• deterministic execution can eliminate repeated runtime inference for stable logic;
• ontologies can provide shared semantic and operational structure for enterprise agents;
• executable knowledge bases can become persistent artifacts that improve through verified repair.

Glages does not need to claim these discoveries as its own.

Its proposition is different.

Glages treats the systematic production of reusable formal models as the primary technology.

The factory must be able to:

produce
verify
reuse
compose
specialize
connect
maintain
and improve
formal models

The model itself becomes a durable computational asset.

The LLM may help produce it.

A compiler may verify parts of it.

A symbolic engine may use it.

A conventional program may execute it.

An agent may operate inside it.

A robot may use a specialized version.

A certification system may use it only as a reference and never execute it.

The model remains distinct from all of those mechanisms.

The Hard Problem Is Producing the Formal Model Correctly

The strongest evidence for hybrid and compiled architectures also exposes the central unsolved problem.

ATA's fully automatic formalization achieved 72.94 percent accuracy on its travel-insurance task; after the authors manually corrected missing clauses, missing predicates, and ambiguous predicate definitions, accuracy rose to 87.17 percent.[5] Compiled AI states the limitation directly: the specification problem remains fundamental, because deterministic execution is only as reliable as the specification that was compiled.[3]

This does not weaken the case for a Model Factory. It defines the research problem the factory must solve.

The difficult step is not proving that a verified formal artifact can be valuable after it exists. Multiple systems already demonstrate that. The difficult step is producing the right artifact from incomplete, inconsistent, and distributed knowledge with sufficiently strong verification.

Glages is therefore not a claim that formalization has been solved.

It is a technology program organized around solving and industrializing that production problem.

The Scale of the Idea

It is easy to describe Glages too narrowly.

A business-domain model sounds like an enterprise-software component.

A process model sounds like a specification.

A compiler sounds like a developer tool.

An automation runtime sounds like infrastructure.

Those descriptions identify possible applications or components, not the scale of the underlying idea.

The larger proposition is this:

Knowledge can be converted systematically into a new class of reusable computational models whose meaning is explicit enough to be checked, combined, specialized, and used independently of the probabilistic system that may have helped create them.

If that proposition works, its scope is not one automation market.

The same production principles can support models for:

• business activity;
• autonomous systems;
• robotics;
• planning;
• simulation;
• formal verification and certification;
• software design;
• edge and inference-constrained systems;
• other computational domains where stable structure should not be reconstructed repeatedly at runtime.

This is comparable in ambition to other model paradigms not because the models are identical, but because the proposed unit of value is itself a model.

OpenAI, Anthropic, Google, Meta, and other foundation-model companies demonstrated the enormous value of producing probabilistic models from accumulated data.

World-model research asks how learned models can represent and predict physical reality more effectively.

Glages asks a complementary question:

Can accumulated knowledge be converted systematically into libraries of explicit formal models that become reusable computational infrastructure?

That is not a feature of an agent.

It is a different model-production paradigm.

Different Models Can Work Together

The most useful future architecture may contain several model classes at once.

Consider an autonomous system.

A perception model may identify objects and terrain.

A learned world model may predict likely physical consequences.

A language model may interpret instructions or uncertain text.

A formal model may define allowed actions, mission conditions, required facts, operational states, authority, and stopping boundaries.

learned perception
+
learned world prediction
+
language interpretation
+
formal operational model
→ controlled system behavior

The same principle applies to business automation.

An LLM may interpret a customer request.

A formal model may define the process.

A deterministic query may establish the current state.

A service may perform the permitted external action.

The architecture becomes stronger when each mechanism is assigned the function for which it is best suited.

Glages is intended to make the formal-model part of that architecture systematically producible.

The Model After the Model

The success of foundation models created an extraordinary new capability: machines can interpret accumulated human material with a breadth that traditional software could not approach.

That achievement may enable another step.

Instead of repeatedly asking a probabilistic model to reconstruct the same stable meaning at runtime, some of that meaning can be extracted, formalized, verified, and retained.

The output becomes another kind of model.

A model produced with the help of AI, but not reducible to the AI that produced it.

A model that can survive a change in LLM vendor.

A model that can be inspected without reading neural weights.

A model that can be specialized instead of retrained.

A model whose permitted behavior can be checked before execution.

A model that becomes more valuable as verified corrections accumulate.

This is the model class Glages is being developed to produce.

The future of AI may not belong to one universal model architecture.

It may belong to systems in which different kinds of models carry different kinds of knowledge.

Glages is a proposal for one of those kinds.

References

1. Meta AI. "V-JEPA: The next step toward advanced machine intelligence." 2024. https://ai.meta.com/blog/v-jepa-yann-lecun-ai-model-video-joint-embedding-predictive-architecture/
2. Meta AI. "V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning." 2025. https://ai.meta.com/research/publications/v-jepa-2-self-supervised-video-models-enable-understanding-prediction-and-planning/
3. Trooskens, G., et al. "Compiled AI: Deterministic Code Generation for LLM-Based Workflow Automation." arXiv:2604.05150, 2026. https://arxiv.org/abs/2604.05150
4. Cao, T., et al. "Kintsugi: Learning Policies by Repairing Executable Knowledge Bases." arXiv:2605.09487, 2026. https://arxiv.org/abs/2605.09487
5. Peer, D., and Stabinger, S. "ATA: A Neuro-Symbolic Approach to Implement Autonomous and Trustworthy Agents." arXiv:2510.16381, 2025. https://arxiv.org/abs/2510.16381
6. Liu, B., et al. "LLM+P: Empowering Large Language Models with Optimal Planning Proficiency." arXiv:2304.11477, 2023. https://arxiv.org/abs/2304.11477
7. Guan, L., Valmeekam, K., Sreedharan, S., and Kambhampati, S. "Leveraging Pre-trained Large Language Models to Construct and Utilize World Models for Model-based Task Planning." arXiv:2305.14909, 2023. https://arxiv.org/abs/2305.14909
8. Bayless, S., et al. "A Neurosymbolic Approach to Natural Language Formalization and Verification." arXiv:2511.09008, 2025. https://arxiv.org/abs/2511.09008
9. Palantir. "The Ontology system." https://palantir.com/docs/foundry/architecture-center/ontology-system/
10. Palantir. "Why create an Ontology?" https://palantir.com/docs/foundry/ontology/why-ontology/
11. Microsoft. "What Is Ontology (Preview)? - Microsoft Fabric." https://learn.microsoft.com/en-us/fabric/iq/ontology/overview
12. Microsoft. "What is Fabric IQ?" https://learn.microsoft.com/en-us/fabric/iq/overview
13. Khattab, O., et al. "DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines." arXiv:2310.03714, 2023. https://arxiv.org/abs/2310.03714
14. Calvanese, D., et al. "Agentic Business Process Management: A Research Manifesto." arXiv:2603.18916, 2026. https://arxiv.org/abs/2603.18916
15. Dumas, M., Milani, F., and Chapela-Campa, D. "Agentic Business Process Management Systems." arXiv:2601.18833, 2026. https://arxiv.org/abs/2601.18833
16. Azarijafari, M., Mich, L., and Missikoff, M. "A Formal Framework for Declarative Agentic AI in Business Process Analysis." arXiv:2606.15291, 2026. https://arxiv.org/abs/2606.15291
17. Sutton, R. S. "The Bitter Lesson." 2019. http://www.incompleteideas.net/IncIdeas/BitterLesson.html