OptiGuide+: An Interactive Recommender System for Virtual Things

Tahani Almanie

, Xu Han

Bhavana Posani

and Alexander Brodsky

Department of Computer Science, George Mason University, 4400 University Drive, Fairfax, U.S.A.

{talmanie, xhan21, bposani, brodsky}@gmu.edu

Keywords:

Interactive Recommender System, Multi-Objective, Pareto-Optimal, Decision Guidance, Virtual Things,

Smart Manufacturing, Optimization.

Abstract:

This paper is concerned with markets of Virtual Things, which are parameterized speciﬁcations of products or

services that can be realized and delivered on demand. Reported in this paper is the design and development

of OptiGuide+, an interactive recommender system designed to guide users in choosing and optimally instan-

tiating Virtual Things. OptiGuide+ enhances decision-making by dynamically integrating user preferences

with multi-objective optimization. It supports (1) real-time interactive utility extraction from user-selected

preferences on Pareto-optimal alternatives; (2) seamless integration of virtual things’ speciﬁcations; (3) cross-

platform web-based deployment capability; and (4) an intuitive user interface for visualizing trade-offs to

explore Pareto-optimal alternatives. OptiGuide+ is unique in its ability to leverage utility-driven decision

guidance methodology for markets of parameterized products and services and demonstrate it in real-world

applications.

1 INTRODUCTION

In this paper, we report on the design and devel-

opment of OptiGuide+: an interactive recommender

system to guide users in choosing and optimally in-

stantiating Virtual Things (VT’s). Virtual Things are

parameterized speciﬁcations of products, services, or

anything of value, associated with analytic models

that describe the consumer-interesting characteristics,

which can be instantiated and fulﬁlled on demand

(Han and Brodsky, 2022).

To illustrate the concept, consider an example of

a virtual bike. Unlike a physical, off-the-shelf prod-

uct, a virtual bike is deﬁned by a parametric design

speciﬁcation, against which it can be manufactured

by a vendor. For a virtual bike, a set of parameters

may involve frame material, bike geometry, wheels’

size, and drivetrain characteristics. VT is also asso-

ciated with a set of constraints on the parameters and

user requirements, such as tire size for riding on snow

and weight limits, as well as objectives, i.e., key per-

formance indicators (KPIs) for the bike, such as total

weight, cost, speed, and feasibility for speciﬁc condi-

tions.

https://orcid.org/0000-0002-6017-4841

https://orcid.org/0000-0002-3347-3627

https://orcid.org/0009-0003-4876-3787

https://orcid.org/0000-0002-0312-2105

Consumers face the challenge of selecting the

most suitable instantiation of a VT, e.g., a bike capa-

ble of riding on snow and optimized according to con-

sumer preferences that balance objectives like cost,

performance, and environmental impact. This prob-

lem involves extracting a user utility function from

(possibly competing) user’s objectives and using the

extracted utility to recommend an optimal instantia-

tion of the VT.

When repositories (or markets) of VTs are avail-

able to consumers, the problem they face is how to

choose a particular (optimal) instantiation of one VT

out of the set of VTs in the repository. E.g., an in-

stantiation of a virtual bike that can ride on snow, or

a procurement package. We are interested in optimal

VT instances, in terms of the user’s utility function,

which can be described in terms of a number of KPIs

or objectives, e.g., cost, quality and carbon emissions.

Thus, the problem involves two interrelated tasks:

how to extract a user utility as a function of KPIs

through a short interactive session with the user; and

how to choose a speciﬁc instantiation of a Virtual

Thing that optimizes the utility. OptiGuide+ is de-

signed to address this problem.

There has been prior work on decision guidance

systems for Markets of Virtual Things, including (Han

and Brodsky, 2022; Han and Brodsky, 2023). This

is based on the work on Decision Guidance Systems

642

Almanie, T., Han, X., Posani, B. and Brodsky, A.

OptiGuide+: An Interactive Recommender System for Virtual Things.

DOI: 10.5220/0013470000003929

In Proceedings of the 27th International Conference on Enterprise Information Systems (ICEIS 2025) - Volume 1, pages 642-653

ISBN: 978-989-758-749-8; ISSN: 2184-4992

(Brodsky et al., 2016; Nachawati et al., 2017), which

are a specialized class of decision support systems

that elicit human knowledge and guide the users to

make the best possible decisions. Paired with para-

metric design for novel products (Gingold et al., 2009;

Yu et al., 2011; LaToza et al., 2013; Shin et al.,

2017; Liu et al., 2019), decision guidance systems

are broadly applied to smart manufacturing (Menasc

et al., 2015), including product analysis, manufactur-

ing process and procedure optimization (Egge et al.,

2013; Shao et al., 2017; Shao et al., 2018; Brodsky

et al., 2019; Li et al., 2020), and manufacturing en-

ergy and waste reduction (Shao et al., 2011; Grifﬁths

et al., 2016).

The concept of Virtual Things (VTs) has been pro-

posed and explored in (Han and Brodsky, 2024) as

part of the DG-ViTh system, which aims to facilitate

