Priced per committer, per year.

Every build your organization runs — local, CI, and AI-agent-triggered — lands here as a Build Scan, acknowledged on arrival and queryable within seconds. It persists that record without limit, on your own database or object storage, and serves it back through the UI, the Develocity API, and an export stream. It is the data tier the rest of the platform — Analytics, MCP, failure and performance views — reads from.

Flaky tests — ones that pass and fail under identical code and inputs — erode the CI signal and block builds for non-real reasons. Detection runs both within a single build and across builds that share an input fingerprint, catching flakes too rare to fail twice in one run. Teams can then quarantine known-flaky tests out of the gate without deleting them, and cross-build detection needs nothing to configure.

Every failure recorded in a Build Scan is grouped by root cause across your entire build history, so the same recurring fault collapses into one group a platform team can triage and track over time. Failures are classified as verification (compilation, test assertions) or non-verification (build config, infrastructure, environment), separating platform-owned reliability work from ordinary code fixes. Coverage spans local and CI builds alike.

Performance Insights reads the data every Build Scan already captures to show where build time and compute go, prove each optimization landed, and catch regressions before they harden. A single slow build breaks down to the task, dependency, or daemon behind it, while organization-wide dashboards aggregate the same data, filterable by build location and hardware. The gains it surfaces are independent of acceleration technologies like Universal Cache and Test Distribution.

MCP Servers let any AI agent that speaks the Model Context Protocol — Claude, Codex, and others — query your build data directly: Build Scans, test results, failure analysis, and organization-wide analytics. The depth is what sets the answers apart — every task, test, dependency, and cache decision captured at build time, which raw CI logs cannot reconstruct. The servers are read-only and run inside your own network, so build data never leaves it.

Even a correctly configured build misses the cache when a volatile input or stray path slips in, and tracing which miss matters takes scarce build-engineering time. This agent finds the most impactful avoidable misses in your Build Scan data, root-causes each, applies a minimum-change fix, re-validates it against a fresh build, and opens a pull request — then quantifies the build time it won back. Every finding cites the Build Scans behind it.

As an artifact moves through the delivery lifecycle, each gate produces signed facts, and any downstream gate reads that result instead of re-evaluating from scratch. When a security team, auditor, or AI agent asks whether an artifact cleared policy, the answer comes from signed facts that already exist. Lifecycle analytics surface delivery cycle times, release frequency, and dependency exposure across the organization.

Ask any question about an artifact's compliance — which dependencies it carries, whether it passed every gate, when it was last evaluated — and get an answer traced to signed records at each gate, not logs or scanners. Fact Connectors and Fact Evaluators extend those answers beyond the build to deployment events, ITSM tickets, and live vulnerability status. Your policies define what compliance means — increasingly required per-package by regulations like the EU Cyber Resilience Act.

Ephemeral CI agents re-download the same dependencies on every run — 20–40% of total build time at large enterprises. Artifact Cache serves them from a Develocity Edge on your LAN, so over 95% of artifacts resolve locally and only new versions reach upstream repositories. It runs as CI pre- and post-steps, leaving the build itself untouched.

Build Cache computes each compile or test result once, then reuses it across every agent and team whenever the inputs match exactly, so results stay correct at scale. One deployment spans every team and build tool. Because storage tracks distinct work rather than build count, CI spend stops climbing with volume — even as AI multiplies the builds hitting your pipelines.

A Gradle build recomputes its configuration phase — compiled build scripts, dependency accessors, generated jars, and shared buildSrc logic — on every run. Setup Cache restores those outputs from the Develocity Edge, typically cutting configuration time by about half, and runs as CI pre- and post-steps without touching the build. It is the Universal Cache component specific to Gradle, most effective alongside Artifact Cache.

A machine-learning model trained on your own build history scores every test against what a change actually touched, then runs only the relevant subset and skips the rest — recording why each test was selected or skipped. Test time scales with the size of the change rather than the size of the suite, so developer feedback stays fast even as AI drives test counts up.

Test Distribution fans a single Gradle or Maven build's test suite across a shared pool of remote agents, partitioned automatically by each test's historical run time. Nothing is rewritten or split by hand: the build returns one log, one coverage report, and one Build Scan, as if every test ran on one machine. Wall-clock time then tracks the size of the agent pool, not the size of the suite.