What SimpleModeling Has Pursued

Created: 2026-07-27 Updated: 2026-07-27

SimpleModeling has developed methods for connecting models to executable software since before AI, using CML (Cozy Modeling Language), DSLs, Literate Models, Cozy, and Textus.

Meanwhile, constructing a Domain Model from knowledge still depended mainly on human work, even with support from glossaries, use cases, and Literate Models. AI is now making collaboration with domain experts and developers practical in this previously manual stage.

This article explains the continuity of SimpleModeling's direction and why AI moves the methodology into a new stage.

Article at a Glance

Part 2 at a glance: the realization path SimpleModeling has built and the knowledge-to-model transformation made practical by AI. summary en

Position in the Series

Part 1 explained that making the Domain Model a working abstraction with a path to implementation shifts human work from code to models and requires software development methodology to be reconstructed around modeling. This article makes that realization path concrete by distinguishing the roles of CML, Cozy, AI, and Textus.

Part 2 examines the path from Model to Executable Software that SimpleModeling developed before AI and the Knowledge-to-Domain-Model stage that AI is changing.

The Starting Point

SimpleModeling began by refusing to treat models as mere design documents.

Model
  ↓
Executable Software

When models are detached from implementation, they may be useful during design but diverge from the code as development proceeds. Reflecting model changes in implementation and bringing implementation results back into models both depend on people. Models consequently cease to be actively used.

SimpleModeling has pursued models as development representations connected to implementation and execution.

CML and DSLs

CML is a literate modeling language for describing SimpleModeling models. It expresses objects, types, relationships, constraints, behavior, and related concepts in a machine-processable structure.

A DSL expresses the concepts and operations of a specific domain using vocabulary suited to that domain. It preserves domain meaning in a form that can be interpreted and transformed.

CML and DSLs make a model an intermediate representation that can be transformed into programs, configuration, technical documentation, and other artifacts.

Literate Modeling

Formal model structure clarifies objects, types, relationships, constraints, and related elements. Natural language provides the reasons for structural choices, supporting business knowledge, and assumptions.

A Literate Model combines natural-language narrative and formal model structure in one document. Humans can read its intent and context, while tools and AI can process its document structure and model elements. This connects knowledge, explanation, models, and generated artifacts in one flow.

SimpleModeling has developed Literate Modeling since before AI as a method for connecting models to both human understanding and machine processing.

Realization with Cozy and Textus

Making a model executable requires a realization path that interprets the model, transforms it into required artifacts, and runs it.

Cozy processes CML and other DSLs, generating programs, configuration, documentation, and related artifacts to transform CML into executable software. AI fills application-specific implementation gaps that cannot be generated completely by transformation rules alone. Textus is the SimpleModeling execution platform that runs the resulting executable software.

Textus is designed to provide quality attributes such as Security, Observability, Performance, Resiliency, and Availability at the execution-platform level. Applications focus on their specific domain logic, while common execution qualities are centralized in the platform.

In this way, even before AI, SimpleModeling had been constructing a path from Model to Executable Software through CML, DSLs, Literate Models, Cozy, and Textus.

The Remaining Gap

Another transformation exists before the model.

Knowledge
  ↓
Domain Model

Knowledge here includes business terminology, rules, examples, requirements, constraints, and the rationale behind decisions. A Domain Model organizes this knowledge as a view of the problem domain for a development purpose.

A glossary clarifies the meaning and boundaries of terminology. Use cases evaluate model validity against business scenarios. Literate Models place knowledge and model structure in the same document. These techniques have supported the work of constructing a Domain Model from Knowledge.

However, people still performed nearly all of the transformation: selecting relevant knowledge, choosing a view, and organizing it into objects and constraints. Even as Model-to-Executable-Software automation progressed, the preceding stage remained largely manual.

What AI Makes Practical

AI can read both structured knowledge and natural language, helping organize terminology, find related knowledge, identify contradictions and omissions, and construct model candidates. This changes the Knowledge-to-Domain-Model transformation from human-only work into a collaborative process.