optimization and decision-making for parameterized

speciﬁcations of manufactured products and services.

However, DG-ViTh lacks interactive mechanisms for

dynamic utility extraction, relying instead on prede-

ﬁned utility functions, which limits its adaptability to

consumer-driven markets.

Extensive work has also been done on iterative

recommender systems based on multi-objective op-

timization. CAPORS introduced a composite recom-

mendation methodology, emphasizing Pareto-optimal

trade-offs for arbitrary criteria (Jeffries and Brod-

sky, 2017). CAPORS-IUX extended this by integrat-

ing continuous user interaction to reﬁne recommen-

dations iteratively, capturing individual utilities (Jef-

fries and Brodsky, 2018). However, real-time opti-

mization posed challenges, particularly in complex

domains, and both systems lacked robust domain in-

dependence.

OptiGuide further advanced the ﬁeld by introduc-

ing preprocessing algorithms to improve efﬁciency

and incorporating a domain-independent architec-

ture. It facilitates user utility extraction by cap-

turing user interactions, providing real time feed-

back and optimization through a customizable inter-

face (Almanie and Brodsky, 2024). Nevertheless,

OptiGuide’s framework was not designed to han-

dle VT-speciﬁc artifacts, such as parameters or met-

rics schemas, preventing its application to dynamic

Virtual Things Markets. Furthermore, its deploy-

ment was limited to standalone systems, restricting

its broader applicability, and it did not implement the

best so far and improvement functionalities.

Bridging these gaps is the focus of this paper.

More speciﬁcally, we have developed OptiGuide+, an

interactive recommender system that guides users in

choosing and optimally instantiating Virtual Things.

OptiGuide+ combines the strengths of DG-ViTh and

OptiGuide to overcome their respective limitations.

The core contribution of this paper is the design and

development of OptiGuide+. This required a number

of speciﬁc technical contributions as follows:

• Real-time Interactive Utility Extraction: OptiGu-

ide+ leverages OptiGuide’s iterative user interac-

tion capabilities, enabling users to dynamically

deﬁne and adjust utility functions based on spe-

ciﬁc objectives and preferences within the VT

framework.

• Seamless VT Integration: OptiGuide+ incorpo-

rates VT-speciﬁc artifacts, including parameter-

ized speciﬁcations and analytic models, enabling

it to operate effectively within the Market of Vir-

tual Things.

• Web Deployability: The system enhances Op-

tiGuide’s deployment capabilities by making it

web-accessible, ensuring broader accessibility

and scalability across diverse domains and plat-

forms.

• Enhanced User Interface: The system provides a

user-friendly interface for visualizing trade-offs,

exploring Pareto-optimal solutions, and ﬁnalizing

decisions, ensuring an intuitive and satisfying user

experience.

The integration of these features makes OptiGu-

ide+ a unique utility-driven interactive decision guid-

ance system capable of addressing the dual challenge

of utility extraction and optimal instantiation of Vir-

tual Things.

The rest of this paper details the design, imple-

mentation, and demonstration of OptiGuide+, high-

lighting its potential to transform decision-making in

markets of parameterized products and services. Sec-

tion 2 reviews the idea of Virtual Things as well as

the high-level architecture and functionalities of DG-

ViTh. Section 3 provides an overview of OptiGuide+

and demonstrates its use through a Virtual Things ex-

ample. Section 4 covers a detailed functional and

architectural design and implementation of OptiGu-

ide+. We then demonstrate in Section 5 how OptiGu-

ide+ works to render optimal VT in a web-deployed

environment and conclude with future research direc-

tions in Section 6.

2 Virtual Things: ARTIFACTS AND

FUNCTIONS

In this section, we overview the concept of Virtual

Things (VT’s) artifacts and functions more formally

OptiGuide+: An Interactive Recommender System for Virtual Things

643

Figure 1: DG-ViTh Functionality and User Roles (Han and Brodsky, 2024).

and describe the DG-ViTh system. We borrow the de-

scription from (Han and Brodsky, 2024).

DG-ViTh (see Figure 1) connects multiple user

roles to the functionalities they desire respectively,

and acts as the interface and decision guidance en-

gine for the Market of Virtual Things. Architecturally,

DG-ViTh involves the reusable, extendable and mod-

ular knowledge base of specs and analytic models in

the VT repository, the conventional e-commerce mar-

ket functions, and the specialized VT functions built

on DGAL (Brodsky and Luo, 2015) which together

power up the Market of Virtual Things.

The entrepreneur with innovative ideas can nav-

igate the transition from conceptual ideation, to vir-

tual design and production, and ultimately to con-

crete market presence, informed and empowered by

the decision guidance system of DG-ViTh. During the

same process, in the whole ecosystem, the capability

providers, designers, collaborators, and investors all

get accurate, genuine, and timely market information

on the reception of the innovative product, so they

can use the valuable feedback information to evalu-

ate and further their work and investment. By sup-

porting the creation, searching, and optimization of

Virtual Things, DG-ViTh streamlines the product de-

velopment workﬂow and enhances design precision

