Read a Paradime State run

Every state-aware dbt run and dbt build ends with a Paradime State summary: what the run built, skipped, and cloned, and how much compute it saved. Find it at the end of the Bolt run logs and in the Code IDE terminal.

The summary

=========== Paradime State ===========
  command  : <command>
  executed : <count>  <nodes>
  skipped  : <count>  <nodes>
  state    : <seconds>s  (network time in the state layer)
  probe    : <seconds>s  (warehouse metadata, <calls> call(s), fetched in the background ...)
  cloned   : <count>  <nodes>
  precloned: <count>  <nodes>  (incrementals/snapshots)
  tests replayed from cache: <count>  (<failed> failed)
  not attempted (upstream failed): <count>  <nodes>
  compute saved (est.): <duration>
=============================================

Line	What it tells you	Shown
`command`	`run` or `build`.	Always
`executed`	The nodes built in this run.	Always
`skipped`	The nodes reused without running.	Always
`state`	Time spent talking to the state service.	When above zero
`probe`	Time spent reading warehouse metadata, which happens in the background, and how long nodes waited for it.	When metadata was read
`warning`	A metadata read took longer than 15 seconds (with a suggested fix), or DuckDB or MotherDuck sources have no freshness column.	When it applies
`cloned`	Tables copied from another environment instead of rebuilt.	When above zero
`precloned`	Incremental models and snapshots copied from the deferred environment before they built. See `pre_clone`.	When above zero
`tests replayed from cache`	Tests whose previous result was reused. Each replayed failure is listed as `FAIL (cached)` and still fails the run.	When above zero
`not attempted (upstream failed)`	Nodes that didn’t run because something upstream of them failed.	When above zero
`compute saved (est.)`	An estimate of the build time avoided, based on how long the skipped and cloned nodes took when they last built.	Always

What dbt™‘s own output shows

Paradime State only asks dbt™ to build the nodes that need it, so dbt™‘s own log lines cover those nodes and no others:

The project compiles first.
dbt™ then builds the nodes listed under executed. Clones show up as dbt clone output.
Skipped nodes don’t appear at all. When every node is skipped, dbt™ builds nothing, and the summary is the only record of the run.

Notices

When something affects the run, Paradime State prints a line that starts with paradime-state:. The most common:

The notice says	What happened
`proceeding without state optimization`	Paradime State couldn’t use its service for the rest of the run, so the remaining nodes built normally. The next run tries again.
`rejected this run as UNAUTHENTICATED`	The state service didn’t accept the run’s access. In the Code IDE, your access has expired: see The Code IDE stopped skipping after a day.
`no warehouse probe for adapter`	Your warehouse isn’t supported, so the run used plain dbt™.
`built instead of cloned`	A clone wasn’t possible for the listed nodes, so they were built. The notice says why.
`still pending after`	Warehouse metadata didn’t arrive within `PARADIME_STATE_PREBUILD_WAIT_S`, so the listed nodes built without it and rebuild on the next run.
`confirm(s) not delivered`	Some results weren’t recorded, so those nodes rebuild on the next run.
`another run had already advanced`	Another run changed the recorded state while this one was running, so some decisions may be conservative and build more than needed.
`--full-refresh`	How a full refresh interacts with Paradime State. See Force a rebuild.

Explain a run in the Code IDE

paradime-state explain shows why each node was skipped, cloned, or built in the last run you made in your Code IDE. Run it in the terminal, from your dbt™ project directory:

paradime-state explain                      # summary of your last run
paradime-state explain --node fct_orders    # one node's full decision trail
paradime-state explain --all --sort node    # every decision, skips included
paradime-state explain --json               # machine-readable output

By default you get a summary: the total for each decision with the compute it saved, the nodes that saved the most, and every node that was built or cloned, with the reason. Skips are counted rather than listed; add --all to list them.

Option	What it does
`--node <name>`	One node in full: its decision, the reason, the clone source, and each check along the way.
`-s`, `--select <node> ...`	Only these nodes.
`--decision SKIP`, `CLONE`, or `EXECUTE`	Only decisions of one kind.
`--sort saved`, `node`, or `decision`	Row order. The default, `saved`, lists the most compute saved first.
`--top <n>`	How many top savers to list. The default is 10.
`--all`	Every decision, skips included.
`-v`, `--verbose`	Every selected node in full.
`--json`	Machine-readable output, for scripts.

explain reads runs made in your own Code IDE. For Bolt runs, use the summary in the run logs.

Foundations

Automate with AI agents

Set up & configure

Orchestrate data pipelines

Optimize builds with Paradime State

Migrate to Paradime

Develop in Paradime

Learn dbt™

Read a Paradime State run

The summary

What dbt™‘s own output shows

Notices

Explain a run in the Code IDE

Next steps

Troubleshoot Paradime State

Configuration reference

​The summary

​What dbt™‘s own output shows

​Notices

​Explain a run in the Code IDE

​Next steps

Troubleshoot Paradime State

Configuration reference

The summary

What dbt™‘s own output shows

Notices

Explain a run in the Code IDE

Next steps