Navigating Trade-Offs: Introducing the GAMS Multi-Objective Optimization (MOO) Framework

In traditional optimization, models are primarily built to solve for a single objective—such as strictly minimizing costs or maximizing output—yielding one mathematically optimal solution. However, modern real-world challenges increasingly demand a paradigm shift. Today’s complex problems, from sustainable supply chains to advanced engineering, frequently require the simultaneous evaluation of two or more inherently conflicting objectives. For instance, a manufacturer might need to find the exact balance between achieving the lowest possible production cost and the highest possible material sustainability. Forcing these distinct goals into a single, artificially weighted metric often strips away crucial nuance and oversimplifies the problem.

While some modern solvers offer built-in multi-objective features, they typically rely on lexicographic optimization. This hierarchical approach strictly prioritizes one objective over another, ultimately still yielding just a single definitive answer. Instead of generating one definitive answer, Multi-Objective Optimization (MOO) embraces this complexity by exploring the natural trade-offs between competing goals. This approach produces a Pareto front—a comprehensive set of optimal, non-dominated solutions where no single objective function can be improved in value without directly degrading another.

For example, a Pareto front reveals exactly how much energy system cost must increase to achieve a measurable reduction of system criticality - meaning the system’s reliance on critical raw materials like lithium. This mathematical transparency is essential: it ensures that decision-makers are fully informed about potential alternatives, clearly understand the true, quantified cost of their compromises, and can move forward with absolute confidence that their strategic choices align with their broader organizational goals.

Overcoming Modeling Challenges

While modern solvers offer built-in features for basic, hierarchical multi-objective optimization, generating a comprehensive Pareto frontier is a different story. Traditionally, exploring these complex trade-offs meant building custom implementations from scratch. Modelers had to write complex, model-specific code, manually program loops, and manage the extraction of Pareto solutions themselves. Beyond the initial setup, these custom scripts are a massive headache to maintain and expand. If a modeler decides they want to try a different solving algorithm, they cannot just swap out a single line of code—they potentially have to rewrite the entire workflow.

The need for a better solution became especially apparent during the RESUME research project. The project sought to transition the large-scale REMix energy system model from pure cost optimization to balancing resilient and geopolitically secure energy systems across Europe. Because generating a Pareto frontier requires solving many large-scale instances of REMix, solve time quickly became a critical bottleneck. This distinct challenge drove the development of a highly performant, general-purpose MOO tool that now lives natively within the GAMS modeling environment.

The GAMS MOO Framework: Accessible, Performant, and Stable

The GAMS MOO framework eliminates the overhead of custom implementations by providing a ready-to-use, standardized pipeline, freeing you to focus on analyzing trade-offs rather than debugging and maintaining algorithm implementations.

Fully incorporated into the standard GAMS distribution, the tool offers a low barrier to entry through a simple interface, sample models, and comprehensive documentation . Rather than relying on clunky workarounds, the framework is explicitly engineered to deliver on several critical fronts:

• Accessible and Standardized: Models can now be expanded with minimal programming effort, which significantly lowers the barrier for multi-objective optimization.
• Performance at Scale: To drastically reduce solution times for large-scale models, model generation was heavily optimized using the GAMSModelInstance class. Furthermore, the framework supports parallel execution across both shared and distributed memory (HPC) architectures.
• Computational Stability: The tool has been rigorously tested and adapted for numerically challenging models - like those typically found in energy modeling - ensuring robust convergence.

The Algorithm Portfolio

The framework currently includes several a posteriori methods to generate Pareto-optimal solutions, allowing users to switch between them effortlessly by changing a single line of code. The portfolio currently includes Random Weighting, Augmented Epsilon Constraint, and Sandwiching.