according to user preferences. Its capabilities to con-

struct optimal Virtual Things and facilitate informa-

tion ﬂows in the cloud environment accelerate the re-

alization of innovative ideas.

2.1 Key Virtual Things Artifacts

Key artifacts for Virtual Things include VT specs, re-

quirements specs, utility, metrics schemas, and pa-

rameters schemas. These artifacts are stored in the

repository and used by the DG-ViTh system.

2.1.1 vtSpec

The core Virtual Thing artifact is a VT design spec

(vtSpec). Semantically, a vtSpec is an analytic model

AM, which is a (mathematical) function

AM : MI → MO

where

• MI is the AM’s domain of all possible param-

eters’ inputs, representing all possible instantia-

tions of ﬁxed and controllable parameters relevant

to model computation.

• MO is the AM’s co-domain of all possible model

outputs representing computed user-facing met-

rics and constraints, i.e., all the information that

the user needs to judge a VT instance.

Syntactically, MI is represented using the notion

of the domain associated with a parameters schema

(parametersSchema), deﬁned formally in (Han and

Brodsky, 2024). A parametersSchema is a JSON

data structure corresponding to AM’s input, where all

ﬁxed and decision parameters are annotated to indi-

cate their type (e.g., reals, int) as well as optional

lower and upper bounds.

Informally, dom(parametersSchema) is the set of

all JSON structures resulting from replacing parame-

ters’ annotations with values within the given bounds

from a corresponding domain. Similarly, MO is rep-

resented using the notion of the domain associated

with a metricsSchema, also formally deﬁned in (Han

and Brodsky, 2024).

The model AM is represented syntactically as a

Python function that gets, as input, a JSON structure

from MI and produces, as output, a JSON structure

from MO. An example of a syntactic representation

of a vtSpec including its parametersSchema, metric-

sSchema and analytic model AM, is shown in Figure

ICEIS 2025 - 27th International Conference on Enterprise Information Systems

644

2.1.2 vtReqSpec

VT requirements speciﬁcation (vtReqSpec) is used by

users to specify requirements to search for vtSpecs or

ﬁnd optimal instances of vtSpecs. The semantics of

vtReqSpec is given by two (mathematical) functions

ob js : MO → O and constraints : MO → {T, F}

where

• MO is the domain of metricsSchema as previously

described (which is also used as a co-domain of

vtSpecs analytic model).

• O is the objs’s co-domain of all possible objec-

tives/KPIs value instantiations according to the

objectives schema (objsSchema).

While a metrics structure in MO may involve numer-

ous metrics and characteristics of a VT instance, a

structure in O holds values for just a (small num-

ber) of objectives (also called KPIs), e.g., cost, carbon

emission, and manufacturing time. The function objs

maps the more complex metrics structure in MO into

the values for the objectives in O. The Boolean func-

tion constraints is used to indicate whether a metrics’

instance m ∈ MO is feasible (constraints(m) = T ) or

not (constraints(m) = F).

Similar to MO = dom(metricsSchema), the objs

co-domain O = dom(ob jsSchema) is deﬁned for-

mally in (Han and Brodsky, 2024). Informally, ob-

jsSchema is a JSON structure that contains the names

of objectives (e.g., cost, carbon emission, manufac-

turing time), with their values annotated to indicate

their type (e.g., real, int) and optional lower and upper

bounds. And dom(ob jsSchema) is the set of all JSON

structures resulting from replacing objectives’ anno-

tations in objsSchema with values within the given

bounds from a corresponding domain. An example

of objsSchema appears in Figure 7 under “objectives”

and “schema”.

Syntactically, vtReqSpec is described as a JSON

structure that contains or refers to metricsSchema, ob-

jsSchema, and Python functions objs and constraints

to deﬁne the corresponding mathematical functions.

It is required and assumed that the Python function

objs produces an output in O for any input in MO,

and that the Python function constraints produces a

Boolean value T or F for any input in MO. An exam-

ple of vtReqSpec artifact appears in Figure 7.

2.1.3 Utility

If a decision maker would like to ﬁnd an optimal in-

stantiation of a vtSpec in terms of multiple objectives,

she needs to specify another artifact - utility which de-

scribes a linear combination of objectives in the cor-

responding vtReqSpec. The semantics of utility (as-

sociated with a vtReqSpec and its objsSchema) is the

(mathematical) function

U : O → R

where O is the domain of objsSchema and R is the

set of real numbers. We restrict ourselves to utility

functions being linear in objectives. Syntactically, a

utility artifact includes a min/max ﬂag to indicate if a

decision maker would like to minimize or maximize

it; and the weights for each of the objectives in the

associated vtReqSpec for the computation of a linear

combination of the objectives.

2.2 DG-ViTh Functions Syntax and

Formal Semantics

DG-ViTh functions are a set of functions that spe-

cialize in creating, searching, modifying, optimizing,

comparing and analyzing the Virtual Things. We have

deﬁned several key functions with their syntactic sig-

natures and semantics.

2.2.1 vtOptimalInstance(vtSpec, vtReqSpec,

Utility)

