Stay Ahead, Stay ONMINE

Introduction to Minimum Cost Flow Optimization in Python

Minimum cost flow optimization minimizes the cost of moving flow through a network of nodes and edges. Nodes include sources (supply) and sinks (demand), with different costs and capacity limits. The aim is to find the least costly way to move volume from sources to sinks while adhering to all capacity limitations. Applications Applications of […]

Minimum cost flow optimization minimizes the cost of moving flow through a network of nodes and edges. Nodes include sources (supply) and sinks (demand), with different costs and capacity limits. The aim is to find the least costly way to move volume from sources to sinks while adhering to all capacity limitations.

Applications

Applications of minimum cost flow optimization are vast and varied, spanning multiple industries and sectors. This approach is crucial in logistics and supply chain management, where it is used to minimize transportation costs while ensuring timely delivery of goods. In telecommunications, it helps in optimizing the routing of data through networks to reduce latency and improve bandwidth utilization. The energy sector leverages minimum cost flow optimization to efficiently distribute electricity through power grids, reducing losses and operational costs. Urban planning and infrastructure development also benefit from this optimization technique, as it assists in designing efficient public transportation systems and water distribution networks.

Example

Below is a simple flow optimization example:

The image above illustrates a minimum cost flow optimization problem with six nodes and eight edges. Nodes A and B serve as sources, each with a supply of 50 units, while nodes E and F act as sinks, each with a demand of 40 units. Every edge has a maximum capacity of 25 units, with variable costs indicated in the image. The objective of the optimization is to allocate flow on each edge to move the required units from nodes A and B to nodes E and F, respecting the edge capacities at the lowest possible cost.

Node F can only receive supply from node B. There are two paths: directly or through node D. The direct path has a cost of 2, while the indirect path via D has a combined cost of 3. Thus, 25 units (the maximum edge capacity) are moved directly from B to F. The remaining 15 units are routed via B -D-F to meet the demand.

Currently, 40 out of 50 units have been transferred from node B, leaving a remaining supply of 10 units that can be moved to node E. The available pathways for supplying node E include: A-E and B-E with a cost of 3, A-C-E with a cost of 4, and B-C-E with a cost of 5. Consequently, 25 units are transported from A-E (limited by the edge capacity) and 10 units from B-E (limited by the remaining supply at node B). To meet the demand of 40 units at node E, an additional 5 units are moved via A-C-E, resulting in no flow being allocated to the B-C pathway.

Mathematical formulation

I introduce two mathematical formulations of minimum cost flow optimization:

1. LP (linear program) with continuous variables only

2. MILP (mixed integer linear program) with continuous and discrete variables

I am using following definitions:

Definitions

LP formulation

This formulation only contains decision variables that are continuous, meaning they can have any value as long as all constraints are fulfilled. Decision variables are in this case the flow variables x(u, v) of all edges.

The objective function describes how the costs that are supposed to be minimized are calculated. In this case it is defined as the flow multiplied with the variable cost summed up over all edges:

Constraints are conditions that must be satisfied for the solution to be valid, ensuring that the flow does not exceed capacity limitations.

First, all flows must be non-negative and not exceed to edge capacities:

Flow conservation constraints ensure that the same amount of flow that goes into a node has to come out of the node. These constraints are applied to all nodes that are neither sources nor sinks:

For source and sink nodes the difference of out flow and in flow is smaller or equal the supply of the node:

If v is a source the difference of outflow minus inflow must not exceed the supply s(v). In case v is a sink node we do not allow that more than -s(v) can flow into the node than out of the node (for sinks s(v) is negative).

MILP

Additionally, to the continuous variables of the LP formulation, the MILP formulation also contains discreate variables that can only have specific values. Discrete variables allow to restrict the number of used nodes or edges to certain values. It can also be used to introduce fixed costs for using nodes or edges. In this article I show how to add fixed costs. It is important to note that adding discrete decision variables makes it much more difficult to find an optimal solution, hence this formulation should only be used if a LP formulation is not possible.

The objective function is defined as:

With three terms: variable cost of all edges, fixed cost of all edges, and fixed cost of all nodes.

The maximum flow that can be allocated to an edge depends on the edge’s capacity, the edge selection variable, and the origin node selection variable:

This equation ensures that flow can only be assigned to edges if the edge selection variable and the origin node selection variable are 1.

The flow conservation constraints are equivalent to the LP problem.

Implementation

In this section I explain how to implement a MILP optimization in Python. You can find the code in this repo.

Libraries

