Data Change Impact Commander

An agent that follows schema changes through DataHub lineage and stops risky write-backs before they break downstream data.

Comment

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Data Change Impact Commander

Short description

A guarded DataHub agent that traces a proposed schema change through real lineage, checks owner coverage, produces a SAFE, REVIEW, or BLOCK decision, and writes the evidence back to the affected asset.

The problem I wanted to fix

A schema request can look tiny in a ticket: rename one field, make another required, ship it on Friday. The hard part is finding everything downstream that quietly depends on those fields and knowing who needs to act.

I built Data Change Impact Commander to turn that detective work into one repeatable review. It uses DataHub as the source of truth, follows the blast radius, finds owners and gaps, and leaves a decision record in the catalog instead of losing the reasoning in a chat window.

What it does

The demo reviews a change to finance.raw_transactions:

  • rename transaction_amount to amount;
  • make the currently nullable currency_code required.

The agent finds the actual dataset in DataHub, reads its schema, traces downstream lineage, and discovers five affected assets across reporting and fraud-risk paths. Two risk assets have no owner. The guarded policy therefore returns BLOCK, creates an owner-by-owner action list, and appends one idempotent review record to the source asset's description.

The agent does not modify schemas, lineage, owners, tags, or business data.

How I built it

  • Open-source DataHub Core provides the metadata graph.
  • DataHub Agent Context Kit exposes search, schema, entity, lineage, and description tools.
  • LangGraph runs the tool-using review loop.
  • Qwen2.5 3B runs locally through Docker Model Runner.
  • A deterministic policy layer computes the minimum safe decision from live lineage, breaking operations, and owner coverage.
  • Python seeds a six-asset synthetic finance graph and verifies the scenario.

The entire model path is local. No hosted-model API key or paid inference service is used.

The difficult part

The first local-model run taught me the most important lesson in this project: model prose is not a safety control. It called a breaking rename SAFE and missed an ownerless risk path.

I restored the bad write, reduced the model's tool surface to five focused operations, and moved the final classification into a deterministic guardrail. Now a breaking change with downstream consumers cannot be SAFE, and a breaking change that reaches an ownerless production asset must be BLOCK. The write-back is also idempotent by change ID.

That failure made the project much stronger and much closer to something a real data platform team could trust.

What I am proud of

  • The demo uses DataHub for the full read, reason, act, and write-back loop.
  • The stored result names five downstream assets and the exact ownership gaps.
  • The synthetic metadata is truthful: currency_code is explicitly nullable.
  • Re-running CHG-2026-001 cannot create duplicate review records.
  • Nine unit tests cover local-only model configuration and decision guardrails.
  • The repository includes complete setup instructions and verified sample output.

What I learned

Good agent design is not just about giving a model more tools. It is about deciding which judgments belong to the model and which require hard, inspectable rules.

DataHub made that separation possible. The model can investigate a rich context graph, while the policy layer can make a reproducible decision from the same lineage and ownership evidence.

What comes next

I want to add field-level migration plans, compatibility-window tracking, and review acknowledgements from downstream owners. I would also like to turn the guardrail pattern into a reusable DataHub skill so teams can apply their own change policies without rewriting the agent.

Built with

DataHub Core, DataHub Agent Context Kit, LangGraph, Python, Qwen2.5, Docker Model Runner, LangChain, Docker

Judge testing instructions

  1. Clone the public repository on a Windows machine with Docker Desktop.
  2. Follow the README to start DataHub and install the local model.
  3. Copy .env.example to .env.
  4. Run python scripts/seed_demo.py --apply.
  5. Run python agent.py.
  6. Open http://localhost:9002, sign in to the local quickstart, and inspect Raw Transactions.
  7. Confirm that its description contains one CHG-2026-001 record with Decision: BLOCK and five downstream assets.

For a fast review without running the model, see examples/sample-run.md.

Pre-existing work disclosure

The project began from the public DataHub Agent Starter by Lakshay Nasa. Its MIT license notice is preserved in THIRD_PARTY_NOTICES.md. The impact-review scenario, local-model path, synthetic finance graph, deterministic guardrails, tests, documentation, and demo materials were built for this hackathon.

Built With

  • datahub-agent-context-kit
  • datahub-core
  • docker
  • docker-model-runner
  • langchain
  • langgraph
  • python
  • qwen2.5
Share this project:

Updates