Domain experts, developers, and AI improve the Domain Model through collaboration. Domain experts assess business validity, developers examine structure, constraints, consistency, and feasibility, and AI supports knowledge organization and modeling. The three review results and feed findings back into the knowledge and model.

AI also complements Cozy's CML transformation. Cozy generates executable software from model transformation rules, and AI fills application-specific implementation details that those rules cannot express completely. AI’s role in the methodology is therefore collaboration in constructing models from knowledge and completion of implementation gaps remaining after Cozy's transformation.

BoK as the Bridge

This collaboration requires a shared knowledge foundation that domain experts, developers, and AI can all reference. In SimpleModeling, the BoK fills this role.

The BoK publishes knowledge to people as HTML on the Web and provides it to AI through MCP. Developers and AI can also use executable knowledge and functions as components. This enables discussion and model updates from the same knowledge foundation.

The BoK is a bridge that extends the knowledge-to-model connection established by Literate Modeling into collaboration with AI. Its internal mechanisms, including RDF, Embedding, RAG, and MCP, will be covered in the Knowledge Modeling article. Here the focus is its historical role in the methodology.

The Complete Path

Combining these developments produces the development path addressed by SimpleModeling.

Knowledge
  ↓  Domain Expert + Developer + AI
Domain Model
  ↓  Expressed as CML
CML
  ↓  Cozy Transformation + AI Completion
Executable Software
  ↓  Runs on Textus
Execution

Knowledge provides the basis for what should be built. The Domain Model represents the problem domain as a view suited to the development purpose and is expressed as CML. Cozy transforms CML into executable software, while AI fills implementation gaps that Cozy cannot transform completely. Textus runs that executable software.

In this path, findings from execution results, tests, and user evaluation return to use cases, the glossary, the BoK, and the Domain Model for iterative improvement.

Continuity and Change

Aspect What Remains What Changes

Goal

Connect models to executable software.

The path from Knowledge to execution can be treated as one collaborative process.

Model

Express models as CML and treat them as a central development representation.

AI participates in knowledge organization and completion of Cozy's transformation results.

Human Work

Determine purpose, meaning, responsibilities, and constraints.

Share part of knowledge organization and implementation with AI.

Realization

Cozy transforms CML into executable software, and Textus runs it.

AI completion of implementation gaps joins Cozy's transformation path.

SimpleModeling has continuously developed a path in which Cozy transforms CML into executable software and Textus runs it. AI makes the previously human-dominated Knowledge-to-Domain-Model stage collaborative and fills implementation gaps that Cozy cannot transform completely. Together, these elements form a practical development methodology from Knowledge to Executable Software.

Next

We have now established why methodology must be reconstructed and the historical direction pursued by SimpleModeling. The next article, "Modeling Technology System," explains the design decisions used to integrate existing software engineering techniques into the methodology.

References

Glossary

CML (Cozy Modeling Language)

CML (Cozy Modeling Language) is the SimpleModeling formal modeling language for describing the Executable Model portion of an Object Model that connects to program generation and execution.

Cozy

Cozy is the SimpleModeling toolchain that analyzes Models expressed in CML and other DSLs and transforms them into realization artifacts such as programs, configuration, and documentation.

Textus

Textus is the runtime foundation for operating software realized through SimpleModeling. It provides execution, operational, and integration mechanisms shared by applications.

SimpleModeling

SimpleModeling is a modeling-centered software development methodology and technology system for constructing a Domain Model from Knowledge, formalizing it in CML, realizing it as executable software through Cozy and AI, and running it on Textus.

Model

A Model is an abstraction that represents a subject according to a particular Purpose and Concern so that it can be understood, reasoned about, evaluated, or constructed. It is not the subject itself; it preserves the elements, relationships, and meanings required for its purpose.

DSL (Domain Specific Language)

A DSL (Domain-Specific Language) is a language designed for a particular domain, enabling direct and concise expression of the domain’s concepts and structures. Compared to general-purpose programming languages (GPLs), DSLs offer a higher level of abstraction tailored for domain-specific problem solving and automation.

Literate Model

Undefined

Dependency

In UML, a Dependency is a directed Relationship indicating that the specification or implementation of a client Model Element depends semantically or structurally on the definition of a supplier Model Element.

