NVIDIA · rapids-bot · Feb 11, 2026 · Jan 28, 2026 · Jan 28, 2026 · Feb 5, 2026
diff --git a/README.md b/README.md
@@ -1,4 +1,5 @@
-# cuOpt - GPU accelerated Optimization Engine
+<!-- AI agents: Start by reading AGENTS.md -->
+# cuOpt - GPU-accelerated Optimization
 
 [![Build Status](https://github.com/NVIDIA/cuopt/actions/workflows/build.yaml/badge.svg)](https://github.com/NVIDIA/cuopt/actions/workflows/build.yaml)
 [![Version](https://img.shields.io/badge/version-26.02.00-blue)](https://github.com/NVIDIA/cuopt/releases)
@@ -11,12 +12,15 @@
 
 
 
-NVIDIA® cuOpt™ is a GPU-accelerated optimization engine that excels in mixed integer linear programming (MILP), linear programming (LP), quadratic programming (QP) and vehicle routing problems (VRP). It enables near real-time solutions for large-scale challenges with millions of variables and constraints, offering
-easy integration into existing solvers and seamless deployment across hybrid and multi-cloud environments.
+NVIDIA® cuOpt™ is a GPU-accelerated optimization engine that excels in mixed integer linear programming (MILP), linear programming (LP), quadratic programming (QP), and vehicle routing problems (VRP). It enables near real-time solutions for large-scale LPs with millions of variables and constraints, and MIPs with hundreds of thousands of variables. cuOpt offers easy integration into existing modeling languages and seamless deployment across hybrid and multi-cloud environments.
 
 The core engine is written in C++ and wrapped with a C API, Python API and Server API.
 
-For the latest stable version ensure you are on the `main` branch.
+For the latest version, ensure you are on the `main` branch.
+
+## Latest Documentation
+
+[cuOpt Documentation](https://docs.nvidia.com/cuopt/user-guide/latest/introduction.html)
 
 ## Supported APIs
 
@@ -153,6 +157,10 @@ cuOpt follows the RAPIDS release schedule and is part of the **"others"** catego
 
 For current release timelines and dates, refer to the [RAPIDS Maintainers Docs](https://docs.rapids.ai/maintainers/).
 
+## For AI Coding Agents
+
+See [AGENTS.md](./AGENTS.md) for agent-specific guidelines.
+
 ## Contributing Guide
 
 Review the [CONTRIBUTING.md](CONTRIBUTING.md) file for information on how to contribute code and issues to the project.
diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md
@@ -1,6 +1,56 @@
 # Release Notes
 
-
+## Release Notes 26.02
+
+### New Features (26.02)
+
+- New parallel reliability branching inside MIP solver
+- Mixed Integer Gomory, Mixed Integer Rounding, Knapsack and Strong Chvatal Gomory cuts are now added at root node
+- Added an option to use batch PDLP when running strong branching at the root. Based on [Batched First-Order Methods for Parallel LP Solving in MIP](https://arxiv.org/abs/2601.21990) ([Nicolas Blin](https://github.com/Kh4ster), [Stefano Gualandi](https://github.com/stegua), [Christopher Maes](https://github.com/chris-maes), [Andrea Lodi](https://github.com/andrealodi), [Bartolomeo Stellato](https://github.com/bstellato))
+- Quadratic programming (QP) solver is now generally available (previously beta)
+- New infeasibility detection option for PDLP's default solver mode Stable3
+- Solutions callbacks added to C API. Users can now retrieve the dual bound and pass in user data
+- Multiple new diving techniques added for finding integer feasible solutions
+- The [PSLP presolver](https://github.com/dance858/PSLP) is enabled by default for LP problems. Use the presolve option to select Papilo or disable
+- Added a batch solve for routing to boost throughput for many similar instances
+- Added experimental support for determinism in the parallel branch-and-bound solver. GPU heuristics are not supported yet in this mode
+
+### Breaking Changes (26.02)
+
+- The signatures of the solution callbacks have changed for the Python API
+- To use PDLP warm start, presolve must now be explicitly disabled by setting `CUOPT_PRESOLVE=0`. Previously, presolve was disabled automatically
+
+### Improvements (26.02)
+
+- Improved primal/dual warm start for PDLP's default solver mode Stable3
+- Quadratic objectives can now be constructed via a matrix in Python API
+- QP barrier now updates and solves augmented system on the GPU
+- Improved performance for LP folding
+- Probing implications and better variable ordering to strengthen presolve and branching
+- Replace deprecated cuDF Column/Buffer APIs with pylibcudf and public cuDF interfaces
+- Modernize dependency pinnings; make CUDA runtime linkage static for portability
+- Build/tooling: add `--split-compile`, `--jobserver`, Clang host build, ThreadSanitizer, improved container scripts, and branch/commit metadata in images
+- Use explicit `cudaStream_t` with `cub::DeviceTransform` and non-blocking streams for GPU control
+- Enable barrier LP tests, add regression testing, and add SonarQube static analysis
+- Added parameter for specifying the random seed used by the solver
+
+### Bug Fixes (26.02)
+
+- Fixed an issue with incorrect signs of dual variables and reduced costs on maximization problems
+- Fix out-of-bounds in dense-column detection in barrier
+- Correct infeasible-list handling to avoid incorrect infeasibility reports in dual simplex
+- Fix race conditions found via Clang host build + ThreadSanitizer
+- Resolve CUDA–Numba version mismatches with cuDF
+- Fix device code to include required trailing return types
+- Fix issue in crossover after dualization in barrier
+- Repair container build and test failures
+- Miscellaneous additional fixes and stability improvements
+
+### Documentation (26.02)
+
+- Update README and top-level docs for current build and usage
+- Document new repository branching strategies and release-cycle details in README and CONTRIBUTING
+- Add best practices for batch solving
 
 ## Release Notes 25.12
 

@@ -143,9 +143,6 @@ You should see the following output:
 Simple Quadratic Programming Example
 ------------------------------------
 
-.. note::
-   The QP solver is currently in beta.
-
 This example demonstrates how to use the cuOpt C API for quadratic programming.
 
 The example code is available at ``examples/cuopt-c/lp/simple_qp_example.c`` (:download:`download <examples/simple_qp_example.c>`):

@@ -5,9 +5,6 @@
 Quadratic Programming Matrix Example
 ====================================
 
-.. note::
-   The QP solver is currently in beta.
-
 This example demonstrates how to formulate and solve a
 Quadratic Programming (QP) problem represented in a matrix format
 using the cuOpt Python API.

@@ -5,9 +5,6 @@
 Simple Quadratic Programming Example
 ====================================
 
-.. note::
-   The QP solver is currently in beta.
-
 This example demonstrates how to formulate and solve a simple
 Quadratic Programming (QP) problem using the cuOpt Python API.
 

@@ -18,9 +18,6 @@ LP, QP and MILP API Reference
    :members:
    :undoc-members:
 
-.. note::
-   The QP solver is currently in beta.
-
 .. autoclass:: cuopt.linear_programming.problem.QuadraticExpression
    :members:
    :undoc-members:

@@ -33,9 +33,6 @@ The response is as follows:
 Simple Quadratic Programming Example
 ------------------------------------
 
-.. note::
-   The QP solver is currently in beta.
-
 :download:`simple_qp_example.py <examples/simple_qp_example.py>`
 
 .. literalinclude:: examples/simple_qp_example.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# TSP batch solve example: solve multiple TSP instances in one call for higher throughput.
+# Use this when you have many similar routing problems (e.g., many small TSPs) to solve.
+
+import cudf
+import numpy as np
+
+from cuopt import routing
+
+
+def create_tsp_cost_matrix(n_locations):
+    """Create a simple symmetric cost matrix for a TSP of size n_locations."""
+    cost_matrix = np.zeros((n_locations, n_locations), dtype=np.float32)
+    for i in range(n_locations):
+        for j in range(n_locations):
+            cost_matrix[i, j] = abs(i - j)
+    return cudf.DataFrame(cost_matrix)
+
+
+def main():
+    # Define multiple TSP sizes to solve in one batch
+    tsp_sizes = [5, 8, 10, 6, 7, 9]
+
+    # Build one DataModel per TSP
+    data_models = []
+    for n_locations in tsp_sizes:
+        cost_matrix = create_tsp_cost_matrix(n_locations)
+        dm = routing.DataModel(n_locations, 1)  # n_locations, 1 vehicle (TSP)
+        dm.add_cost_matrix(cost_matrix)
+        data_models.append(dm)
+
+    # Shared solver settings for the batch
+    settings = routing.SolverSettings()
+    settings.set_time_limit(5.0)
+
+    # Solve all TSPs in batch (parallel execution)
+    solutions = routing.BatchSolve(data_models, settings)
+
+    # Inspect results
+    print(f"Solved {len(solutions)} TSPs in batch.")
+    for i, (size, solution) in enumerate(zip(tsp_sizes, solutions)):
+        status = solution.get_status()
+        status_str = (
+            "SUCCESS" if status == routing.SolutionStatus.SUCCESS else status
+        )
+        vehicle_count = solution.get_vehicle_count()
+        print(
+            f"  TSP {i} (size {size}): status={status_str}, vehicles={vehicle_count}"
+        )
+
+
+if __name__ == "__main__":
+    main()
@@ -11,4 +11,5 @@ This section contains details on the cuOpt routing optimization Python API.
    :titlesonly:
 
    routing-api.rst
+   routing-examples.rst
    Routing Example <routing-example.ipynb>
@@ -25,6 +25,8 @@ cuOpt Routing Python API Reference
 
 .. autofunction:: cuopt.routing.Solve
 
+.. autofunction:: cuopt.routing.BatchSolve
+
 .. autoclass:: cuopt.routing.Assignment
    :members:
    :undoc-members:

@@ -0,0 +1,42 @@
+========================================
+Routing Examples
+========================================
+
+This section contains examples for the cuOpt routing Python API.
+
+TSP Batch Mode
+--------------
+
+The routing Python API supports **batch mode** for solving many TSP (or routing) instances in a single call. Instead of calling :func:`cuopt.routing.Solve` repeatedly, you build a list of :class:`cuopt.routing.DataModel` objects and call :func:`cuopt.routing.BatchSolve`. The solver runs the problems in parallel to improve throughput.
+
+**When to use batch mode:**
+
+- You have **many similar routing problems** (e.g., dozens or hundreds of small TSPs).
+- You want to **maximize throughput** by utilizing the GPU across multiple problems at once.
+- Problem sizes and structure are compatible with the same :class:`cuopt.routing.SolverSettings` (e.g., same time limit).
+
+**Returns:** A list of :class:`cuopt.routing.Assignment` objects, one per input data model, in the same order as ``data_model_list``. Use :meth:`cuopt.routing.Assignment.get_status` and other assignment methods to inspect each solution.
+
+The following example builds several TSPs of different sizes, solves them in one batch, and prints a short summary per solution.
+
+:download:`tsp_batch_example.py <examples/tsp_batch_example.py>`
+
+.. literalinclude:: examples/tsp_batch_example.py
+   :language: python
+   :linenos:
+
+Sample output:
+
+.. code-block:: text
+
+   Solved 6 TSPs in batch.
+     TSP 0 (size 5): status=SUCCESS, vehicles=1
+     TSP 1 (size 8): status=SUCCESS, vehicles=1
+     TSP 2 (size 10): status=SUCCESS, vehicles=1
+     ...
+
+**Notes:**
+
+- All problems in the batch use the **same** :class:`cuopt.routing.SolverSettings` (e.g., time limit, solver options).
+- Callbacks are not supported in batch mode.
+- For best practices when batching many instances, see the *Add best practices for batch solving* note in the release documentation.
@@ -10,6 +10,11 @@
 Note:
     Warmstart is only applicable to LP, not for MILP.
 
+Important:
+    To use warm start with PDLP, presolve must be explicitly disabled.
+    Set "presolve": "off" in solver_config, as presolve transforms the problem
+    and the warm start solution from the original problem cannot be applied.
+
 Requirements:
     - cuOpt server running (default: localhost:5000)
     - cuopt_sh_client package installed

@@ -374,6 +374,11 @@ Linear Programming FAQs
 
     cuOpt supports presolve reductions using PSLP or Papilo for linear programming (LP) problems, and Papilo for mixed-integer programming (MIP) problems. For MIP problems, Papilo presolve is always enabled by default. For LP problems, PSLP presolve is always enabled by default. Presolve is controlled by the ``CUOPT_PRESOLVE`` setting.
 
+.. dropdown:: How do I use warm start with PDLP?
+
+    To use warm start functionality with PDLP, you must explicitly disable presolve by setting ``CUOPT_PRESOLVE=0`` in solver_config.
+    This is required because presolve transforms the problem, and the warm start solution from the original problem
+    cannot be applied to the presolved problem.
 
 Mixed Integer Linear Programming FAQs
 --------------------------------------

@@ -58,9 +58,6 @@ There are two ways to specify constraints to the LP solver:
 Quadratic Programming
 ---------------------
 
-.. note::
-   The QP solver is currently in beta.
-
 cuOpt supports problems with quadratic objectives of the form:
 
 .. code-block:: text