Governed Change Impact Agent (GCIA)

GCIA turns DataHub metadata changes into human-gated, evidence-backed actions by mapping downstream impact, revalidating risk, and proving outcomes without blind retries.

Comment

Inspiration

Metadata changes often look local but are not local in effect. A small change to one dataset can affect downstream datasets, charts, dashboards, owners, and migration decisions.

GCIA was built around a simple question: before changing metadata, can an agent understand the real blast radius, require an explicit Human decision, perform one bounded action, and then prove what actually happened?

What it does

Governed Change Impact Agent (GCIA) uses DataHub context to turn metadata change risk into a governed, evidence-backed workflow.

For the demo case GCIA_DEMO_001, GCIA binds to the exact order_details dataset and reads its DataHub context before action.

The verified downstream impact is:

  • 35 downstream assets
  • 20 datasets
  • 12 charts
  • 3 dashboards

Before any action, GCIA revalidates the exact target, baseline description hash, owner presence, duplicate-notice state, and complete lineage.

A Human approval boundary then controls whether the action may proceed.

The demonstrated action is intentionally narrow: one approved metadata-description append, dispatched once.

After the action, GCIA immediately reads the state back and produces deterministic proof. The demo reached:

  • CONFIRMED_SUCCESS
  • ACTION_CONFIRMED_STOP
  • notice count = 1
  • retry disabled

If an outcome is unknown, GCIA does not blindly retry. It first reconciles the actual state.

How we built it

GCIA is implemented in Python and uses DataHub OSS/Core together with the DataHub MCP Server for metadata context.

The project separates the workflow into bounded stages:

  1. exact target resolution
  2. owner, schema, and lineage readback
  3. downstream impact compilation
  4. Human decision gate
  5. pre-action revalidation
  6. one bounded metadata action
  7. post-action readback
  8. reconciliation and proof

The repository also includes a deterministic local evidence operator. It validates the confirmed runtime proof without performing another network call or live mutation.

Challenges

The hardest part was not sending an update. It was making the update governable.

We had to prevent several failure modes:

  • acting on stale metadata context
  • counting unrelated URNs as downstream impact
  • duplicate mutations
  • retrying after an uncertain transport result
  • confusing local evidence replay with a new live DataHub action
  • losing provenance between Human approval and post-action proof

These constraints shaped the architecture more than the mutation itself.

Accomplishments

We are especially proud that GCIA demonstrates an end-to-end governed change flow rather than only reading metadata.

The project:

  • uses DataHub lineage and ownership context
  • exposes the downstream blast radius before approval
  • keeps execution behind a Human gate
  • performs one bounded action
  • proves the resulting state
  • stops without blind retry
  • provides deterministic text and JSON evidence outputs
  • ships with a public Apache-2.0 repository and reproducible tests

What we learned

Metadata context becomes much more valuable when it is connected directly to the action boundary.

Lineage is not only useful for visualization. It can become part of an execution precondition.

We also learned that post-action proof matters as much as pre-action reasoning. An agent that cannot determine what actually happened should reconcile state before deciding what to do next.

What's next

The current prototype is intentionally narrow and evidence-first.

Future work could extend the same governed pattern to additional metadata changes, richer policy checks, and multi-user operational workflows while preserving the same core rule:

Understand impact before approval. Prove the outcome after action. No blind retries.

Disclosure

GCIA was built as a new hackathon project during the submission period. Existing general development tools, AI assistants, and prior governance concepts informed the design, while the submitted GCIA repository, implementation, tests, evidence operator, and hackathon demo workflow were created for this project.

Built With

Share this project:

Updates