Tag: optimisation

  • Optimisation evaluations: probing methods with AnyLogic

    Optimisation evaluations: probing methods with AnyLogic

    Aug 21, 2023, updated July 31, 2026

    Summary

    AnyLogic is a powerful simulation tool that can be used to simulate a wide range of systems and processes. It allows developers to build simulations that take in a user defined set of inputs and provide a robust set of outputs. Therefore, it can be a useful tool to aid in optimisation problems by taking in a set of inputs and quickly generating outputs that can then be evaluated to determine how well these inputs performed. Over multiple runs of the simulation with varying inputs you can determine which inputs provide the optimal results.

    AnyLogic provides two main types of experiment that can be used for optimisation. Firstly, there is the Optimisation Experiment which is built on top of the OptQuest Simulation Engine and is quick and easy to set up within AnyLogic. Secondly, there is the Custom Experiment which is entirely specified by the user and gives them full control and flexibility over how the simulation runs. However, to perform optimisation with Custom Experiment it requires the user to set up an external Java programme which calls and runs it. Another area that is useful to consider is how accessing python optimisation scripts can enhance an AnyLogic simulation and allow it to make better decisions or perform more complex processes. The best method for this is using the Java Pypeline library which provides AnyLogic with a way to make calls to external python scripts.

    Optimisation Experiment

    The Optimisation Experiment is a built-in feature within AnyLogic which is designed for running multiple scenarios to try and minimise/maximise the ‘objective function’. The objective function is the value that we want to optimise such as minimising lead time or maximising revenue. This could be a single output or multiple outputs that are resolved into a single aggregated value. The user can specify a set of inputs that are either fixed or are varied between runs of the model so that the best values can be determined. By varying inputs, such as the number of available resources, the model can determine the optimal set of inputs. There is also built-in functionality for performing runs of the model in parallel and evaluating multiple runs of the same inputs to account for randomness within the model such as varying levels of demand for resources at different times. These are good out-of-the box features that are easy to use and can provide a lot of value for simple optimisation problems.

    What are the Limitations of Native AnyLogic Optimisation?

    The out-of-the-box features provide immediate value for straightforward scenarios, the native setup falls short for highly complex engineering or logistics problems.

    • Algorithmic Constraints: The native experiment types are strictly limited to minimising or maximising a specific value. Advanced heuristic search techniques, such as the Hill Climbing method, are not natively supported.
    • Parameter Structure Restrictions: The optimiser cannot natively vary complex inputs like arrays or lists.

    Consequently, varying complex data structures must still be managed manually between runs. Developers may find it necessary to implement dummy inputs simply to ensure the optimiser completes, subsequently collecting performance statistics manually rather than relying on the engine’s built-in outputs.

    In theory, a developer can write custom code within the experiment to execute algorithms like Hill Climbing. However, this approach essentially bypasses the actual OptQuest engine, utilising the platform’s multi-run framework as a workaround for something that could be achieved just as effectively using a standard Monte Carlo experiment.

    AnyLogic Professional Optimization Results for 'ExampleModel' - Status: Finished. The dashboard displays a table comparing current and best iterations and objective values (Best Objective: 471.6), and a performance chart showing feasible and infeasible solution points over iterations. An active 'Copy best' button is present.
    Figure 1: Example of the default Optimisation Experiment UI

    Custom Experiments: The Cloud-Native Paradigm

    While built-in experiments offer out-of-the-box simplicity, the Custom Experiment framework unlocks total flexibility, granting full programmatic control over simulation logic, execution parameters, and model run-times.

    Historically, running a custom experiment meant orchestrating a cumbersome, local Java programme to manually trigger consecutive simulation iterations. Today, this restrictive approach has been entirely replaced by a cloud-native paradigm. Rather than binding computation to a developer’s local machine, modern architectures decouple the simulation model from the optimisation logic.

    Scaling with the AnyLogic Cloud RESTful API

    The contemporary standard for advanced orchestration relies on the AnyLogic Cloud RESTful API, which features native client libraries for Python, Java, and JavaScript. This multi-language web interface fundamentally transforms how custom optimisation loops are executed:

    • Serverless-Style Execution: Developers can completely bypass local environmental constraints. Simulation models are uploaded to a cloud or private server instance, where individual runs are triggered headlessly and asynchronously on-demand.
    • Distributed Parallelisation: Highly intensive, multi-run optimisation loops are offloaded to high-performance infrastructure. The cloud platform splits the workload horizontally across distributed cloud nodes and cores, executing thousands of scenarios simultaneously and drastically shortening time-to-insight.
    • Language-Agnostic Heuristics: By utilising the Cloud API, engineers are no longer forced to write complex search heuristics exclusively in Java. A data scientist can now design sophisticated search algorithms (such as the Hill Climbing method, genetic algorithms, or deep reinforcement learning policies) directly within a Python script, leveraging powerful open-source libraries like Google OR-Tools, SciPy, or PyTorch.

    For example, a Python orchestration script can execute a supply chain simulation via a clean REST call, instantly analyse the returned outputs to pinpoint a localised bottleneck (such as a depleted inventory layer or an asset constraint), update the input vectors, and immediately fire a new flight of parallelised runs across the cloud cluster.

    This modern cloud workflow allows businesses to use their AnyLogic digital twins as highly scalable, serverless objective function evaluators for cutting-edge external solvers.

    A split-pane screenshot of AnyLogic development environment interface. The top section is a code editor displaying syntax-highlighted Java code with comments for configuring and running a simulation engine. Key lines include creating the engine, setting the time unit to SECOND, start date to toDate( 2023, JUNE, 2, 0, 0, 0 ), and stop time to 100. The code goes on to create a new Main object, set its parameters, run the simulation in fast mode (engine.runFast()), collect results into exampleOutput, and stop the engine.The bottom section shows a structured user interface for 'Application options' and 'Advanced Java'. It includes a field for 'Additional class code' where two variable definitions used in the script are present: double exampleInput; and double exampleOutput;, each preceded by a grey-to-red gradient marker icon.
    Figure 2: Example of the Custom Experiment Set Up
    A technical workflow diagram titled "Figure 3: Cloud-Native Custom Experiment Distributed Architecture". On the left, a Master Orchestrator in a Python Environment executes custom heuristics (such as Hill Climbing or Reinforcement Learning). It sends HTTPS POST requests with JSON input vectors across an AnyLogic Cloud RESTful API gateway. On the right, a Distributed Serverless Cluster splits the execution horizontally across multiple Headless Cloud Nodes (Node 1, Node 2, to Node N). The cluster processes the runs in parallel and returns asynchronous JSON execution outputs back to the Python orchestrator.
    Figure 3: Diagram of workflow for running Custom Experiment from external optimiser programme.

    Hybrid Decision Intelligence: Choosing Your Architectural Pattern

    When moving beyond native probing limits, enterprise models require a hybrid approach that pairs discrete-event simulation with sophisticated mathematical solvers or analytical models. Depending on your tech stack, latent memory requirements, and data science infrastructure, two primary patterns emerge.

    Pattern A: The Analytics & ML Bridge (Figure 4)

    Architecture diagram of a modern dual-pathway pipeline illustrating Python-inside-Java integration. Outbound state data flows from an AnyLogic Java simulation through a Jsonifier serialization framework into a Python analytical environment, with optimised decisions returning to the Java simulation.
    Figure 4: Diagram showing workflow of using an optimiser to supplement an AnyLogic model.

    While using native Java remains the foundation for internal scripting, enhancing an AnyLogic simulation with Python’s vast ecosystem of data science, optimisation, and machine learning libraries is now standard practice. However, Python integration is no longer a one-size-fits-all workaround. Modern architectures deploy a structured, dual-pathway approach depending entirely on which environment dictates the execution flow.

    Pathway 1: Pypeline (v1.9.6) – The Python-inside-Java Architecture

    The Pypeline custom library is the premier tool for workflows where the AnyLogic model acts as the parent process. In this configuration, the simulation runs normally in its Java environment but reaches out to a local Python installation to execute discrete, targeted scripts on demand.

    • Best For: Scenarios where the simulation requires real-time assistance from a Python library to make an internal decision (such as querying a pre-trained scikit-learn model to predict an asset failure rate mid-run or calling Google OR-Tools to solve a complex Travelling Salesman problem for fleet routing).
    • The Jsonifier Advantage: Modern iterations of Pypeline are deeply integrated with the Jsonifier serialisation framework. This eliminates the historical headache of manually converting Java data structures into standard text strings. Jsonifier allows entire agent populations, multidimensional tables, and complex database tuples to be seamlessly serialised into machine-readable JSON strings and deserialised back into native Java objects with minimal computational overhead.
    AnyLogic screenshot of a Pypeline configuration form for 'pyCommunicator'. The name is set to 'pyCommunicator' and visible. Connection and error throwing are enabled. The Python command is set to 'python'. Last configuration is not loaded. Output redirection is enabled.
    Figure 5: Default settings for the Pypeline communicator object. Allows you to select which version of python.

    Pathway 2: Alpyne (v1.2.1 Beta) – The Java-inside-Python Architecture

    When the orchestration flow needs to be completely reversed, the Alpyne (v1.2.1 Beta) library provides a powerful alternative. Under this paradigm, the master Python script acts as the host environment, treating the AnyLogic simulation as an importable, interactive object.

    • Best For: Advanced AI training, complex heuristic loops, and intensive Reinforcement Learning (RL) pipelines.
    • How it Works: Developers export their model from AnyLogic using the native Reinforcement Learning experiment framework. The Alpyne package then initialises a standalone AnyLogicSim connection inside Python. The Python script can interactively step the simulation forward, freeze execution at pre-defined decision points, inspect the exact internal observation state, inject an algorithmic action, and collect rewards.
    • AI Testbed Compatibility: Because Python serves as the control room, engineers can natively wrap the simulation inside standard machine learning frameworks (like OpenAI Gym/Gymnasium) to train neural networks using deep RL frameworks like PyTorch, TensorFlow, or Stable-Baselines3.

    Pattern B: The High-Performance Embedded Engine (Figure 6)

    Diagram illustrating Pattern B: an embedded Gurobi solver running in-memory within the AnyLogic JVM instance for zero-latency, mid-run re-optimisation.
    Figure 6: Embedded Math-Heuristic Hybrid Architecture (AnyLogic + Gurobi)

    Embedding the Gurobi Optimiser for Mathematical Rigour

    For large-scale enterprise problems (such as global supply chain networks, complex asset-scheduling, or multi-echelon inventory routing) standard heuristics and search algorithms often struggle to converge on a true mathematical optimum. In these scenarios, the highly robust architecture option involves embedding a high-performance mathematical solver like Gurobi directly into the simulation environment.

    Because AnyLogic is natively built on Java, developers can easily add the gurobi.jar dependency directly into the simulation project’s build path. This setup unlocks a powerful, two-way hybrid framework:

    • Balancing Stochasticity with Deterministic Rigour: AnyLogic excels at capturing the messy, unpredictable realities of a system (stochastic delays, machine breakdowns, fluctuating demand). Meanwhile, Gurobi excels at solving dense, deterministic mathematical models with millions of variables and constraints.
    • Dynamic, Mid-Simulation Re-optimisation: Rather than just using an optimiser to find inputs before a model runs, an AnyLogic model can call the Gurobi Java API during a run. For example, every simulated 24 hours, the model can halt, pass its current state (such as unexpected delivery disruptions or machine outages) to Gurobi as a matrix, and allow Gurobi to instantly calculate a mathematically optimal production schedule or fleet routing blueprint for the next day. The simulation then resumes using that flawless plan.

    By combining AnyLogic’s granular, event-driven simulation with Gurobi’s industry-leading prescriptive analytics engine, engineers can construct highly resilient digital twins that not only accurately predict system bottlenecks but actively solve them with absolute mathematical certainty.

    Architectural Decision Matrix

    Technical CriteriaPattern A: Python Ecosystem Bridge (Fig 4)Pattern B: In-Memory Embedded Solver (Fig 6)
    Primary FocusAI / Machine Learning & Flexible HeuristicsHigh-Speed Deterministic Mathematical Optimisation
    Data Exchange MethodIn-Memory / Inter-Process JSON SerialisationDirect In-Memory JVM RAM Reference
    Execution LatencyMicro-latency (Optimised for macro-step decisions)Near-Zero Latency (Optimised for high-frequency loops)
    Key Software StackAnyLogic + Python (scipy, scikit-learn, OR-Tools)AnyLogic + Gurobi / CPLEX Native Java API

    Final Thoughts: Choosing Your Optimisation Architecture

    Selecting the right optimisation pathway in AnyLogic depends entirely on the scale of your problem and the complexity of the data structures involved. There is no single “correct” approach, but rather a spectrum of engineering choices tailored to enterprise requirements:

    • For Straightforward Parameters: If your objective is simply to vary a handful of discrete or continuous scalar variables to find a clear minimum or maximum, the native Optimisation Experiment offers a highly capable, out-of-the-box framework driven by OptQuest that requires minimal development overhead.
    • For High-Performance Cloud Scaling: When optimisation loops involve multi-dimensional arrays or require advanced custom search heuristics, pivoting to a Custom Experiment executed via the AnyLogic Cloud RESTful API is the modern benchmark. This allows you to offload computational strain serverless-style across distributed cloud nodes.
    • For Ecosystem Integration: If your solution relies on data science or machine learning libraries, deploying a structured, dual-pathway approach via Pypeline (v1.9.6) or Alpyne (v1.2.1 Beta) ensures a robust data exchange between Java and Python, depending on whether the simulation or an external script controls the parent execution flow.
    • For Absolute Mathematical Rigour: For highly dense, combinatorial problems where heuristics fail to guarantee a true global optimum, embedding a premium solver like Gurobi directly into the simulation code path unlocks powerful math-heuristic capabilities. This empowers digital twins to balance unpredictable real-world stochasticity with precise, mid-run prescriptive analytics.

    By understanding these structural boundaries, engineering teams can stop treating simulation models as passive visual tools and start utilising them as scalable, highly intelligent decision-support engines.

    Transform Your Operational Complexities into Provable Success

    At Decision Lab, we specialise in bridging the gap between intricate system simulations and industry-leading mathematical optimisation. Whether you are aiming to de-risk global supply chains, design high-efficiency logistics networks, or train cutting-edge reinforcement learning agents, our decision intelligence experts can help you architect the perfect technical framework.

    Contact our team

  • Why LLMs Aren’t Enough: Engineering Antifragile Operations with Composable Decision Intelligence

    Why LLMs Aren’t Enough: Engineering Antifragile Operations with Composable Decision Intelligence

    As we navigate the technological landscape of 2026, Generative AI has undoubtedly transformed the way we interact with information. Chatbots and Large Language Models (LLMs) have proliferated across enterprise software, streamlining communication and automating basic workflows. However, for operations and supply chain leaders in complex, capital-intensive industries like FMCG, Automotive, and Retail manufacturing, a stark reality is emerging: LLMs are not a silver bullet.

    While language models excel at processing text, they cannot single-handedly optimise a global supply chain network, nor can they provide the quantitative assurance needed to de-risk a £50m factory expansion. When dealing with physical realities, extreme market volatility, and fragmented legacy systems, text prediction is insufficient.

    By 2026, 75% of Global 500 companies will apply decision intelligence practices

    Gartner

    The definitive competitive edge in 2026 belongs to those looking beyond Generative AI toward Decision AI. It belongs to organisations thoughtfully advancing their tech stack and building on established capabilities to embrace the architecture of a Composable Decision Intelligence Platform (DIP).

    The Industrial Reality: High Stakes and High Volatility

    Traditional planning systems struggle to account for agile and accelerated business and the consequent hazards. Today’s supply chain and operations leaders are caught in a crossfire of overlapping challenges, two of the most critical being:

    • Demand & Supply Volatility: SKU proliferation, shifting consumer behaviours, and frequent supply chain disruptions are breaking static planning models. The inability of legacy systems to cope with this extreme volatility inevitably results in poor service levels, excess inventory, and spiralling costs.
    • High-Stakes CAPEX Uncertainty: Securing funding for major capital investments—whether a new automated line, a facility expansion, or rationalising a post-merger manufacturing network—requires robust, data-driven justification. Without quantitative assurance, it is incredibly difficult to de-risk these investments and guarantee ROI.

    Solving these multi-dimensional problems requires more than just analysing past data; it requires a platform capable of simulating the future and discovering the optimal path forward.

    The Path to Implementation: A Composable Architecture

    At Decision Lab, we deliver Decision Intelligence to help leaders master this uncertainty. We achieve this not through a rigid, black-box AI model, but by building a Composable Decision Intelligence Platform based on responsible AI TRiSM principles.

    Composability is the principle that enables businesses to be agile. Rather than relying on a single vendor’s inflexible suite, a composable DIP orchestrates best-in-class, modular capabilities that ingest data from fragmented ERP, MES, and WMS systems. This creates a unified, dynamic view—an AI Simulation Twin.

    The Strategic Advantage of the AI Simulation Twin

    Instead of waiting years for a fully instrumented, hardware-dependent Digital Twin, leading organisations are accelerating their time-to-value by deploying an AI Simulation Twin.

    Traditional Digital Twin programmes often stall in pilot purgatory due to immense IoT integration challenges, prohibitive hardware costs, and fragmented legacy data pipelines. A Simulation Twin, while still ingesting real data, fundamentally bypasses these immediate infrastructure hurdles. It delivers the core predictive and prescriptive advantages now—providing a high-fidelity virtual environment to solve urgent CAPEX and operational bottlenecks—while your physical IoT maturity can be developed as a separate, parallel track. This decoupling ensures you realise ROI in months, rather than years, before moving into the four pillars of the platform:

    Infographic of the four pillars of a composable decision intelligence platform.

    1. The Cognitive Engine: Autonomous AI Agents

    Agentic AI serves as the reasoning layer of the platform. These agents can interpret complex scenarios, model market volatility, and process multi-tiered supply chain dynamics, translating raw data into actionable context.

    2. The Virtual Sandbox: Simulation

    To understand a complex physical network, you must be able to interrogate it and test it. Practically, that means replicating it. We use simulation to build a high-fidelity digital twin environment, employing appropriate technologies, such as AnyLogic’s multi-method capabilities. A simulation maps constraints, machines, and distribution nodes, providing the holistic view necessary to test what-if scenarios safely. It answers critical CAPEX questions before money is spent.

    3. The Mathematical Engine: Optimisation

    Where simulation shows you what could happen, optimisation dictates what should happen. For us, that means employing mathematical optimisation, such as Gurobi’s world-class mathematical solver, to cut through millions of potential permutations. It discovers the mathematically perfect production schedules and inventory policies—maximising throughput and service levels while minimising duplicated costs. The key is being timely—it is no good getting the answer after it was needed. Gurobi’s speed is key here (Gurobi white paper on solver speed).

    4. The Continuous Learning Loop: Reinforcement Learning

    This is where the platform moves from a passive analytical tool to an active operational asset. By applying Reinforcement Learning, specifically leveraging AgileRL, a platform can learn from real-time feedback. It continually experiments within the simulation, discovering new strategies to navigate supply shocks or demand spikes as they happen.

    Engineering the Antifragile Supply Chain

    The ultimate goal of implementing a Composable Decision Intelligence Platform is to shift operations from a state of fragility to one of Antifragility.

    A robust system merely survives a shock. An antifragile operational system improves when exposed to volatility. When a sudden supply chain disruption occurs, the reinforcement learning algorithms immediately assess the new reality within the simulation, trigger the optimisation engine to recalculate the best path, and deploy autonomous agents to orchestrate a self-adapting response. Relying on singular AI models or monolithic ERPs to solve complex physical problems is being consigned to the past.

    For leaders navigating constant disruption, true agility requires an adaptable, composable ecosystem. By implementing a Decision Intelligence Platform, you gain the foresight not just to predict the future, but to engineer your position—a compelling competitive advantage now and for the future.

    To find out more, check out our case studies or contact us!

  • The Power Couple of Decision Science: Integrating Simulation and Optimisation

    The Power Couple of Decision Science: Integrating Simulation and Optimisation

    In the world of complex decision-making, organisations often rely on two distinct tools. On one hand, there is Simulation (‘What happens if…?’), allowing us to model uncertainty and test scenarios. On the other, there is Optimisation (‘What is the best choice?’), allowing us to find the ideal solution within constraints.

    Separately, they are powerful. But when integrated, they unlock a new level of capability—moving from simple decision support to intelligent, autonomous systems.

    At Decision Lab, we don’t believe there is one single best method for this integration. The ideal approach depends entirely on the business problem at hand. Below, we explore the three primary patterns we use to drive value for clients like Migros, FedEx, and Nestlé, and how these models contribute to building truly antifragile organisations.

    Three Patterns of Integration

    We generally view the integration of simulation and optimisation across a spectrum, moving from tactical support to full autonomy.

    1. Optimisation within Simulation (Complex Decision Support)

    In this pattern, the simulation runs a large-scale system, such as a warehouse. When a complex, real-time decision is required, the simulation pauses to call a dedicated optimisation algorithm.

    How it works: The algorithm solves the specific sub-problem, and the simulation continues, testing how that “optimal” decision performs under real-world uncertainty (like worker delays).

    Case Study: For Migros, we utilised this method. Their warehouse simulation calls an optimisation algorithm to determine the most efficient trolley-picking route every time a new order arrives. This allows us to test the routing logic’s real-world impact on the system’s total throughput. Case, video.

    2. Optimisation controls Simulation (Strategic Design)

    Here, the roles are reversed. An external optimisation wrapper searches for the best strategic solution, such as a factory layout or supply chain network.

    How it works: For every solution the optimiser proposes, it uses the simulation as a high-fidelity “evaluation function” to test performance against stochastic conditions.

    Case Study: For DataForm Lab, an optimisation model proposed various wind farm layouts. Our simulation then tested each layout against uncertain wind and wave conditions to calculate true energy output. The optimiser used this feedback to find the next, better solution.

    3. Simulation trains Optimisation (The Autonomous Future)

    This is where we enter the realm of the Digital Twin and Reinforcement Learning (RL). The simulation acts as a high-speed, risk-free training environment.

    How it works: A machine learning agent interacts with the simulation millions of times, learning an ‘optimal policy’ for making autonomous decisions.

    Case Study: For FedEx, we built a simulator for their linehaul operations. An AI agent was trained inside this simulator to learn the optimal policy on when to “cancel, delay, or add” linehauls based on uncertain package volumes, dramatically improving efficiency.

    Building Antifragility: Beyond Resilience

    Why go through the effort of building these combined models? It isn’t just about efficiency; it is about survival and growth.

    A key philosophy at Decision Lab is Antifragility. While resilient systems merely withstand shock, antifragile systems improve because of it. By integrating simulation and optimisation, we create a “Digital Twin” that acts as a long-term asset.

    We use these models to perform rigorous Sensitivity Analysis—identifying which inputs drive outcomes—and to stress-test operations against millions of potential scenarios. This allows organisations to design supply chains and operations that are prepared not just for the average day, but for uncertainty and volatility.

    Navigating the Challenges

    Every powerful methodology has trade-offs. We mitigate these through a rigorous Verification & Validation (V&V) process.

    • Computational Cost: Evaluating thousands of simulation runs is intensive. We use sensitivity analysis to identify key variables early, reducing the search space and focusing computational effort where it matters.
    • Data Dependency: “Garbage in, garbage out” applies doubly here. We don’t just use average values; we statistically analyse historical data to find correct probability distributions (e.g., ensuring orders follow specific peak-and-trough patterns, not just flat averages).

    The ‘Human-in-the-Loop’

    Ultimately, we build these models with you, not just for you.

    Our methodology relies on a Human-in-the-Loop (HITL) framework. Whether we are helping Gousto compress development time for routing logic from months to days, or helping Nestle optimise warehouse slotting, the goal is the same: to present insights that empower expert judgment, not replace it.

    Ready to build your Digital Twin?

    To ensure a successful project, we look for four preliminary conditions:

    1. A clear, quantifiable business problem.
    2. Access to operational and historical data.
    3. Dedicated engagement from your Subject Matter Experts (SMEs).
    4. Clearly defined system boundaries.

    If you are ready to move beyond simple guesswork and start engineering an antifragile operation, Contact Decision Lab today.

  • Bold Choices in an Uncertain World

    Bold Choices in an Uncertain World

    Why Gurobi’s Latest Keynote is a Blueprint for Antifragility

    In the current landscape of supply chain and operational planning, the search for certainty is a losing battle. Yet, many organisations still build their strategies around static forecasts, hoping the world will comply with their spreadsheets.

    At the recent EMEA Gurobi Summit in Vienna, a different path was illuminated. In their keynote Bold Choices, Proven Methods, Gurobi’s Dr. Kostja Siefen and Ronald van der Velden outlined a comprehensive framework for empowering confident decision-making. They effectively demonstrated that optimisation is not only a tactical tool for efficiency; it is a core method underpinning bold leadership. Their presentation encapsulated what we at Decision Lab recognise as Antifragility and the ability to not just withstand volatility, but to use it to gain a competitive edge.

    While resilience is about surviving a shock, antifragility is about improving because of it. Siefen and van der Velden’s keynote perfectly articulated the mechanics required to build such a system. They argued that to move from tentative planning to bold action, organisations must master three specific areas: challenging the status quo, mastering the projects, and achieving business value.

    Here is how Gurobi’s technical roadmap aligns with the strategic imperative of antifragility.

    Resilience Over Prediction

    One of the most dangerous traps in decision-making is the ‘illusion of certainty’. As noted in the keynote, “failures in planning and strategy often stem from misplaced confidence… rather than from making the ‘wrong’ decision”.

    A fragile system assumes the forecast is correct. An antifragile system, however, relies on a Robustness Strategy. As their presentation articulated, the goal is not to eliminate uncertainty but to design processes that endure when reality diverges from expectations. By moving away from a single, unrealistic scenario and embracing uncertainty-aware optimisation, businesses can design plans that remain effective even when the unexpected happens.

    Evolution Through Pacing

    True antifragility is not achieved through a single ‘big bang’ implementation. It requires an Evolution Strategy, viewing the past and future not as opponents, but as partners.

    The keynote speakers emphasised the importance of a Pacing Strategy, where change is introduced through focused stages that create momentum. Rather than demanding instant perfection, successful optimisation projects ‘start small, learn fast, and adapt’. This iterative approach allows an organisation to absorb stressors, such as data quality issues or stakeholder resistance, and use them to refine the model, making the final solution stronger and more fit for purpose.

    The Art of Adaptive Focus

    In the age of Digital Twins, there is a temptation to model every atom of a supply chain. However, complexity without clarity leads to paralysis. The Gurobi keynote introduced the concept of Adaptive Focus: the practice of purposeful abstraction to create robust output.

    By keeping the level of detail adjustable (by balancing relevance, detail, and time) decision-makers can utilise a ‘zoom lens’ to focus on what truly matters in a crisis. This capability is essential for antifragility; it allows leaders to filter out the noise and make rapid, high-quality decisions based on the relevant constraints of the moment.

    Trust as the Currency of Change

    Perhaps the most critical insight for leadership was that trust drives adoption. No matter how advanced the mathematics, a solution will fail if the humans at the helm do not trust it.

    Gurobi’s Trust Strategy suggests that trust should be an informed stance rather than an emotional leap. By utilising what-if scenarios, explainability, and human-in-the-loop validation, organisations can transform compliance into commitment. When teams trust the ‘black box’, they are empowered to make the bold choices required to navigate volatility.

    AI trust and AI TRiSM, a woman printing to a node network featuring a padlock and a shield with a check mark.

    Building trust in complex systems is essential. See how Decision Lab builds trust into projects from the start using the AI TRiSM framework.

    The Decision Lab Perspective

    The methods outlined by Siefen and van der Velden at the Gurobi Summit confirm that the technology to build antifragile systems is already here. We see the future of supply chain planning as range-based experiment-driven. Indeed, Gartner recently recognised Decision Lab as a representative provider in an Innovation Insight report.

    On the journey from fragile, through resilient, to antifragile, we recognise the speed and power of Gurobi’s world-class solver, leveraging its capabilities for solutions to supply chain and defence related challenges. By combining Gurobi’s proven methods with a strategic focus on antifragility, we help our partners stop fearing uncertainty and start using it to their advantage.

    As a Trusted Partner, we offer Gurobi Compass training. It allows teams to integrate solutions and make the most of the solver quickly, whatever challenges they seek to resolve.

    Our Antifragility C-Suite Roadmap for supply chain from Decision Lab CEO David Buxton. Get your copy