• Random Weighting: This method optimizes the weighted sum of the objective functions. It generates Pareto points by randomly varying the weights. This straightforward approach serves as an easy-to-use baseline for initial explorations of the Pareto front. Check out more details at Multi-Objective Optimization (moo) > RandomWeighting .
• Augmented Epsilon Constraint: This algorithm optimizes one objective while constraining the others, iterating through predefined grid points to find exact Pareto solutions. It is versatile, supporting LP, MIP, as well as corresponding Non-Linear cases. It is also highly suitable for parallelization and avoids redundant calculations by exploiting information from slack variables to skip infeasible solutions. Check out more details at Multi-Objective Optimization (moo) > EpsConstraint .
• Sandwiching: This method approximates the Pareto front by “sandwiching” it between an inner and an outer approximation. It is highly efficient because it sequentially generates Pareto points in regions where the approximation error is the largest. It provides an explicit accuracy measure, allowing the algorithm to stop once a predefined approximation gap is reached. This method is restricted to LP models and cannot be parallelized. Check out more details at Multi-Objective Optimization (moo) > Sandwiching .

Mini-Tutorial: Upgrading Your GAMS Code

Transitioning your code from a single objective to multiple objectives is a seamless process.

Step 1: Start with Your Existing GAMS Model

Before diving into trade-offs, let’s look at the baseline. Normally, a standard single-objective GAMS model relies on a single scalar variable for the objective function. Your code likely looks something like this:

  
    
*[...] Sets and Parameters
*[...] Variables and Equations
Variable Z 'scalar objective function variable';
Model modelname /all/;
solve modelname use LP min Z;

  

Step 2 & 3: Define Multiple Objectives & Call the MOO Framework

To transition from a single objective to a multi-objective problem, you only need to make a few straightforward modifications to your existing model.

First, define the sets and parameters for your objectives and your desired Pareto points. Next, upgrade your objective function variable to a one-dimensional variable so it can hold multiple values. Finally, replace your standard solve statement with the $libInclude moo command to trigger the framework:

  
    
*[...] Sets
Set objectives 'objective functions' / cost, co2, endogenous /
	points 'pareto points' / point1*point100 /;
*[...] Parameters
Parameter direction(objectives) 'direction of the objective functions'
  / cost -1, co2 -1, endogenous +1 /
      	pareto_obj(points,objectives) 'objective values of pareto points';
*[...] Variables and Equations
Variable Z(objectives) 'objective function variables';
Model modelname /all/;
$libInclude moo EpsConstraint modelname LP objectives direction Z points pareto_obj

  

Step 4: Select Your Algorithm and Settings

In the example above, the tool utilizes the EpsConstraint method to solve the model, automatically outputting the generated Pareto points directly into your pareto_obj parameter.

Want to capture more than just the objective values? You can easily instruct the tool to export the full solution for each Pareto point by adding the -savepoint=1 option.

If you want to try a different algorithm, simply swap out EpsConstraint in your include statement for Sandwiching or RandomWeighting, and the framework handles the rest.

Full code examples can be found here .

Step 5 & 6: Generate Pareto Frontier & Analyze Trade-offs

Once your setup is complete, all that is left is to run your model exactly as you normally would. The MOO framework takes over from there, automatically generating the Pareto frontier based on your configurations.

When it comes to analyzing those trade-offs, you have a couple of options for visualizing your results:

• Quick Built-in Plots: If you are working with two or three objectives, the MOO framework includes a basic, out-of-the-box plotting feature. Simply add the -plot=1 option to your run, and GAMS will generate a quick-glance visualization of your frontier. It is a great way to immediately verify your results without any extra coding.
• Custom Advanced Plotting: Need something more robust? Because the built-in plots are relatively simple, you might want to create your own. GAMS makes it incredibly straightforward to export your frontier data. From there, you can easily pull the data into your favorite external tools—like Python (using libraries such as Matplotlib or Seaborn)—to write custom scripts, dive deep into the trade-offs, and generate highly customized, publication-ready charts.

What’s Next

By standardizing the process, the GAMS MOO framework dramatically lowers the barrier to entry for analyzing complex trade-offs. While it was specifically built and proven at scale for the large-scale LPs found in energy modeling, its generic nature means it has wide applicability to modeling problems far beyond energy system analysis.

Looking Ahead: The framework is fully extendable. We are actively working on adding more algorithms to the portfolio to expand your multi-objective toolkit. Furthermore, we are planning to bring multi-objective optimization directly into GAMSPy, ensuring that GAMS speed and Python ease work together seamlessly for your data and analytics pipelines.

Check out the MOO tool in your next project, explore its documentation , and let us know what you think! We are eager to hear your feedback, feature requests, and algorithm wishes as we continue expanding and refining the framework.