Glossary

A Glossary is a knowledge resource that manages the names, meanings, boundaries, synonyms, and identifiers of terms used in a subject domain. It provides a common foundation for participants to use the same terms with the same meanings.

Use Case

In UML, a Use Case is a Model Element that specifies a set of Actions performed by a subject to yield an observable result of value to an Actor or other stakeholder.

Software Development Methodology

A Software Development Methodology is a coherent system of models, model transformations, technologies, design principles, and decision rules used in software development. It defines what is modeled, how models are constructed, and how they are connected to executable software. In general usage, a Software Development Methodology may also include a Development Process. SimpleModeling separates the Methodology that defines models and model transformations from the Development Process that operates it in practical development.

State

In UML, a State models a situation during which an invariant condition holds. The current State of an Object may determine accepted Events and Operations, applicable Constraints, and possible next Transitions.

Object

An Object is an Instance classified by a Class or another Classifier and may have structure, State, and Behavior. It is treated as an individual that can be referred to separately from other Instances of the same Classifier.

Constraint

In UML, a Constraint is a condition or restriction expressed in natural language or a machine-readable language to declare part of the Semantics of one or more Model Elements. Its evaluation yields a Boolean value and has no side effects.

Behavior

In UML, Behavior is a specification of how its context Behaviored Classifier changes State over time. It may define possible executions, emergent Behavior, or a selected example of execution.

Type

Undefined

Operation

In UML, an Operation is a Behavioral Feature of a Classifier that specifies the name, type, Parameters, and Constraints for invoking associated Behavior. The Operation specifies an invocation contract, while a Method or another Behavior realizes it.

Literate Modeling

Undefined

Security

Security is the quality of protecting information and functions according to legitimate authority and preventing unauthorized disclosure, use, modification, destruction, or repudiation. It includes Concerns such as Confidentiality, Integrity, Authenticity, and Accountability.

Quality Attribute

A Quality Attribute is a characteristic that expresses the degree of quality with which software satisfies requirements in addition to performing its functions. Examples include Security, Performance, Availability, Reliability, Resilience, Observability, and Maintainability.

Performance

Performance is the quality by which a system satisfies timing requirements such as processing time, response time, Throughput, and capacity under specified conditions and resources.

View

A View is a representation that projects selected parts of a Model according to a particular Purpose and Concern so they can be understood, reasoned about, evaluated, or used. A View presents part of a Model and does not own meaning independently of the source Model.

BoK (Body of Knowledge)

At SimpleModeling, the core knowledge system for contextual sharing is called the BoK (Body of Knowledge). The goal of building a BoK is to enable knowledge sharing, education, AI support, automation, and decision-making assistance.

Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open protocol for connecting applications that use generative AI with external data sources and tools and for providing context and capabilities in a standardized form.

Component

A software construct that encapsulates well-defined responsibilities, contracts, and dependencies as a reusable and replaceable unit. In the logical model, it serves as an abstract structural unit; in the physical model, it corresponds to an implementation or deployment unit.

RDF

A W3C-standardized data model that represents information as subject–predicate–object triples.

Knowledge Modeling

Undefined

Embedding

An Embedding is a numerical-vector representation of text, terms, Model Elements, or related content that enables computation of semantic similarity. It is used for similarity search and candidate retrieval.

Retrieval-Augmented Generation (RAG)

A generation technique that supplements a language model’s internal (parametric) knowledge by retrieving relevant external information before generation. RAG systems first search knowledge sources such as databases or knowledge graphs and then use the retrieved context as input for text generation.

Test

A Test is an activity and specification that executes or evaluates a subject under stated conditions and compares observed results with expected results or Constraints to check conformance to requirements or contracts.

Aspect

An Aspect is a condition, property, or Concern examined across multiple Model Elements or behaviors. It centers on Quality Attributes and may include cross-cutting conditions that are not adequately expressed by a Quality Attribute alone.

Responsibility

A Responsibility is an obligation stating what an Object or Role must know, decide, perform, or protect. It assigns ownership of rules and Behavior, not merely structural information.

Realization

Undefined

Modeling Technology System

Undefined