The semantics of the vtOptimalInstance function is to

ﬁnd a VT instance that matches the vtReqSpec and

is optimal in terms of the user’s utility. We have the

mathematical functions

AM : MI → MO

constraints : MO → {T, F}

ob js : MO → O

U : O → R

corresponding to the semantics of vtSpec, reqSpec

and utility in the input. Consider

ARGMAX = argmax

mi∈MI

U(objs(AM(mi)))

s.t. constraints(AM(mi)) ∧

vtMetricBounds(AM(mi)) ∧

reqMetricBounds(AM(mi)) ∧

objsBounds(objs(AM(mi)))

where

• vtMetricBounds is the bound constraints of the

vtSpec’s metricsSchema

• reqMetricBounds is the bound constraints of the

vtReqSpec’s metricsSchema

• ob jsBounds is the bound constraints of the

vtReqSpec’s ob jsSchema

OptiGuide+: An Interactive Recommender System for Virtual Things

645

To complete the semantics of vtOptimalInstance, the

output is as follows:

1. If ARGMAX =

0, return INFEASIBLE

2. Else, if (∀mi ∈ MI)(∃mi

′

∈ MI)

s.t. U (ob js(AM(mi

′

))) > U (ob js(AM(mi))),

return UNBOUNDED

3. Else return i ∈ ARGMAX

Note that ARGMAX may have more than one ele-

ment, so in the third case any element i ∈ ARGMAX,

which corresponds to an optimal solution, can be re-

turned.

2.2.2 paretoOptimalDB(vtSpec, vtReqSpec)

This function returns a set of all valid vtSpec

instances that are Pareto-optimal with respect to

vtReqSpec. More formally, consider a vtSpec

instance i ∈ vtValidInstances, where the set

vtValidInstances is deﬁned by the function

vtValidInstance that returns all valid instances

of the vtSpec. Let o

(i), . . . , o

(i) denote the val-

ues for each objective’s name in ob jsSchema of

vtReqSpec, as computed by ob js(i). We say that i

is Pareto-optimal w.r.t. vtReqSpec if the following

condition is satisﬁed: there does not exist a valid

instance i

′

∈ vtValidInstances such that

• All objective values o

′

), . . . , o

′

) are at least

as good as o

(i), . . . , o

(i), and

• At least one objective value o

′

) for 1 ≤ k ≤ n is

strictly better than o

(i)

Note that strictly better means “<” for minimization

problems and “>” for maximization problems. Ac-

cording to the theoretical semantics above, the set de-

ﬁned by the paretoOptimalDB function may be (un-

countably) inﬁnite. In practical implementation, this

function may return a discretized representation of the

Pareto front. Also note that the function of paretoOp-

timalDB easily generalizes to input of a set of vtSpecs,

from a single vtSpec.

2.3 DG-ViTh Service Architecture

DG-ViTh supports effective and efﬁcient interactions

between the users and the Market of Virtual Things

with a customizable, modular, scalable and user-

centric service architecture shown in Figure 2. The

users may take upon either the role of VT consumers

or VT composers to interact with the system through

a graphical user interface (GUI) where available ser-

vice options are presented. Each service is backed by

the corresponding DG-ViTh functions implemented in

DGAL.

The DG-ViTh functions are managed by the de-

cision guidance management system (DGMS) which

serves as a platform and connects technical users,

such as developers, data analysts, and administra-

tors (Brodsky and Wang, 2008). The DGMS gov-

erns the access to a library of reusable, extensible, and

modular analytic models that associate with the Vir-

tual Things. Through the virtual service network and

virtual product assembly, various data artifacts are

turned into new Virtual Things that match the user’s

innovative ideas. The Virtual Things are described

and represented by their dedicated performance ana-

lytic models which can be crafted and customized by

professional mathematical programmers and model

builders, or be machine-generated by the DGMS. In

addition, the DGMS offers a comprehensive toolkit

for tasks like database management, data mining, sim-

ulation, optimization, and more.

3 OVERVIEW OF OPTIGUIDE+

OptiGuide+ is an interactive recommender system

that builds upon the foundational OptiGuide frame-

work. This earlier system is domain-independent and

employs multi-objective optimization to guide users

in extracting their utility and ﬁnding Pareto-optimal

recommendations.

OptiGuide+ expands upon this foundation by in-

tegrating the VT framework from DG-ViTh, enabling

real-time interactive utility extraction and seamless

integration of VT-speciﬁc artifacts. This enhance-

ment allows it to operate effectively within the Market

of Virtual Things, engaging users to reﬁne their pref-

erences iteratively and ensuring personalized utility-

driven decision-making. Moreover, OptiGuide+ en-

hances accessibility and scalability by being web-

deployable, which broadens its applicability across

various domains and platforms. It also enhances the

user interface by incorporating more functionalities,

making it more intuitive for visualizing trade-offs and

exploring Pareto-optimal solutions, thereby enhanc-

ing the overall user experience.

We illustrate the methodology of the OptiGuide+

system with an example involving a procurement

