Context Engineering

Turn every build, test, and dependency into structured context, then let humans and AI agents reason and act on it — the context engineering layer between your toolchain and the models working inside it.

Try Develocity Free Request a Demo

Feature overview

Context Engineering

Context Engineering is the Develocity capability that produces toolchain context, curates it to the problem at hand, and acts on the result. It composes three parts: the context layer — structured Develocity records (Build Scan, Policy Scan, and Provenance) plus encoded build-system expertise, queried as a system model, not as logs; the agents — Develocity Agents that identify what to fix across every project, fix it as a verified change, and observe the result; and the interfaces where humans verify, override, and steer. A frontier model on raw logs reasons heuristically over free text; the same model against these structured records queries explicit entities and relationships. Models commoditize; context does not. From the customer's stack, Develocity is the context engineering layer for AI-driven software delivery.

Structured evidence agents query — not logs they have to parse

The substrate is structured Develocity records — not logs — from every build, local and CI: Build Scan for the build, Policy Scan and Provenance for the artifact.
Encoded build-system expertise — Agent Skills and validated query patterns — tells an agent where to look and how to interpret what it finds: decades of knowledge made executable.
Model Context Protocol (MCP) servers expose these records as structured queries against a pre-modeled schema — so agents call for fields, not parse logs.
The substrate spans one build to all of history — each build landing live in the Observability Data Platform, Develocity Analytics trending patterns over time.

A coding agent querying the Develocity MCP server — get_build and compare_builds return a typed test-failure assertion and the one changed dependency input, citing the Build Scan, read as structured fields rather than parsed from logs.

Every agent runs one loop — identify, fix, observe — grounded in the context layer

Identify — the hard part, and the differentiator: which projects to fix first, then root-cause each from structured Build Scan and Policy Scan data.
Fix — the agent turns the diagnosis into a verified change, applies it the way that fits — a pull request or a change-control hand-off — and confirms it worked.
Observe — each agent's impact is recorded and tracked over time, so a one-time fix becomes ongoing protection, measured rather than assumed.
Develocity Agents is the agent tier that runs this loop across every project.

A Develocity agent — the Build Caching Optimizer — run report: 3 issues found and all 3 fixed, build time 1m10s to 12.4s, with a before/after table and findings traced to tasks.

The layer between your toolchain and your agents

Develocity engineers the toolchain context that models and runtimes need — from structured records and encoded Skills — and acts on it.
Not a 'Context Engineering Platform': that category sells embeddings, retrievers, and Retrieval-Augmented Generation (RAG) pipelines for others to engineer context over their own data.
Not a model and not an agent runtime: both commoditize. An agent's competence on the toolchain — the structured substrate and the encoded Skills — is what Develocity owns.

The customer's AI stack as four layers: AI models, AI agents (the runtime), the context engineering layer (Develocity, highlighted), and the toolchain.

Two assets no model and no parser can backfill

Data superiority: Build Scans, Policy Scans, and provenance hold what logs don't — input hashes, cache keys, task-avoidance decisions, policy outcomes, lineage — explicit entities, not reconstructed text.
Knowledge superiority: build-system expertise from the creators of Gradle, encoded as Agent Skills — depth a community parser or public training corpus cannot replicate.
The advantage compounds, not commoditizes: every build deepens the structured record, so the lead over commodity AI widens as the data grows.

Two assets behind Context Engineering — structured Develocity records and encoded build-system expertise — resting on a foundation of agent competence on the toolchain that no model or parser can backfill.

Citable, overridable, and under your control

Every insight and action cites the evidence behind it — a Build Scan field or Policy Scan result — so the verdict is bound to cited data, not model confidence.
Humans stay on the loop, not in it: sample, gate by policy, and override on a confidence threshold as agents produce change faster than review can absorb.
The interfaces — Build Scan, the Observability Data Platform, and IDE integration — are where engineers verify, override, and steer what the substrate and the agents produce.
Your toolchain data stays governed by your controls — agents run on your keys and write only through an audited surface, wherever Develocity is deployed. See Security & Compliance.