To build the flow network, I used NetworkX which is an excellent library (https://networkx.org/) for working with graphs. There are many interesting articles that demonstrate how powerful and easy to use NetworkX is to work with graphs, i.a. customizing NetworkX Graphs, NetworkX: Code Demo for Manipulating Subgraphs, Social Network Analysis with NetworkX: A Gentle Introduction.

One important aspect when building an optimization is to make sure that the input is correctly defined. Even one small error can make the problem infeasible or can lead to an unexpected solution. To avoid this, I used Pydantic to validate the user input and raise any issues at the earliest possible stage. This article gives an easy to understand introduction to Pydantic.

To transform the defined network into a mathematical optimization problem I used PuLP. Which allows to define all variables and constraint in an intuitive way. This library also has the advantage that it can use many different solvers in a simple pug-and-play fashion. This article provides good introduction to this library.

Defining nodes and edges

The code below shows how nodes are defined:

from pydantic import BaseModel, model_validator
from typing import Optional

# node and edge definitions
class Node(BaseModel, frozen=True):
    """
    class of network node with attributes:
    name: str - name of node
    demand: float - demand of node (if node is sink)
    supply: float - supply of node (if node is source)
    capacity: float - maximum flow out of node
    type: str - type of node
    x: float - x-coordinate of node
    y: float - y-coordinate of node
    fixed_cost: float - cost of selecting node
    """
    name: str
    demand: Optional[float] = 0.0
    supply: Optional[float] = 0.0
    capacity: Optional[float] = float('inf')
    type: Optional[str] = None
    x: Optional[float] = 0.0
    y: Optional[float] = 0.0
    fixed_cost: Optional[float] = 0.0

    @model_validator(mode='after')
    def validate(self):
        """
        validate if node definition are correct
        """
        # check that demand is non-negative
        if self.demand < 0 or self.demand == float('inf'): raise ValueError('demand must be non-negative and finite')
        # check that supply is non-negative
        if self.supply < 0: raise ValueError('supply must be non-negative')
        # check that capacity is non-negative
        if self.capacity < 0: raise ValueError('capacity must be non-negative')
        # check that fixed_cost is non-negative
        if self.fixed_cost < 0: raise ValueError('fixed_cost must be non-negative')
        return self

Nodes are defined through the Node class which is inherited from Pydantic’s BaseModel. This enables an automatic validation that ensures that all properties are defined with the correct datatype whenever a new object is created. In this case only the name is a required input, all other properties are optional, if they are not provided the specified default value is assigned to them. By setting the “frozen” parameter to True I made all properties immutable, meaning they cannot be changed after the object has been initialized.

The validate method is executed after the object has been initialized and applies more checks to ensure the provided values are as expected. Specifically it checks that demand, supply, capacity, variable cost and fixed cost are not negative. Furthermore, it also does not allow infinite demand as this would lead to an infeasible optimization problem.

These checks look trivial, however their main benefit is that they will trigger an error at the earliest possible stage when an input is incorrect. Thus, they prevent creating a optimization model that is incorrect. Exploring why a model cannot be solved would be much more time consuming as there are many factors that would need to be analyzed, while such “trivial” input error may not be the first aspect to investigate.

Edges are implemented as follows:

class Edge(BaseModel, frozen=True):
"""
class of edge between two nodes with attributes:
origin: 'Node' - origin node of edge
destination: 'Node' - destination node of edge
capacity: float - maximum flow through edge
variable_cost: float - cost per unit flow through edge
fixed_cost: float - cost of selecting edge
"""
origin: Node
destination: Node
capacity: Optional[float] = float('inf')
variable_cost: Optional[float] = 0.0
fixed_cost: Optional[float] = 0.0

@model_validator(mode='after')
def validate(self):
"""
validate of edge definition is correct
"""
# check that node names are different
if self.origin.name == self.destination.name: raise ValueError('origin and destination names must be different')
# check that capacity is non-negative
if self.capacity < 0: raise ValueError('capacity must be non-negative')
# check that variable_cost is non-negative
if self.variable_cost < 0: raise ValueError('variable_cost must be non-negative')
# check that fixed_cost is non-negative
if self.fixed_cost < 0: raise ValueError('fixed_cost must be non-negative')
return self

The required inputs are an origin node and a destination node object. Additionally, capacity, variable cost and fixed cost can be provided. The default value for capacity is infinity which means if no capacity value is provided it is assumed the edge does not have a capacity limitation. The validation ensures that the provided values are non-negative and that origin node name and the destination node name are different.

Initialization of flowgraph object

To define the flowgraph and optimize the flow I created a new class called FlowGraph that is inherited from NetworkX’s DiGraph class. By doing this I can add my own methods that are specific to the flow optimization and at the same time use all methods DiGraph provides:

from networkx import DiGraph
from pulp import LpProblem, LpVariable, LpMinimize, LpStatus

class FlowGraph(DiGraph):
    """
    class to define and solve minimum cost flow problems
    """
    def __init__(self, nodes=[], edges=[]):
        """
        initialize FlowGraph object
        :param nodes: list of nodes
        :param edges: list of edges
        """
        # initialialize digraph
        super().__init__(None)

        # add nodes and edges
        for node in nodes: self.add_node(node)
        for edge in edges: self.add_edge(edge)


    def add_node(self, node):
        """
        add node to graph
        :param node: Node object
        """
        # check if node is a Node object
        if not isinstance(node, Node): raise ValueError('node must be a Node object')
        # add node to graph
        super().add_node(node.name, demand=node.demand, supply=node.supply, capacity=node.capacity, type=node.type, 
                         fixed_cost=node.fixed_cost, x=node.x, y=node.y)
        
    
    def add_edge(self, edge):    
        """
        add edge to graph
        @param edge: Edge object
        """   
        # check if edge is an Edge object
        if not isinstance(edge, Edge): raise ValueError('edge must be an Edge object')
        # check if nodes exist
        if not edge.origin.name in super().nodes: self.add_node(edge.origin)
        if not edge.destination.name in super().nodes: self.add_node(edge.destination)

        # add edge to graph
        super().add_edge(edge.origin.name, edge.destination.name, capacity=edge.capacity, 
                         variable_cost=edge.variable_cost, fixed_cost=edge.fixed_cost)

FlowGraph is initialized by providing a list of nodes and edges. The first step is to initialize the parent class as an empty graph. Next, nodes and edges are added via the methods add_node and add_edge. These methods first check if the provided element is a Node or Edge object. If this is not the case an error will be raised. This ensures that all elements added to the graph have passed the validation of the previous section. Next, the values of these objects are added to the Digraph object. Note that the Digraph class also uses add_node and add_edge methods to do so. By using the same method name I am overwriting these methods to ensure that whenever a new element is added to the graph it must be added through the FlowGraph methods which validate the object type. Thus, it is not possible to build a graph with any element that has not passed the validation tests.

Initializing the optimization problem

The method below converts the network into an optimization model, solves it, and retrieves the optimized values.

  def min_cost_flow(self, verbose=True):
        """
        run minimum cost flow optimization
        @param verbose: bool - print optimization status (default: True)
        @return: status of optimization
        """
        self.verbose = verbose

        # get maximum flow
        self.max_flow = sum(node['demand'] for _, node in super().nodes.data() if node['demand'] > 0)

        start_time = time.time()
        # create LP problem
        self.prob = LpProblem("FlowGraph.min_cost_flow", LpMinimize)
        # assign decision variables
        self._assign_decision_variables()
        # assign objective function
        self._assign_objective_function()
        # assign constraints
        self._assign_constraints()
        if self.verbose: print(f"Model creation time: {time.time() - start_time:.2f} s")

        start_time = time.time()
        # solve LP problem
        self.prob.solve()
        solve_time = time.time() - start_time

        # get status
        status = LpStatus[self.prob.status]

        if verbose:
            # print optimization status
            if status == 'Optimal':
                # get objective value
                objective = self.prob.objective.value()
                print(f"Optimal solution found: {objective:.2f} in {solve_time:.2f} s")
            else:
                print(f"Optimization status: {status} in {solve_time:.2f} s")
        
        # assign variable values
        self._assign_variable_values(status=='Optimal')

        return status

Pulp’s LpProblem is initialized, the constant LpMinimize defines it as a minimization problem — meaning it is supposed to minimize the value of the objective function. In the following lines all decision variables are initialized, the objective function as well as all constraints are defined. These methods will be explained in the following sections.

Next, the problem is solved, in this step the optimal value of all decision variables is determined. Following the status of the optimization is retrieved. When the status is “Optimal” an optimal solution could be found other statuses are “Infeasible” (it is not possible to fulfill all constraints), “Unbounded” (the objective function can have an arbitrary low values), and “Undefined” meaning the problem definition is not complete. In case no optimal solution was found the problem definition needs to be reviewed.

Finally, the optimized values of all variables are retrieved and assigned to the respective nodes and edges.

Defining decision variables

All decision variables are initialized in the method below:

   def _assign_variable_values(self, opt_found):
        """
        assign decision variable values if optimal solution found, otherwise set to None
        @param opt_found: bool - if optimal solution was found
        """
        # assign edge values        
        for _, _, edge in super().edges.data():
            # initialize values
            edge['flow'] = None
            edge['selected'] = None
            # check if optimal solution found
            if opt_found and edge['flow_var'] is not None:                    
                edge['flow'] = edge['flow_var'].varValue                    

                if edge['selection_var'] is not None: 
                    edge['selected'] = edge['selection_var'].varValue

        # assign node values
        for _, node in super().nodes.data():
            # initialize values
            node['selected'] = None
            if opt_found:                
                # check if node has selection variable
                if node['selection_var'] is not None: 
                    node['selected'] = node['selection_var'].varValue

First it iterates through all edges and assigns continuous decision variables if the edge capacity is greater than 0. Furthermore, if fixed costs of the edge are greater than 0 a binary decision variable is defined as well. Next, it iterates through all nodes and assigns binary decision variables to nodes with fixed costs. The total number of continuous and binary decision variables is counted and printed at the end of the method.

Defining objective

After all decision variables have been initialized the objective function can be defined:

    def _assign_objective_function(self):
        """
        define objective function
        """
        objective = 0
 
        # add edge costs
        for _, _, edge in super().edges.data():
            if edge['selection_var'] is not None: objective += edge['selection_var'] * edge['fixed_cost']
            if edge['flow_var'] is not None: objective += edge['flow_var'] * edge['variable_cost']
        
        # add node costs
        for _, node in super().nodes.data():
            # add node selection costs
            if node['selection_var'] is not None: objective += node['selection_var'] * node['fixed_cost']

        self.prob += objective, 'Objective',

The objective is initialized as 0. Then for each edge fixed costs are added if the edge has a selection variable, and variable costs are added if the edge has a flow variable. For all nodes with selection variables fixed costs are added to the objective as well. At the end of the method the objective is added to the LP object.

Defining constraints

All constraints are defined in the method below:

  def _assign_constraints(self):
        """
        define constraints
        """
        # count of contraints
        constr_count = 0
        # add capacity constraints for edges with fixed costs
        for origin_name, destination_name, edge in super().edges.data():
            # get capacity
            capacity = edge['capacity'] if edge['capacity'] < float('inf') else self.max_flow
            rhs = capacity
            if edge['selection_var'] is not None: rhs *= edge['selection_var']
            self.prob += edge['flow_var'] <= rhs, f"capacity_{origin_name}-{destination_name}",
            constr_count += 1
            
            # get origin node
            origin_node = super().nodes[origin_name]
            # check if origin node has a selection variable
            if origin_node['selection_var'] is not None:
                rhs = capacity * origin_node['selection_var'] 
                self.prob += (edge['flow_var'] <= rhs, f"node_selection_{origin_name}-{destination_name}",)
                constr_count += 1

        total_demand = total_supply = 0
        # add flow conservation constraints
        for node_name, node in super().nodes.data():
            # aggregate in and out flows
            in_flow = 0
            for _, _, edge in super().in_edges(node_name, data=True):
                if edge['flow_var'] is not None: in_flow += edge['flow_var']
            
            out_flow = 0
            for _, _, edge in super().out_edges(node_name, data=True):
                if edge['flow_var'] is not None: out_flow += edge['flow_var']

            # add node capacity contraint
            if node['capacity'] < float('inf'):
                self.prob += out_flow = demand - supply
                rhs = node['demand'] - node['supply']
                self.prob += in_flow - out_flow >= rhs, f"flow_balance_{node_name}",
            constr_count += 1

            # update total demand and supply
            total_demand += node['demand']
            total_supply += node['supply']

        if self.verbose:
            print(f"Constraints: {constr_count}")
            print(f"Total supply: {total_supply}, Total demand: {total_demand}")

First, capacity constraints are defined for each edge. If the edge has a selection variable the capacity is multiplied with this variable. In case there is no capacity limitation (capacity is set to infinity) but there is a selection variable, the selection variable is multiplied with the maximum flow that has been calculated by aggregating the demand of all nodes. An additional constraint is added in case the edge’s origin node has a selection variable. This constraint means that flow can only come out of this node if the selection variable is set to 1.

Following, the flow conservation constraints for all nodes are defined. To do so the total in and outflow of the node is calculated. Getting all in and outgoing edges can easily be done by using the in_edges and out_edges methods of the DiGraph class. If the node has a capacity limitation the maximum outflow will be constraint by that value. For the flow conservation it is necessary to check if the node is either a source or sink node or a transshipment node (demand equals supply). In the first case the difference between inflow and outflow must be greater or equal the difference between demand and supply while in the latter case in and outflow must be equal.

The total number of constraints is counted and printed at the end of the method.

Retrieving optimized values

After running the optimization, the optimized variable values can be retrieved with the following method:

    def _assign_variable_values(self, opt_found):
        """
        assign decision variable values if optimal solution found, otherwise set to None
        @param opt_found: bool - if optimal solution was found
        """
        # assign edge values        
        for _, _, edge in super().edges.data():
            # initialize values
            edge['flow'] = None
            edge['selected'] = None
            # check if optimal solution found
            if opt_found and edge['flow_var'] is not None:                    
                edge['flow'] = edge['flow_var'].varValue                    

                if edge['selection_var'] is not None: 
                    edge['selected'] = edge['selection_var'].varValue

        # assign node values
        for _, node in super().nodes.data():
            # initialize values
            node['selected'] = None
            if opt_found:                
                # check if node has selection variable
                if node['selection_var'] is not None: 
                    node['selected'] = node['selection_var'].varValue 

This method iterates through all edges and nodes, checks if decision variables have been assigned and adds the decision variable value via varValue to the respective edge or node.

Demo

To demonstrate how to apply the flow optimization I created a supply chain network consisting of 2 factories, 4 distribution centers (DC), and 15 markets. All goods produced by the factories have to flow through one distribution center until they can be delivered to the markets.

Supply chain problem

Node properties were defined:

Node definitions

Ranges mean that uniformly distributed random numbers were generated to assign these properties. Since Factories and DCs have fixed costs the optimization also needs to decide which of these entities should be selected.

Edges are generated between all Factories and DCs, as well as all DCs and Markets. The variable cost of edges is calculated as the Euclidian distance between origin and destination node. Capacities of edges from Factories to DCs are set to 350 while from DCs to Markets are set to 100.

The code below shows how the network is defined and how the optimization is run:

# Define nodes
factories = [Node(name=f'Factory {i}', supply=700, type='Factory', fixed_cost=100, x=random.uniform(0, 2),
                  y=random.uniform(0, 1)) for i in range(2)]
dcs = [Node(name=f'DC {i}', fixed_cost=25, capacity=500, type='DC', x=random.uniform(0, 2), 
            y=random.uniform(0, 1)) for i in range(4)]
markets = [Node(name=f'Market {i}', demand=random.randint(1, 100), type='Market', x=random.uniform(0, 2), 
                y=random.uniform(0, 1)) for i in range(15)]

# Define edges
edges = []
# Factories to DCs
for factory in factories:
    for dc in dcs:
        distance = ((factory.x - dc.x)**2 + (factory.y - dc.y)**2)**0.5
        edges.append(Edge(origin=factory, destination=dc, capacity=350, variable_cost=distance))

# DCs to Markets
for dc in dcs:
    for market in markets:
        distance = ((dc.x - market.x)**2 + (dc.y - market.y)**2)**0.5
        edges.append(Edge(origin=dc, destination=market, capacity=100, variable_cost=distance))

# Create FlowGraph
G = FlowGraph(edges=edges)

G.min_cost_flow()

The output of flow optimization is as follows:

Variable types: 68 continuous, 6 binary
Constraints: 161
Total supply: 1400.0, Total demand: 909.0
Model creation time: 0.00 s
Optimal solution found: 1334.88 in 0.23 s

The problem consists of 68 continuous variables which are the edges’ flow variables and 6 binary decision variables which are the selection variables of the Factories and DCs. There are 161 constraints in total which consist of edge and node capacity constraints, node selection constraints (edges can only have flow if the origin node is selected), and flow conservation constraints. The next line shows that the total supply is 1400 which is higher than the total demand of 909 (if the demand was higher than the supply the problem would be infeasible). Since this is a small optimization problem, the time to define the optimization model was less than 0.01 seconds. The last line shows that an optimal solution with an objective value of 1335 could be found in 0.23 seconds.

Additionally, to the code I described in this post I also added two methods that visualize the optimized solution. The code of these methods can also be found in the repo.

Flow graph

All nodes are located by their respective x and y coordinates. The node and edge size is relative to the total volume that is flowing through. The edge color refers to its utilization (flow over capacity). Dashed lines show edges without flow allocation.

In the optimal solution both Factories were selected which is inevitable as the maximum supply of one Factory is 700 and the total demand is 909. However, only 3 of the 4 DCs are used (DC 0 has not been selected).

In general the plot shows the Factories are supplying the nearest DCs and DCs the nearest Markets. However, there are a few exceptions to this observation: Factory 0 also supplies DC 3 although Factory 1 is nearer. This is due to the capacity constraints of the edges which only allow to move at most 350 units per edge. However, the closest Markets to DC 3 have a slightly higher demand, hence Factory 0 is moving additional units to DC 3 to meet that demand. Although Market 9 is closest to DC 3 it is supplied by DC 2. This is because DC 3 would require an additional supply from Factory 0 to supply this market and since the total distance from Factory 0 over DC 3 is longer than the distance from Factory 0 through DC 2, Market 9 is supplied via the latter route.

Another way to visualize the results is via a Sankey diagram which focuses on visualizing the flows of the edges:

Sankey flow diagram

The colors represent the edges’ utilizations with lowest utilizations in green changing to yellow and red for the highest utilizations. This diagram shows very well how much flow goes through each node and edge. It highlights the flow from Factory 0 to DC 3 and also that Market 13 is supplied by DC 2 and DC 1.

Summary

Minimum cost flow optimizations can be a very helpful tool in many domains like logistics, transportation, telecommunication, energy sector and many more. To apply this optimization it is important to translate a physical system into a mathematical graph consisting of nodes and edges. This should be done in a way to have as few discrete (e.g. binary) decision variables as necessary as those make it significantly more difficult to find an optimal solution. By combining Python’s NetworkX, Pulp and Pydantic libraries I built an flow optimization class that is intuitive to initialize and at the same time follows a generalized formulation which allows to apply it in many different use cases. Graph and flow diagrams are very helpful to understand the solution found by the optimizer.

If not otherwise stated all images were created by the author.

Shape
Shape
Stay Ahead

Explore More Insights

Stay ahead with more perspectives on cutting-edge power, infrastructure, energy,  bitcoin and AI solutions. Explore these articles to uncover strategies and insights shaping the future of industries.

Shape

Energy Secretary Acts to Protect Mid-Atlantic Grid

WASHINGTON—U.S. Secretary of Energy Chris Wright issued an emergency order to reduce the risk of power outages and strengthen grid reliability across the mid-Atlantic region. The order permits PJM Interconnection, L.L.C. (PJM), in coordination with Talen Energy Corporation, to run Unit 4 at the Wagner Generating Station in Anne Arundel County, Maryland, to meet anticipated electricity demand. The order follows an application from PJM submitted on October 23, 2026.  “Energy shortfalls for 65 million Americans are simply unacceptable,” said U.S. Secretary of Energy Chris Wright.  “Previous orders in the mid-Atlantic region have helped keep the lights on and I’m confident this order will help do so in the coming months as well. Today’s order helps temporarily address the urgent need to strengthen grid reliability and ensure Americans across the mid-Atlantic region have access to affordable, reliable, and secure power, regardless of whether the sun shines or the wind blows.”   Secretary Wright previously granted PJM’s requests to operate Wagner Unit 4 beyond its operating limit to help maintain grid reliability.  PJM relied on Wagner Unit 4 during periods of unusually high temperatures earlier this summer, using the unit’s remaining operating hours. PJM has since reaffirmed to the Department of Energy (DOE) the continued need for Wagner Unit 4 to meet high electricity demand, strengthen grid reliability, and reduce the risk of power outages across the mid-Atlantic region.   The renewed order is effective from November 18, 2026, through December 31, 2026. 

Read More »

EIA: US crude oil inventories up 3.4 million bbl

US crude oil inventories for the week ended Nov. 13, excluding the Strategic Petroleum Reserve, increased by 3.4 million bbl from the previous week, according to data from the US Energy Information Administration (EIA). At 417.8 million bbl, US crude oil inventories are 3% below the 5-year average for this time of year, the EIA report indicated. Gasoline inventories increased 5.2 million bbl, 3% above the 5-year average. Propane-propylene inventories remained unchanged, 12% above the 5-year average. Total commercial petroleum inventories increased by 9.2 million bbl for the week. Distillate inventories increased 1.6 million bbl, 7% below the 5-year average. US crude oil refinery inputs averaged 16.9 million b/d for the week ended Nov. 13, which was 129,000 b/d less than the previous week’s average. Refineries operated at 95.7% of capacity. Gasoline output averaged 9.4 million b/d, and distillate production increased to 5.2 million b/d. Crude oil imports decreased 1.1 million b/d to 5.6 million b/d. The 4-week average of 6.3 million b/d is 13% above the year-ago level. Gasoline imports increased and averaged 533,000 b/d; distillate imports also increased and averaged 133,000 b/d. Over the past four weeks, total product supplied averaged 20.6 million b/d, down 0.3% year over year. The 4-week average for gasoline product supplied decreased 1.8% year over year to 8.7 million b/d, while the 4-week average for distillate product supplied increased 4.3% to 4.0 million b/d. The 4-week average for jet fuel product supplied increased 0.3% year over year.

Read More »

Sonangol discovers hydrocarbons offshore Kwanza basin

Sonangol’s Burututu-1 well has identified hydrocarbons in pre-salt reservoirs for the first time in Angola’s Block 5/06. <!–> Nov. 18, 2026 –> Key Highlights Burututu-1 is the first well to identify hydrocarbons in presalt reservoirs in Block 5/06. The discovery lies in the maritime portion of Angola’s Kwanza basin. The exploration identified 25 m of reservoir containing hydrocarbon deposits.

Read More »

The grid will fall short of AI’s power needs. These 6 resources can close the gap.

Listen to the article 7 min This audio is auto-generated. Please let us know if you have feedback. Simon Irish is CEO of Terrestrial Energy, a developer of small modular nuclear reactors. Most planning for artificial intelligence’s electricity demand starts with a forecast and asks whether it is right. I would start somewhere else: Assume the grid will fall short, then ask how to close the gap — and how fast. Simon Irish The evidence supports that starting point. McKinsey & Company estimates the U.S. will need 30 GW to 55 GW of additional capacity by 2030 as data center demand grows and aging plants retire. PJM Interconnection, the largest U.S. grid operator, has already seen the impacts of this trend. Its latest capacity auction fell about 6.6 GW short of its reliability requirement and cleared at the price cap. Forecasts can be wrong, and requested load can be speculative or duplicative. But the PJM result is a market outcome, not a forecast. The useful question is which tools can close the gap, by when and at what cost. 6 ways to close the gap, and where each runs out The first four options below address serving data centers through the grid. The final two consider generation at or near the data center, with an optional grid connection. These categories overlap; on-site generation is a delivery strategy, not a generation technology, and can use multiple technologies. Flexible demand. Duke University’s Nicholas Institute estimates the grid could absorb 76 GW of new load if that load accepted curtailment averaging 0.25% of annual consumption, in events of about 1.7 hours. It is the fastest option because it needs no new generation. It makes better use of capacity already on the grid. But that capacity is finite, and beyond it, further load growth

Read More »

NEO Next+ to acquire UK upstream business from EnQuest for up to $960 million

NEO Next+ Energy Upstream UK Ltd. has agreed to acquire EnQuest plc’s UK upstream oil and gas business and associated infrastructure for up to $960 million. The acquisition includes all issued shares of EnQuest Britain Ltd., which through subsidiaries holds EnQuest’s UK upstream interests, including the operated Magnus, Kraken, and Greater Kittiwake Area fields (Kittiwake, Mallard, Gadwall, Goosander and Grouse), the non-operated Golden Eagle field, and the undeveloped Bressay field and Bentley discovery. The assets averaged net production of 31,100 boe/d in 2025, comprising 92% liquids and 8% gas. As of Dec. 31, 2025, the portfolio contained 122 MMboe of 2P reserves and 308 MMboe of 2C resources, according to EnQuest. The deal also includes EnQuest’s UK decommissioning liabilities and midstream interests, including its operating stake in the Sullom Voe Terminal, the Northern Leg gas pipeline, and the Ninian pipeline system. EnQuest is divesting the assets as part of a broader strategy to become a Southeast Asia-focused operator with production, development, and exploration assets in Malaysia, Vietnam, Brunei, and Indonesia, as well as its Veri Energy subsidiary and associated carbon capture, utilization, and storage interests. The company cited an uncertain UK investment environment. For NEO Next+, the deal is the latest step in its North Sea consolidation strategy. In December 2025, TotalEnergies agreed to combine its UK offshore upstream business with NEO NEXT Energy Ltd., creating what the companies described as the largest independent oil and gas producer in the UK. Consideration comprises an upfront cash payment of $840 million at closing, subject to customary adjustments, and contingent payments of up to $120 million tied to future oil prices and potential changes to the UK fiscal regime, including repeal or reduction of the Energy Profits Levy between January 2027 and yearend 2029. Completion remains subject to customary conditions and regulatory approvals. The

Read More »

Energy Department Announces $2.8 Billion Loan to Strengthen Grid Reliability and Help Lower Costs in Wyoming

WASHINGTON—The U.S. Department of Energy’s (DOE) Office of Energy Dominance Financing (EDF) today announced a conditional loan commitment of up to $2.8 billion for Grid United’s Wyoming Intertie project to lower electricity costs and strengthen grid reliability in Wyoming. The project will add approximately 1.8 gigawatts (GW) of electricity transfer capacity and is estimated to deliver up to $39 billion in electricity cost savings for American families and businesses across 17 states within the Western Electricity Coordinating Council (WECC) and Southwest Power Pool (SPP) regions. The loan advances President Trump’s Executive Order Strengthening the Reliability and Security of the U.S. Electric Grid and builds on DOE’s recent Speed to Power through Accelerated Reconductoring and other Key Advanced Transmission Technology Upgrades (SPARK) announcement. “The Energy Department is delivering on President Trump’s promise to strengthen America’s electric grid and unleash American energy dominance,” said U.S. Secretary of Energy Chris Wright. “Projects like Wyoming Intertie will help move more American energy where it’s needed most to support our nation’s growing energy needs and power American prosperity for decades to come.” Wyoming Intertie will double existing transfer capacity between the SPP and WECC regions, allowing more electricity to flow across Wyoming to meet growing demand and improve grid resilience during periods of high demand and extreme weather. The project will also create hundreds of construction-related jobs and long-term operations jobs, supporting local economic growth over the 30-year life of the project. “Thanks to President Trump and Secretary Wright, EDF is financing projects that deliver real benefits to American families and businesses,” said EDF Director Gregory A. Beard. “Wyoming Intertie is a prime example of how EDF’s financing can help lower electricity costs, create American jobs, and support long-term economic growth in Wyoming and across the nation.” While this conditional commitment indicates DOE’s intent to

Read More »

App developers turn to QVAC for AI tooling without the cloud  

In most instances today, adding AI to an app means sending user data to a third-party API, paying per request, and hoping the connection holds.    Tether’sQVAC is built on the opposite premise. It runs AI models directly on the user’s device. Data never leaves the hardware, there are no per-request costs, no rate limits, and no need for an internet connection once a model is downloaded.   QVAC SDK: the next milestone in cloud-free AI  While open-source tools and standards like llama.cpp, GGML, and ONNX have made local AI much more accessible in recent years, creating new possibilities for consumer devices, the edge AI ecosystem remains fragmented.    Against this backdrop, in 2026, Tether released a software development kit (SDK) that pulls together the best open tooling from across different domains of machine learning.    The centerpiece of Tether’sQVACSDK isFabric. Built on llama.cpp, it expands the engine to enable on-device fine tuning and additional AI capabilities—opening access to memory-intensive workloads previously only possible with expensive hardware or cloud services.    Building on GGML’s modular framework, QVAC Fabric is primarily oriented toward three backends: Vulkan, which covers most consumer-grade desktop and mobile chips; Metal and Core ML for Apple Silicon; and CUDA for higher-end NVIDIA GPU setups.   The QVAC SDK empowers developers with a unified interface for building multiplatformAIappsthatrunon-device. But although significant progress has been made in bringing inference to consumer devices, text generation alone is only one part of the pipeline that makes modern AI useful.    Bringing search to edge AI   RAG (retrieval-augmented generation) is what equips AI to import and process contextual information to enhance its output. Instead of language models relying solely on their training  data to answer questions, RAG lets them answer using a specific set of documents.    Implementing RAG into an AI app incurs significant memory overhead versus running a

Read More »

DCF Video: CoolIT’s 3 MW CDU Brings Smart Monitoring and Fanless Cooling to AI Infrastructure

As AI infrastructure moves toward higher rack densities and increasingly liquid-cooled architectures, the next challenge is not simply removing more heat. It’s ensuring that the cooling systems themselves remain reliable, efficient, and capable of protecting increasingly valuable computing hardware. At the 2026 OCP Global Summit in San Jose, CoolIT Systems Director of Marketing Charles Robison gave Data Center Frontier a close-up look at several technologies addressing that challenge, including the company’s new 3-megawatt CHx 3000 coolant distribution unit (CDU), integrated coolant health monitoring, and a fifth-generation cold plate loop designed for fanless servers. The demonstration comes at a significant moment for CoolIT, which was acquired by Ecolab for approximately $4.75 billion in July 2026. On November 16, Ecolab formally introduced its new integrated AI cooling platform at SC26 in Chicago, placing the CHx 3000 and its embedded 3D TRASAR technology at the center of a broader strategy combining liquid cooling hardware, fluid management, and digital monitoring. Looking Inside the CHx 3000 The CoolIT CHx 3000 is a liquid-to-liquid CDU rated for 3 MW of cooling capacity at a 3°C approach temperature difference, with a specified flow rate of 4,500 liters per minute. Designed for high-density AI deployments, the unit incorporates Ecolab’s 3D TRASAR technology to continuously monitor the condition of the circulating coolant. In the video, Robison points directly to the sensor array that makes the integration possible. “3D TRASAR, and you can see the array of sensors here, allows coolant health monitoring,” Robison explains. “It allows people to see real-time what’s going on with the coolant. So before it goes out of spec, they know what’s happening and they can address it.” The distinction is important. Traditional cooling monitoring typically emphasizes temperature, pressure, and flow. Ecolab’s technology adds visibility into fluid chemistry and contamination, allowing operators to identify deteriorating

Read More »

Beyond Announced Megawatts: Metlen’s Lillian Kasa on Delivering AI Infrastructure

For an industry racing to build infrastructure at unprecedented scale, the most consequential question may no longer be how many megawatts can be announced. It is how many can actually be delivered—and which projects deserve the investment required to get there. As hyperscalers, neoclouds, and data center developers assemble increasingly ambitious capacity pipelines, the distinction between potential and execution has become central to the economics of AI infrastructure. Announcements routinely involve hundreds of megawatts or gigawatts. But behind those numbers lie unresolved questions about power availability, equipment procurement, customer commitments, construction schedules, and financing. For Lillian Kasa, Head of Energy and Data Center Infrastructure Origination for North America at Metlen, these are not simply obstacles to be overcome in pursuit of speed. They are the fundamental questions that determine whether an infrastructure opportunity is worth developing in the first place. In a new episode of the Data Center Frontier Show, Kasa joined DCF Editor in Chief Matt Vincent to examine how developers can distinguish viable projects from speculative pipelines, allocate capital under uncertainty, and build commercial structures capable of supporting the next generation of AI computing infrastructure. The conversation follows Kasa’s participation at September’s Data Centre West conference in Calgary, where she moderated a panel on Solving for Power. As DCF reported in its Data Centre West 2026 conference analysis, the industry is increasingly discovering that power availability and delivery certainty—not simply land or market demand—determine which projects can proceed. Kasa brings an additional perspective to that conversation: years spent in offshore oil and gas exploration, where capital-intensive investment decisions must routinely be made with incomplete information. Her argument is that AI infrastructure development can benefit from much the same discipline. The Difference Between Announcing Power and Delivering It “When I hear an announcement involving hundreds of megawatts or gigawatts,

Read More »

Arista expands its routing options to support secure AI inferencing

Arista is unveiling a portfolio of networking devices designed to secure and improve the performance and resiliency of connections serving AI compute and storage infrastructure. Four new Etherlink R4 high-performance routing switches are aimed at large-scale distributed data center, AI back-end, and service provider environments where high route scale, deep packet buffering, and 400G connectivity are required. In addition, the new R4s integrate line-rate encryption into every port via TunnelSec, including MACsec, IPsec, VXLANsec, and hardware-based Segment Routing over IPv6, according to a blog post co-authored by Brendan Gibbs, Arista vice president, product line management, and Tyson Lamoreaux, senior vice president, Cloud/AI. All run Arista’s Extensible Operating System, or EOS. “The initial phase of artificial intelligence (AI) buildouts concentrated compute nodes in massive, centralized clusters, but the need for greater scale has led operators to span training clusters across multiple data centers with AI scale-across solutions. Now, the operational reality of centralized inferencing has emerged as the new frontier requiring a distributed solution,” Gibbs and Lamoreaux wrote. “Training can tolerate being tucked away near remote power grids, while inferencing cannot. As AI transitions from static prompts to real-time interaction, intelligence must be distributed across front-end networks spanning distinct geographies, regional hubs, and enterprise perimeters.”

Read More »

You’ve decided to repatriate cloud workloads. Now what?

Advice for IT Pros Repatriation is the market correcting a decade of poor placement decisions. That’s healthy, but the burden of getting it right falls on network, I&O, and data center teams. If you’re facing a repatriation project, here’s where I would focus. Lock down capacity first. The single biggest mistake I see is treating space and power as a procurement detail to be sorted out after the business case is approved. With vacancy at historic lows in the major markets and most new construction spoken for before it’s finished, that order of operations no longer works. Engage colocation providers and your own facilities team as early as possible, and be prepared to consider secondary markets, smaller footprints spread across multiple sites, or upgrading an existing owned facility. Get firm answers on power per rack, cooling options, cross-connect availability, and delivery dates before committing to a migration timeline. In many markets, the lead time for space and power can be longer than the migration itself. Design the network for a hybrid end state. Repatriation doesn’t end with a clean break from the cloud; it ends with more locations that must work as one. Treat interconnects, cloud on-ramps, WAN, data center fabric, segmentation, and security policy as a single architecture spanning on-prem, colo, and multiple clouds. That means sizing interconnect bandwidth for actual data flows rather than estimates, enforcing consistent policy regardless of where a workload runs, and building in visibility to troubleshoot an application path that spans three environments. If the network is designed as an afterthought, latency and integration problems that already plague many organizations will worsen. Plan AI infrastructure explicitly. If AI inference or fine-tuning is part of the repatriation plan, treat it as a separate project. GPU clusters introduce power density, cooling, and networking requirements that are

Read More »

Data center boom faces challenges beyond water and power

According to a report published by BBC Science Focus, the United States had more than 4,000 data centers by the end of 2025, representing approximately 50 gigawatts of capacity. Meanwhile, U.S. data centers consumed approximately 66 billion liters of water in 2023, highlighting the substantial environmental footprint of the industry. These resource requirements have driven considerable opposition to new developments. A recent NBC News poll cited by the publication found that 69% of respondents would oppose construction of an AI data center in their neighborhoods. This is reflected in the recent elections, where pro-data center candidates lost badly while those who publicly opposed for the construction of data centers did well at the ballot box. Data centers can provide economic benefits to the communities where they operate, including increased property tax revenues, permanent employment and infrastructure improvements. Developers sometimes finance upgrades to electrical substations, roads and emergency services to accommodate their facilities.

Read More »

Microsoft will invest $80B in AI data centers in fiscal 2025

And Microsoft isn’t the only one that is ramping up its investments into AI-enabled data centers. Rival cloud service providers are all investing in either upgrading or opening new data centers to capture a larger chunk of business from developers and users of large language models (LLMs).  In a report published in October 2024, Bloomberg Intelligence estimated that demand for generative AI would push Microsoft, AWS, Google, Oracle, Meta, and Apple would between them devote $200 billion to capex in 2025, up from $110 billion in 2023. Microsoft is one of the biggest spenders, followed closely by Google and AWS, Bloomberg Intelligence said. Its estimate of Microsoft’s capital spending on AI, at $62.4 billion for calendar 2025, is lower than Smith’s claim that the company will invest $80 billion in the fiscal year to June 30, 2025. Both figures, though, are way higher than Microsoft’s 2020 capital expenditure of “just” $17.6 billion. The majority of the increased spending is tied to cloud services and the expansion of AI infrastructure needed to provide compute capacity for OpenAI workloads. Separately, last October Amazon CEO Andy Jassy said his company planned total capex spend of $75 billion in 2024 and even more in 2025, with much of it going to AWS, its cloud computing division.

Read More »

John Deere unveils more autonomous farm machines to address skill labor shortage

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More Self-driving tractors might be the path to self-driving cars. John Deere has revealed a new line of autonomous machines and tech across agriculture, construction and commercial landscaping. The Moline, Illinois-based John Deere has been in business for 187 years, yet it’s been a regular as a non-tech company showing off technology at the big tech trade show in Las Vegas and is back at CES 2025 with more autonomous tractors and other vehicles. This is not something we usually cover, but John Deere has a lot of data that is interesting in the big picture of tech. The message from the company is that there aren’t enough skilled farm laborers to do the work that its customers need. It’s been a challenge for most of the last two decades, said Jahmy Hindman, CTO at John Deere, in a briefing. Much of the tech will come this fall and after that. He noted that the average farmer in the U.S. is over 58 and works 12 to 18 hours a day to grow food for us. And he said the American Farm Bureau Federation estimates there are roughly 2.4 million farm jobs that need to be filled annually; and the agricultural work force continues to shrink. (This is my hint to the anti-immigration crowd). John Deere’s autonomous 9RX Tractor. Farmers can oversee it using an app. While each of these industries experiences their own set of challenges, a commonality across all is skilled labor availability. In construction, about 80% percent of contractors struggle to find skilled labor. And in commercial landscaping, 86% of landscaping business owners can’t find labor to fill open positions, he said. “They have to figure out how to do

Read More »

2025 playbook for enterprise AI success, from agents to evals

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More 2025 is poised to be a pivotal year for enterprise AI. The past year has seen rapid innovation, and this year will see the same. This has made it more critical than ever to revisit your AI strategy to stay competitive and create value for your customers. From scaling AI agents to optimizing costs, here are the five critical areas enterprises should prioritize for their AI strategy this year. 1. Agents: the next generation of automation AI agents are no longer theoretical. In 2025, they’re indispensable tools for enterprises looking to streamline operations and enhance customer interactions. Unlike traditional software, agents powered by large language models (LLMs) can make nuanced decisions, navigate complex multi-step tasks, and integrate seamlessly with tools and APIs. At the start of 2024, agents were not ready for prime time, making frustrating mistakes like hallucinating URLs. They started getting better as frontier large language models themselves improved. “Let me put it this way,” said Sam Witteveen, cofounder of Red Dragon, a company that develops agents for companies, and that recently reviewed the 48 agents it built last year. “Interestingly, the ones that we built at the start of the year, a lot of those worked way better at the end of the year just because the models got better.” Witteveen shared this in the video podcast we filmed to discuss these five big trends in detail. Models are getting better and hallucinating less, and they’re also being trained to do agentic tasks. Another feature that the model providers are researching is a way to use the LLM as a judge, and as models get cheaper (something we’ll cover below), companies can use three or more models to

Read More »

OpenAI’s red teaming innovations define new essentials for security leaders in the AI era

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More OpenAI has taken a more aggressive approach to red teaming than its AI competitors, demonstrating its security teams’ advanced capabilities in two areas: multi-step reinforcement and external red teaming. OpenAI recently released two papers that set a new competitive standard for improving the quality, reliability and safety of AI models in these two techniques and more. The first paper, “OpenAI’s Approach to External Red Teaming for AI Models and Systems,” reports that specialized teams outside the company have proven effective in uncovering vulnerabilities that might otherwise have made it into a released model because in-house testing techniques may have missed them. In the second paper, “Diverse and Effective Red Teaming with Auto-Generated Rewards and Multi-Step Reinforcement Learning,” OpenAI introduces an automated framework that relies on iterative reinforcement learning to generate a broad spectrum of novel, wide-ranging attacks. Going all-in on red teaming pays practical, competitive dividends It’s encouraging to see competitive intensity in red teaming growing among AI companies. When Anthropic released its AI red team guidelines in June of last year, it joined AI providers including Google, Microsoft, Nvidia, OpenAI, and even the U.S.’s National Institute of Standards and Technology (NIST), which all had released red teaming frameworks. Investing heavily in red teaming yields tangible benefits for security leaders in any organization. OpenAI’s paper on external red teaming provides a detailed analysis of how the company strives to create specialized external teams that include cybersecurity and subject matter experts. The goal is to see if knowledgeable external teams can defeat models’ security perimeters and find gaps in their security, biases and controls that prompt-based testing couldn’t find. What makes OpenAI’s recent papers noteworthy is how well they define using human-in-the-middle

Read More »

Introducing Gemini 4 Neon

Delivers across enterprise, analytical, and scientific workEnterprise work lives in spreadsheets, PDFs, charts, audio, and video. Neon can synthesize across all of these inputs in

Read More »

Genie 4 is now available

The gallery also showcases inspiring collaborations with pioneering creators who had early access to these tools. Teaming up with creative technologist Will aka BLVCKL!GHT, we

Read More »