Build Scan

The foundational dataset Develocity captures — a wide, complete record of every build that every capability writes to and every tool, agent, and engineer reads from.

Try Build Scan Free Request a Demo

Feature overview

Build Scan

Build Scan is the foundation of Develocity — the dataset every build produces and everything else is built on. Develocity agents instrument every build from the inside, capturing the whole execution as a single wide event: every task and its inputs, every test outcome with its assertion and stack trace, the resolved dependency graph, every cache decision and the reason behind it, resource usage, and the full environment. Much of this exists nowhere else — cache keys, input fingerprints, and resolution decisions are computed inside the build and never reach a log. Every capability records its behavior here — caching, test distribution, failure analytics — and every surface built on it — the Observability Data Platform, Develocity Analytics, and your AI agents — reads from it.

Works great with

Metadata Enrichment

Data no log ever held — captured from inside the build

Captured from inside the build, not from logs — so it holds data that exists nowhere else: cache keys, input fingerprints, and resolution decisions no log can reconstruct.
Build Scan records timing, test outcomes with assertions and stack traces, the resolved dependency graph, cache decisions, CPU and memory usage, what triggered the build, and full environment.
The same semantically-rich structure on every build system — not each one's own log format, but one predictable model you build tooling, queries, and agents against once.
Captures local developer builds and CI builds alike — the same record covers the terminal and the pipeline, which is what makes shifting diagnosis left concrete.

Six build systems (Gradle, Maven, sbt, Bazel, npm, Python) pointing to one Build Scan structure that lists the events it captures every build — timeline, tasks, tests, dependency graph, cache decisions, cache keys, resource usage, build trigger, and environment.

From "something's wrong" to "this specific thing is wrong" — here's why

See dependencies added, removed, or version-bumped between builds — and whichever changed input flipped a cache key, re-ran a task, or caused a regression.
Compare switches and infrastructure — command-line flags, JVM, OS, and environment — to catch the configuration drift behind a build that behaves differently across machines.
Because the event is wide, you correlate across axes you never planned to query — the unknown-unknowns a fixed dashboard was never built to show.
And because those axes are high-cardinality, you isolate the exact commit, dependency, CI agent, or region — the specific value, not a bucket.

A Build Scan comparison of two builds, showing the dependency versions that changed between them highlighted side by side.

Not just a record — a platform for capturing more

Build Scan both records what happened and lets you extend it — attach custom values and tags to capture context the build tool can't know on its own.
Tag any build with branch, pull-request number, pipeline, or feature flag — making the whole corpus searchable and correlatable across your organization.
Because instrumentation is programmatic, agents and tooling can enrich a build non-intrusively — gathering the extra signal an investigation needs without changing the build itself.

Build logic and a command-line invocation attaching tags (CI, Linux, PR_1234) and custom values (Build Type, buildNumber) to a Build Scan.

Observability

The foundation the whole organization is observed through

Every build lands in the Observability Data Platform and becomes cross-build views of performance, failures, and tests in Develocity Analytics — spanning every team, project, and build tool.
One build in full detail or the whole organization in aggregate — the same Build Scan data, read at two resolutions.
Patterns across thousands of builds surface where to look before the cost lands in everyone's feedback loop — the regression no single build makes obvious.
Querying that corpus over time is its own discipline — Develocity Analytics turns Build Scan history into time-series trends and prebuilt dashboards over months of builds.

An organization-wide Develocity dashboard rolling up Build Scan data — total projects, Build Cache hits, and realized build-cache time savings, broken down by build tool.

Agent Context

Built for human observability — ideal for AI agents

Build Scan was designed for human observability; the same properties — wide, high-cardinality, semantically rich events — make it the data model an AI agent needs.
The Develocity MCP server exposes Build Scan data over Model Context Protocol — an agent can fetch a build, compare two, and list test results, the way an engineer would.
An agent reads focused, typed events — outcomes, cache keys, failure causes — instead of sifting megabytes of console output for the few lines that matter.
It can pull a failing build, compare it to the last green one, and read the exact input that broke it — the whole investigation loop, run unattended.