package from two virtual supply aggregators. Con-

sider a procurement package that includes items like

tables, chairs, and cabinets, each with a speciﬁc de-

mand. In our repository (or market) of Virtual Things,

there are two supply aggregators: Supply Aggregator

1, which includes suppliers 1 and 2, and Supply Ag-

gregator 2, which includes suppliers 3 and 4, each of-

fering different speciﬁcations. A recommendation is

an optimal instance of one of the Virtual Things. This

ICEIS 2025 - 27th International Conference on Enterprise Information Systems

646

Figure 2: DG-ViTh Service Architecture (Han and Brodsky, 2024).

recommendation comprises a set of orders, each of

which includes item quantities to be purchased from

a speciﬁc supplier. These orders must meet demand

and availability constraints and optimize multiple ob-

jectives, including cost, carbon emissions (CO2), and

manufacturing time (manufTime).

The challenge for users is to select the most suit-

able instantiation of a VT that effectively balances

these objectives. This process involves extracting a

user utility function from the competing objectives

and determining the optimal instantiation of the VT.

OptiGuide+ aims to learn the user’s utility through

user-system interactions and Pareto-optimal trade-

offs between objectives to generate optimal recom-

mendations with the highest predicted utility for the

user.

To initialize the OptiGuide+ recommender sys-

tem for the given example, users must provide a set

of domain-speciﬁc artifacts, including the analytic

model AM, parameters schema, metrics schema, vt-

Spec, vtReqSpec, and speciﬁed conﬁguration settings.

The analytic model, as depicted in Figure 3, cal-

culates each objective (cost, CO2, and manufTime)

based on the parameters and control variables of the

input data. It also deﬁnes feasibility constraints to en-

sure non-negative quantities and to prevent exceeding

suppliers’ availability limits.

The parameters schema speciﬁes the input param-

eters for the analytic model. Some of these parame-

ters are ﬁxed, while others are control variables, an-

Figure 3: Analytic Model for Virtual Supply Aggregators.

notated with DGAL for optimal decision-making. In

this example, the Parameters Schema includes the

purchase information variables. For each pair of sup-

pliers and items, the purchase information covers the

price per unit, carbon emissions per unit, manufac-

turing time per unit, and available items, along with

the control variable “quantities”. Figure 4 depicts the

Parameters Schema for Supply Aggregator 1.

The metrics schema captures all metrics related to

OptiGuide+: An Interactive Recommender System for Virtual Things

647

Figure 4: Parameters Schema for VT1:Supply Aggregator1.

the user, including cost, CO2 emissions, manufactur-

ing time, combined supply of items (demand), and the

satisfaction of constraints for this example, as shown

in Figure 5.

Figure 5: Metrics Schema for Virtual Supply Aggregators.

The vtSpec for each virtual supply aggregator

speciﬁes the collection of the analytic model, param-

eters schema, and metrics schema of a VT, as shown

in Figure 6.

The vtReqSpec artifact captures key information

about the objectives and constraints on the metrics. It

Figure 6: vtSpec for VT1: Supply Aggregator1.

includes an objectives schema that identiﬁes the ob-

jectives, their data types, whether each objective is a

minimization or maximization metric, and the lower

and upper bounds for each objective. Figure 7 illus-

trates the vtReqSpec for the virtual supply aggregators

example.

Figure 7: vtReqSpec for Virtual Supply Aggregators.

Finally, the conﬁguration settings for OptiGu-

ide+ specify the required artifacts, including vtRe-

qSpec and vtSpecs. The vtSpecs structure contains a

list of all relevant vtSpecs for the example under study.

Additionally, the settings deﬁne the default objective

(e.g., cost) for the user to consider, along with other

technical parameters necessary for the system’s oper-

ation, as shown in Figure 8.

Figure 8: Conﬁguration Settings for Supply Aggregators.

ICEIS 2025 - 27th International Conference on Enterprise Information Systems

648

3.1 System Demonstration

The OptiGuide+ interface is designed to provide a

clear and intuitive layout for analyzing trade-offs and

optimizing recommendations among multiple objec-

tives. It facilitates the visual exploration and selec-

tion of optimal solutions from a Pareto front, guiding

users in choosing and optimally instantiating Virtual

Things. The interface, as illustrated in Figure 9, con-

sists of the following key sections:

• Pareto Front Graph: The upper-left section of

the interface displays a scatter plot representing a

Pareto front. Each point on the graph represents

a solution associated with a speciﬁc Virtual Thing

(e.g., supply aggregator1 or supply aggregator2),

showing the current trade-off between utility and

another objective (e.g., cost). A toolbar with icons

is provided at the bottom of the graph for quick ac-

cess to additional display options, such as zoom-

ing, exporting data, and resetting views.

• Weights of Current Utility: This section dis-

plays the current weights assigned to each ob-

jective, indicating their relative importance in

decision-making. These weights inﬂuence the

calculation of the overall utility.

• Pareto Front Table: The upper-right section of

the interface features a sortable, interactive ta-

ble displaying current trade-off recommendations.

