What if both players always play the worst engine move? There are questions for the worst opening in chess and the worst opening in Chess960, but these only consider the very first move. I'm curious what a game would look like where white plays the worst opening, black plays the worst possible response, white plays the worst response to that, and so on until the game concludes. After every move, the evaluation bar would shift in the opposite player's favor as much as possible, making for quite a wild ride presumably.
I imagine it would be possible to generate a game like this using the API for Stockfish or another engine.
(The idea is vaguely reminiscent of antichess, but it's different, because (1) captures would not be forced and (2) players would be evaluating all moves using min-max like in regular chess, and then choosing the worst option, whereas in antichess both players are anticipating that the other player will play the most-losing move.)
You may find this game interesting: https://lichess.org/A9ZRnDcE.
Here Stockfish (black) is programmed to select the move leading to the most negative eval position. White is a human who is aiming to lose (i.e.: be checkmated). White is ultimately successful, which goes to show that really playing to be checkmated is a variant in its own right - we could call it Misère chess - and simply playing negative eval moves, even the most negative eval moves, doesn't make one a good player of Misère chess.
The reason for this is that chess engine positional evaluation assumes the 'optimal' responses (as far as the engine can tell) for subsequent plies. If we were to choose the move most likely to lead to our own checkmate ('selfmate') given  both sides on every subsequent move will be doing the same (as opposed to the assumption both sides are playing optimally for checkmate), then we would have a Misère chess engine. I am not sure what the technical challenges involved in developing such would be, but they are likely to be substantial given how far behind the state-of-the-art in selfmate solvers is compared to even the on-the-fly mating capabilities of a standard modern engines.
Lastly to answer your initial question, regarding engines playing the lowest eval moves on both sides assuming current eval metrics, have a look at this paper: http://tom7.org/chess/weak.pdf. The algorithm WorstFish does exactly what you ask. Its results against itself and even slightly less bad players are almost entirely draws. Even a much less bad algorithm like a random mover rarely actually beats WorstFish! So I'm afraid the answer may not be as dramatic as you'd hoped: players just keep offering and rejecting offers of material until it becomes impossible to do so, before swiftly trading down into a drawn endgame.