Cloud Eval And Free Depth: Getting Deeper Analysis Without New Hardware

There is a persistent belief among improving players that their analysis is limited by their laptop. It isn’t. The gap between a 1400 and a 1900 has nothing to do with whether your engine reaches depth 30 or depth 45, and the money you were going to spend on a Ryzen upgrade would be better spent on a coach, a book, or nothing at all.

What actually limits you is that you don’t know what to ask the engine. You open a game, hit the analysis button, see a red blunder marker, nod, and close the tab. That process would produce identical results at depth 20 and depth 60.

So this piece is about getting deep evaluations for free, using infrastructure other people have already paid for, and then using those evaluations properly. Chess cloud analysis is not a compromise version of local analysis. For most positions you will ever look at, it is strictly better, because it’s the pooled output of thousands of machines running for a very long time.

What Lichess cloud eval actually is

When you open the analysis board on Lichess and the eval bar populates before you’ve clicked anything, you are not running Stockfish. You’re reading a cache.

Lichess stores engine evaluations for positions that have been analysed before. The cache holds tens of millions of positions, and it’s keyed by FEN, so it doesn’t care how you got there. Type in a position from a Kasparov game, a position from your blitz game last Tuesday, or a position you made up: if someone has analysed it, the eval is already sitting there.

The stored evals are typically depth 30 to depth 40 or better, and crucially they include multiple principal variations. Here’s a real cloud eval response for the position after 1.e4 e5 2.Nf3 Nc6 3.Bb5 a6 4.Ba4 Nf6 5.O-O Be7 6.Re1 b5 7.Bb3 d6 8.c3 O-O:

depth 41, knodes 11,453,271
pv1  +0.32  h3 Nb8 Nbd2 Nbd7 Bc2 c5 a4 c4 d4 cxd3
pv2  +0.30  a4 Bd7 axb5 axb5 Rxa8 Qxa8 d4 Re8
pv3  +0.28  d4 Bg4 Be3 exd4 cxd4 Na5 Bc2 Nc4

Three moves, three evaluations, within 0.04 of each other at depth 41. Your laptop running for ten minutes will tell you the same thing with less confidence.

You can query this directly. The endpoint is public and needs no authentication:

https://lichess.org/api/cloud-eval?fen=rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR%20b%20KQkq%20-%200%201&multiPv=3

The multiPv parameter is the useful bit. Ask for 3 or 5 lines and you get a ranked list rather than a single verdict. If the position is not in the cache, you get a 404, and that itself is information: an uncached position is usually one nobody plays, which for a sub-1900 opening repertoire question is worth knowing.

The 0.3 rule, and why depth stops mattering

Here’s the number that should reshape how you use engines. In practical play at club level, an evaluation difference of less than about 0.5 pawns is noise. Between 1000 and 1900, games are decided by two-pawn swings and hung pieces, not by whether the Sicilian Najdorf is +0.24 or +0.31.

Now consider how eval changes with depth. Take a normal middlegame position, something from a King’s Indian where White is pushing on the queenside. Run Stockfish 17 locally on four threads:

depth 18   +0.71   0.4s
depth 22   +0.64   1.9s
depth 26   +0.58   9s
depth 30   +0.61   47s
depth 34   +0.55   4m 10s
depth 38   +0.57   22m

Twenty-two minutes of compute to move the number by 0.14. Every doubling of depth costs roughly four to five times the time and buys you an eval shift smaller than the previous one. The move order in the PV may shuffle, but the top move at depth 22 is the top move at depth 38 in the overwhelming majority of quiet positions.

The exceptions are real and worth naming: sharp tactical positions with a long forcing sequence, fortress positions where the engine needs depth to see that nothing can be made of an extra piece, and some endgames. For those, cloud evals at depth 40 already have you covered, and tablebases cover the rest.

Tablebases: perfect, not deep

For any position with seven pieces or fewer including kings, the answer is known exactly. Not estimated. Known. The Lichess tablebase endpoint gives you distance-to-mate and distance-to-zeroing for every legal move:

https://tablebase.lichess.ovh/standard?fen=4k3/8/8/8/8/8/4P3/4K3_w_-_-_0_1

King and pawn versus king, and you’ll get back category: "win" with the winning moves ranked by DTM. No engine depth involved. If you are analysing your own endgames and you reached a six-piece position, stop running Stockfish and query the tablebase. It takes one request and it cannot be wrong.

This matters more than improvers realise. A huge fraction of decisive club games end in simplified endgames where the technique was available and missed. Those are exactly the positions where free, perfect analysis exists.

Free notebook compute when you genuinely need more

Sometimes you want to run something the cache can’t give you: a batch analysis of 300 of your own games, a deep look at a novelty you’re preparing, an eval sweep across a whole opening tree. That’s when notebook compute earns its place.

Google Colab gives you a free CPU runtime with 2 vCPUs and about 12GB of RAM, and sessions run up to roughly 12 hours (they can be reclaimed earlier). Kaggle Notebooks give you 4 CPU cores and 30 hours of guaranteed compute per week. Neither is fast per-core, but you’re running them in the background while you do something else, so wall-clock doesn’t matter the way it does when you’re staring at your own screen.

A working setup in Colab:

!wget -q https://github.com/official-stockfish/Stockfish/releases/latest/download/stockfish-ubuntu-x86-64-avx2.tar
!tar -xf stockfish-ubuntu-x86-64-avx2.tar
!pip -q install python-chess

import chess, chess.pgn, chess.engine

eng = chess.engine.SimpleEngine.popen_uci("stockfish/stockfish-ubuntu-x86-64-avx2")
eng.configure({"Threads": 4, "Hash": 2048})

with open("my_games.pgn") as f:
    while (game := chess.pgn.read_game(f)):
        board = game.board()
        prev = None
        for mv in game.mainline_moves():
            info = eng.analyse(board, chess.engine.Limit(depth=22))
            cur = info["score"].white().score(mate_score=10000)
            if prev is not None and abs(cur - prev) > 150:
                print(game.headers["Site"], board.fullmove_number, board.san(mv), prev, "->", cur)
            board.push(mv)
            prev = cur
eng.quit()

That script flags every move that swung the evaluation by more than 1.5 pawns. On 300 games it takes maybe two hours at depth 22 on a Kaggle notebook, and it hands you a list. Not a feeling that you “blunder in time trouble”, an actual list of positions with move numbers.

Note the Hash: 2048. Hash table size matters more than clock speed for analysis quality, and it’s free. Most people leave it at the default 16MB and then complain their engine is slow. If you have 16GB of RAM on your own machine, give Stockfish 4096MB and you’ve bought yourself several ply for nothing. The engine setup guide covers threads, hash, NNUE files and GUI configuration in detail, and it is the thing to read before you read a single benchmark chart.

Turning output into a training plan

Depth gets you numbers. A plan comes from categorising them. Take the blunder list your batch job produced and sort each entry into one of four buckets:

The point of the split is that these need completely different work. Puzzles do nothing for positional drift. More opening theory does nothing for endgame technique. Most improvers do the bucket they enjoy and wonder why the rating doesn’t move.

Run this over 50 games and you will usually find one bucket holds 40% or more of your lost evaluation. That’s your next three months.

Interrogating the engine instead of obeying it

One more habit, and it’s the one that separates people who improve from people who accumulate analysis. When the engine gives you a move, ask it a question back.

Set MultiPV to 4 and look at the spread. If the top four moves are +0.8, +0.75, +0.7 and +0.65, the position is not sharp and your choice mostly doesn’t matter. If they’re +1.2, -0.1, -0.3 and -0.6, there’s exactly one move and you need to know why. That gap is the single most useful number on the screen and almost nobody looks at it.

Then play your move on the board and let the eval update. The engine will show you the refutation as its PV. Follow that PV three or four moves in and ask what changed. Was it a tactic, or did your structure collapse? The answer is the lesson. The number was just the alarm.

Cloud evals give you all of this instantly, for free, at depth 40, for any position anyone has ever looked at. Your CPU is not the bottleneck. Your questions are.