Each recommendation in the table corresponds to

a point on the Pareto front and includes computed

objectives and current utility. A “Details” option

offers deeper insight into each solution. Addition-

ally, actionable options allow users to mark a so-

lution as “Best” or remove it from the table.

• Best So Far Section: The bottom panel of the

interface is reserved for recording and display-

ing the best solutions identiﬁed so far, facilitating

comparative analysis and ﬁnal decision-making.

Initially, it is blank but will update dynamically.

3.1.1 User-System Interactions

Initially, as shown in Figure 9, users are presented

with a graph that plots different solutions on a Pareto-

optimal curve, where each alternative optimizes one

objective at the expense of others. The current util-

ity is at ﬁrst calculated with equal weights assigned

to each objective. The default objective, represented

on the y-axis of the graph, is determined by the con-

ﬁguration settings, shown in Figure 8, which specify

“cost” for this example. The recommendation with

the highest utility value is displayed in the Pareto

Front Table.

The points on the graph are color-coded for dis-

tinction, with blue indicating selectable options and

red highlighting actively selected points for further

analysis, as illustrated in Figure 10. Upon selecting

a point on the graph, the system automatically adds

the points and displays its information in the Pareto

Front Table. A sorting feature above the table allows

users to organize solutions based on selected criteria

such as utility or cost. Clicking on “Details” opens a

hierarchical view of the solution, displaying speciﬁc

data such as the quantities of items to be purchased

from designated suppliers within a supply aggregator.

For instance, the solution shown in Figure 10 involves

suppliers 3 and 4, associated with supply aggregator2.

When the user selects the third recommendation

(Rec 3) as the best choice, the system updates by

adding it to the “Best So Far” section. Concurrently,

the system recalculates the current utility based on the

objective weights of the selected recommendation and

updates the Pareto Front Graph and Table to reﬂect the

updated utility.

The “Best So Far” section displays a graph of nor-

malized utility and objectives for each best solution,

which facilitates comparison, alongside a detailed in-

formation table for that solution. Additionally, for

each best solution in this section, the user has three

actionable options: “Improve” to generate a new set

of recommendations by optimizing a selected objec-

tive, “Remove” to delete the solution from the list, or

“Accept” to ﬁnalize it as the optimal recommendation.

For example, if the user wants to improve the

“Best 1” recommendation based on manufacturing

time, they select the “manufTime” objective from the

table and mark the “Improve” option. Consequently,

a new set of recommendations is plotted along the

Pareto curve where the y-axis of the Pareto Graph

becomes “manufTime”, and the x-axis represents the

last updated utility. The user can continue reﬁning

through this iterative process, as depicted in Figure

11, until deciding to ﬁnalize their choice by selecting

the “Accept” option for the optimal recommendation.

Figure 12 displays the accepted optimal recom-

mendation and its detailed solution, which involves

orders from suppliers 1 and 2, both associated with a

speciﬁc VT (supply aggregator 1).

4 OPTIGUIDE+ ARCHITECTURE

AND IMPLEMENTATION

In the development of OptiGuide+, we utilize the

foundational architecture of the original OptiGuide,

shown in Figure 13. This architecture comprises two

primary components: the Recommendation Engine,

OptiGuide+: An Interactive Recommender System for Virtual Things

649

Figure 9: OptiGuide+ Interface Displaying the Initial Pareto Front Visualization.

Figure 10: Adding Data Points to the Pareto Front Table and Displaying Solution Details of a Selected Point.

Figure 11: OptiGuide+ Interface Demonstrating Iterative Improvement and Selection of the Best Solutions.

which handles the preprocessing phase, and the Rec-

ommendation User Interface, which implements the

runtime phase (Almanie and Brodsky, 2024).

The Recommendation Engine requires initializa-

tion with domain-speciﬁc artifacts that include an an-

alytic model, parameters schema, metrics schema, vt-

Spec, vtReqSpec, and conﬁguration settings. Once

initialized, it integrates with the DGMS, which uses

ICEIS 2025 - 27th International Conference on Enterprise Information Systems

650

Figure 12: OptiGuide+ Interface Showing the Accepted Optimal Recommendation and its Solution Details.

Figure 13: OptiGuide+ Architecture (Almanie and Brodsky, 2024).

DGAL to generate domain-speciﬁc recommendations

and compute their objectives based on this initial

structure. The goal of the preprocessing phase is to

create a database for the Pareto front of the recom-

mendation space. This database includes estimated

user utility for each Pareto-optimal alternative, which

will then be utilized during the runtime phase. The

preprocessing phase involves four steps:

1. Weights Generation: This step generates a list of

weight combinations, where each weight is asso-

ciated with an objective. These weights contribute

to generating Pareto-optimal solutions during op-

timization.

2. Utility Computation: The utility function nor-

malizes the objectives on a scale from zero to one,

where zero represents the worst value and one rep-

resents the best. It then computes the weighted

sum of these normalized objectives using the gen-

erated list of weights.

3. Utility Optimizations: This step employs the

paretoOptimalDB function to identify all vtSpec

