Pruna Cache Adaptive

The idea in one line

Most of a diffusion run is the model doing almost nothing. Late steps in particular change the image so little that you can throw the computation away and reconstruct it from the step before. Pruna Cache Adaptive watches how much the latent is actually moving and decides, prompt by prompt, which steps it can skip.

It's the same family of trick as TeaCache or First Block Cache, the free speedups people shove into Flux workflows. The difference is the decision rule: the threshold is measured against latent difference rather than a timestep embedding, and you choose how the skipped output gets reconstructed.

What it does to your graph

Wire it inline, exactly where the MODEL used to go: Load Checkpoint → Pruna Cache Adaptive → KSampler. The node clones your ModelPatcher, configures Pruna's caching, calls smash() on the diffusion model, and patches the cached module back in. Downstream is unchanged - same sampler, same steps, same scheduler. Only the internals got lazier.

The inputs that matter

• model - the MODEL wire.
• threshold - default 0.01, range 0.001–0.2. This is the quality dial. It's the difference between the current and previous latent that has to be exceeded before the step is actually computed; below it, the cached output is reused. Higher = faster, less accurate. The README's own SD 28-step benchmark nudged this to 0.02.
• max_skip_steps - default 4, range 1–5. A hard cap on consecutive skips so the sampler can't coast through half the trajectory on a stale value. This is your safety rail. If images go soft, this is the second knob to pull down after threshold.
• cache_mode - one of default, taylor, ab, bdf. default naively reuses the previous step's output. taylor reconstructs it with a Taylor expansion, ab and bdf use Adams-Bashforth and Backward Differentiation Formula respectively - i.e. they extrapolate where the sampler was heading instead of assuming it stopped. taylor is what Pruna used for their published benchmarks, so it's the sane starting point. The default is default, which is the crudest of the four - worth changing immediately.
• compiler - torch_compile, stable_fast, or none, default torch_compile. Yes, caching applies compilation on top. Set it to none if you only want the caching; set it to torch_compile if you want both and don't mind the flag below. stable_fast needs the pruna[stable-fast] extra installed.

Output is one MODEL, straight into the sampler.

The Pruna Pro gate

All three caching nodes need Pruna Pro. The caching engines are Pro-only, and the code says so in as many words:

ValueError: adaptive caching requires pruna_pro to be installed

That's not a broken install, it's a licence gate. And because compiler defaults to torch_compile, a caching node always touches compilation too, which means you always need the launch flag:

cd <path_to_comfyui> && python main.py --disable-cuda-malloc --gpu-only

Without --disable-cuda-malloc the README warns the nodes "may not function properly." Not optional.

Installing it

Manager: search "Pruna nodes for ComfyUI". Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/PrunaAI/ComfyUI_pruna.git

Then, from the README - the Pro package plus your token:

pip install pruna_pro==0.2.6
export PRUNA_TOKEN=<your_token_here>

The pack's own install.py installs pruna_pro and pruna[stable-fast] for you if Manager runs it. Restart ComfyUI afterwards. Only Linux with an NVIDIA GPU is supported, and the repo is explicitly unmaintained, so plan accordingly. For models: any SD checkpoint dropped into models/checkpoints works, and the Flux path needs clip_l.safetensors + t5xxl_fp16.safetensors in models/clip/, ae.safetensors in models/vae/, and the diffusion weights in models/diffusion_models/. The pack ships ready-made workflows under workflows/ - drag one into the window to skip the wiring.

Where you'll get burned

Step count is the whole ballgame. Caching wins by skipping steps; a model that only takes 8 of them has almost nothing to skip. Pruna's benchmarks are 50-step and 28-step runs, which is exactly the regime where this pays. If you're on a distilled Turbo/Lightning/Schnell checkpoint in 2026, the modern baseline is single-digit steps - measure the gain before you believe it, because the architecture world moved on and this pack didn't.

Crudest setting is the default. cache_mode: default plus compiler: torch_compile ships out of the box - worst-quality reconstruction mode, most fragile dependency. Set cache_mode: taylor and consider compiler: none for your first run so you can attribute artifacts to one change at a time.

Nobody in the community is running this. Search for the node and you find Pruna's own marketing and a couple of curious onlookers - not troubleshooting threads from users who hit your wall. TeaCache and First Block Cache have thousands of threads behind them. Worth knowing when you decide where to spend an evening.