OptiGuide+: An Interactive Recommender System for Virtual Things

651

instances that are Pareto-optimal with respect to

vtReqSpec. It iterates over the generated list of

weights and uses the vtOptimalInstance function

to ﬁnd a VT instance that matches the vtReqSpec

and optimizes the user’s utility, resulting in an

“initial DB” JSON ﬁle containing all feasible rec-

ommendations for the given problem.

4. Initial DB Uniﬁcation: This step merges rec-

ommendations that share similar or identical ob-

jective values but differ in weights, utilizing Eu-

clidean distance and K-Medoids clustering. This

process reduces redundancy, resulting in a “Pareto

DB” JSON ﬁle containing only representative,

non-dominated solutions.

The runtime phase is designed to facilitate user

interaction and learning of an individual’s utility to

eventually identify their optimal recommendation.

This phase includes three components:

• Pareto Front Preparation: This component pre-

pares the Pareto front data from “Pareto DB” en-

tries based on the current weights and the objec-

tive designated for the y-axis. It computes the cur-

rent utility, represented on the x-axis, for each en-

try according to these weights.

• UI Generation: This component provides the

user with a visual representation of Pareto-

optimal solutions.

• Handling UI Interaction: It handles all user in-

teractions within the interface. For example, when

a user selects a point as “Best” in the table, it re-

trieves the weights of the corresponding point and

updates the GUI to reﬂect the new utility.

5 OPTIGUIDE+

CROSS-PLATFORM

DEPLOYMENT

METHODOLOGY

The deployment of OptiGuide+ was designed to

leverage JupyterLab as the primary platform, cap-

italizing on its robust support for integrating com-

putational workﬂows with a graphical user inter-

face (GUI). Users will be able to access the project

repository that houses the relevant artifacts and in-

voke function calls from the GUI. This process en-

sures an accessible, efﬁcient, and reproducible de-

ployment mechanism, aligning with modern compu-

tational standards. The speciﬁc steps are as follows:

1. Platform Preparation: JupyterLab was selected

as the ideal platform for hosting OptiGuide+ due

to its browser-based interface, which ensures plat-

form independence and minimizes setup com-

plexity.

2. Deployment Initialization: The deployment pro-

cess begins with launching JupyterLab from the

project directory. This step grants users access

to a uniﬁed workspace, allowing them to inter-

act with all necessary components of OptiGuide+,

including ﬁle management, script execution, and

application interfaces.

3. Data Preprocessing: Within JupyterLab, the pre-

processing module (mainPreprocessing.py) is ex-

ecuted. This module transforms the input arti-

facts and pre-computes the data in the underlying

Pareto optimal database in preparation for subse-

quent interactions, ensuring optimal performance

of the GUI.

4. Interface Activation: After preprocessing, the

graphical user interface is initialized by execut-

ing the script (optiguideUI.py). This launches the

OptiGuide+ interface in a new browser tab, where

users can engage with its features and explore its

capabilities in real-time.

By utilizing JupyterLab, this deployment method-

ology features cross-platform reproducibility, scala-

bility, and user-centric design. The simpliﬁed setup

and intuitive interface reduce barriers to entry, foster-

ing broader adoption among diverse user groups.

6 CONCLUSIONS

OptiGuide+ has advanced the ﬁeld of interactive

decision guidance systems by speciﬁcally address-

ing the needs of the Virtual Things (VT) market.

The system leverages multi-objective optimization

techniques and real-time user interaction to generate

Pareto-optimal recommendations, ensuring that each

decision maximizes the user’s utility while adhering

to practical constraints.

Many interesting research questions remain open.

They include (1) the development of more efﬁcient

algorithms for Pareto front computation;

(2) exploring new paradigms for utility extraction;

and (3) improvements to the user interface with an

emphasis on integrating advanced visualization tools.

These enhancements will aid users in more effectively

comparing the “best so far” options, incorporating

domain-speciﬁc visualizations such as maps to pro-

vide deeper insights into the data.

ICEIS 2025 - 27th International Conference on Enterprise Information Systems

652

REFERENCES

Almanie, T. and Brodsky, A. (2024). Optiguide: An efﬁ-

cient domain-independent package recommender sys-

tem based on multi-objective optimization and user

decision guidance. In Proceedings of the 57th Hawaii

International Conference on System Sciences, page

1528–1535.

Brodsky, A., Krishnamoorthy, M., Bernstein, W. Z., and

Nachawati, M. O. (2016). A system and architecture

for reusable abstractions of manufacturing processes.

In 2016 IEEE International Conference on Big Data

(Big Data), pages 2004–2013.

Brodsky, A. and Luo, J. (2015). Decision guidance ana-

lytics language (DGAL) - toward reusable knowledge

base centric modeling. In ICEIS 2015 - Proceedings

of the 17th International Conference on Enterprise In-

formation Systems, Volume 1, Barcelona, Spain, 27-30

April, 2015, pages 67–78. SciTePress.

Brodsky, A., Nachawati, M. O., Krishnamoorthy, M., Bern-

stein, W. Z., and Menasc

e, D. A. (2019). Factory op-

tima: A web-based system for composition and anal-

ysis of manufacturing service networks based on a

reusable model repository. International Journal of

Computer Integrated Manufacturing, 32(3):206–224.

Brodsky, A. and Wang, X. S. (2008). Decision-guidance

management systems (dgms): Seamless integration of

data acquisition, learning, prediction and optimiza-

tion. In Proceedings of the 41st Annual Hawaii In-

ternational Conference on System Sciences (HICSS

2008), pages 71–71.

Egge, N. E., Brodsky, A., and Griva, I. (2013). An efﬁ-

cient preprocessing algorithm to speed-up multistage

production decision optimization problems. In 46th

Hawaii International Conference on System Sciences,

HICSS 2013, Wailea, HI, USA, January 7-10, 2013,

pages 1124–1133. IEEE Computer Society.

Gingold, Y. I., Igarashi, T., and Zorin, D. (2009). Struc-

tured annotations for 2d-to-3d modeling. ACM Trans.

Graph., 28(5):148.

Grifﬁths, C., Howarth, J., Almeida-Rowbotham, G. D.,

Rees, A., and Kerton, R. (2016). A design of exper-

iments approach for the optimisation of energy and

waste during the production of parts manufactured by

3d printing. Journal of Cleaner Production, 139:74–

85.

Han, X. and Brodsky, A. (2022). Toward cloud manufac-

turing: A decision guidance framework for markets of

virtual things. In ICEIS (1), pages 406–417.

Han, X. and Brodsky, A. (2023). Optivith: A decision guid-

ance framework and system for design, analysis and

optimization of cloud-manufactured virtual things. In

Filipe, J.,

Smiałek, M., Brodsky, A., and Hammoudi,

S., editors, Enterprise Information Systems, pages

175–197, Cham. Springer Nature Switzerland.

Han, X. and Brodsky, A. (2024). Dg-vith: A decision guid-

ance system for repositories of virtual things. Journal

of Decision Systems, 0(0):1–19.

Jeffries, W. and Brodsky, A. (2017). Composite alterna-

tive pareto optimal recommender system (capors). In

Proceedings of the 19th International Conference on

Enterprise Information Systems - Volume 1: ICEIS,,

pages 496–503. INSTICC, SciTePress.

Jeffries, W. and Brodsky, A. (2018). Composite alterna-

tive pareto optimal recommendation system with indi-

vidual utility extraction (capors-iux). In International

Conference on Enterprise Information Systems.

LaToza, T. D., Shabani, E., and van der Hoek, A. (2013).

A study of architectural decision practices. In 6th

International Workshop on Cooperative and Human

Aspects of Software Engineering, CHASE 2013, San

Francisco, CA, USA, May 25, 2013, pages 77–80.

IEEE Computer Society.

Li, H., Yang, J., Chen, G., Liu, X., yun Zhang, Z., jun Li,

G., and hui Liu, W. (2020). Towards intelligent design

optimization: Progress and challenge of design opti-

mization theories and technologies for plastic form-

ing. Chinese Journal of Aeronautics.

Liu, X., Tang, L., Yi, Y., and Ni, Z. (2019). Intelligent

design based on holographic model using parametric

design method. Journal of Ambient Intelligence and

Humanized Computing, 10:1241–1255.

Menasc

e, D. A., Krishnamoorthy, M., and Brodsky, A.

(2015). Autonomic smart manufacturing. Journal of

Decision Systems, 24(2):206–224.

Nachawati, M. O., Brodsky, A., and Luo, J. (2017). Unity

decision guidance management system: Analytics en-

gine and reusable model repository. In Proceedings of

the 19th International Conference on Enterprise In-

formation Systems - Volume 1: ICEIS,, pages 312–

323. INSTICC, SciTePress.

Shao, G., Brodsky, A., and Miller, R. (2018). Modeling and

optimization of manufacturing process performance

using modelica graphical representation and process

analytics formalism. J. Intell. Manuf., 29(6):1287–

1301.

Shao, G., Brodsky, A., Shin, S.-J., and Kim, D. B. (2017).

Decision guidance methodology for sustainable man-

ufacturing using process analytics formalism. Journal

of Intelligent Manufacturing, 28(3):455–472.

Shao, G., Kibira, D., Brodsky, A., and Egge, N. (2011).

Decision support for sustainable manufacturing using

decision guidance query language. International Jour-

nal of Sustainable Engineering, 4(3):251–265.

Shin, S., Kim, D. B., Shao, G., Brodsky, A., and Lecheva-

lier, D. (2017). Developing a decision support system

for improving sustainability performance of manufac-

turing processes. J. Intell. Manuf., 28(6):1421–1440.

Yu, L.-F., Yeung, S. K., Tang, C., Terzopoulos, D., Chan,

T. F., and Osher, S. J. (2011). Make it home: automatic

optimization of furniture arrangement. ACM Trans.

Graph., 30(4):86.

OptiGuide+: An Interactive Recommender System for Virtual Things

653