-
-
How It Works — DataHub Context Through the Deterministic Governance Gate
-
Governed Context Agent — Deterministic Governance Before Agent Action
-
Governed Context Agent — Deterministic Governance Before Agent Action
Inspiration
The idea started from a simple problem I kept coming back to while working with AI agents:
Finding information is not the same as knowing whether that information is still safe to rely on.
An agent can retrieve a document, decision, or project state perfectly and still make the wrong decision if that context has been superseded, conflicts with another controlling source, is only historical, or simply cannot be resolved with enough authority.
Most agents ask:
“What does my context say?”
I wanted to add a second question:
“Is this context still authoritative enough to support action?”
That became Governed Context Agent.
What it does
Governed Context Agent puts a deterministic governance boundary between retrieved context and what an agent may do next.
DataHub provides the governed context, provenance, relationships, and persistence layer. The system retrieves the relevant evidence for a target asset and verifies the source set and provenance.
The deterministic Governed Core then evaluates whether that context is eligible to support action.
The demo uses the same governed pipeline to produce four outcomes:
CURRENT → PROPOSAL
Current controlling context can support a non-canonical proposal.
SUPERSEDED → BLOCK
The information exists and may once have been correct, but a newer controlling source has superseded it. The old context is blocked from supporting action.
CONFLICT_OPEN → HUMAN REVIEW
Relevant controlling claims remain incompatible. Instead of choosing the most convenient answer, the system requires human review.
UNRESOLVED → ABSTAIN
The evidence set is verified complete, but the governed context still cannot resolve the action safely. The system abstains instead of guessing.
The important boundary is simple:
The agent may propose. The deterministic Governed Core decides whether the context is eligible to support action.
How we built it
We deliberately kept the hackathon scope narrow.
Instead of building a generic chatbot, RAG application, or multi-agent platform, we built one complete vertical slice:
User request → DataHub context → proposed action → authority and provenance checks → reconciliation → deterministic governance gate → governed outcome → DataHub write-back and read-back verification
DataHub is an essential part of that flow.
It is used to represent and retrieve the governed asset context and evidence references, preserve provenance and relationships, and persist the resulting advisory decision proposal.
The governance decision itself remains deterministic.
The Governed Core controls authority, provenance, supersession, conflicts, and final eligibility to support action. DataHub does not become the authority engine.
The result is written back to DataHub as a non-canonical advisory proposal and then read back again for verification.
The demo uses synthetic, non-operational data and a frozen governance core so that the four states can be demonstrated reproducibly.
Challenges we ran into
The hardest part was not retrieving context.
The harder problem was proving exactly what the agent was allowed to trust.
We had to work through questions such as:
- Is the retrieved evidence set complete?
- Which source is actually controlling?
- Has a valid source been superseded?
- What happens when two controlling claims conflict?
- What happens when retrieval is complete but the available authority still cannot resolve the action?
- Can an AI-generated output accidentally promote itself into new authority?
- Can the final result be written to DataHub and read back exactly without changing its authority?
We also treated provenance and reproducibility as part of the engineering problem.
The final public repository separates pre-existing work, the frozen deterministic governance core, and DataHub-specific hackathon work. The demo data is synthetic, and the public release was verified from a fresh clone.
During the final demo work we also encountered practical integration issues around local DataHub state and evidence-document serialization. The important part was that the governance path failed closed instead of silently continuing with malformed context.
Accomplishments that we're proud of
The biggest accomplishment is that the final demo does not need four custom decision paths.
One governed pipeline produces all four outcomes.
CURRENT → PROPOSAL
SUPERSEDED → BLOCK
CONFLICT_OPEN → HUMAN REVIEW
UNRESOLVED → ABSTAIN
The same deterministic Governed Core controls all four.
We are also proud that:
- DataHub is part of the real end-to-end flow rather than just a visual layer.
- governed evidence is retrieved with provenance;
- results are written back to DataHub and read back for verification;
- the agent cannot promote its own proposal into governing authority;
- the Frozen Core remains integrity-checked;
- the public repository is reproducible from a clean environment;
- the project uses synthetic, non-operational data;
- the system can deliberately refuse to proceed when governance conditions are not satisfied.
For us, BLOCK, HUMAN REVIEW, and ABSTAIN are not failure states. They are successful governance outcomes when proceeding would not be justified.
What we learned
The biggest lesson was that more context does not automatically create a safer agent.
Complete retrieval is also not the same thing as sufficient authority.
An agent can have all available evidence and still reach the correct conclusion:
I should not decide this.
We also learned that authority and provenance need to remain separate from AI interpretation.
AI can be useful for understanding a request, interpreting context, and proposing an action. But authority, supersession, conflicts, and final eligibility to support action are better treated as deterministic governance decisions that the AI cannot bypass.
A useful agent should therefore sometimes do less.
Sometimes the right outcome is to proceed with a proposal.
Sometimes it is to block.
Sometimes a human needs to decide.
And sometimes the safest result is to abstain.
What's next for Governed Context Agent
The hackathon version intentionally proves one narrow vertical slice.
The next step would be to generalize the governed-context model beyond the synthetic demo while keeping the same deterministic authority boundary.
Potential directions include additional governed asset types, richer provenance relationships, more reconciliation policies, clearer human-review workflows, and agent integrations that can consume the governance result before taking further action.
A future AI interpretation layer could help understand more complex requests and propose actions, while the deterministic governance gate would remain in control of whether the available context is eligible to support them.
The goal is not to replace DataHub, and it is not to build another generic agent platform.
The goal is much simpler:
An agent should not act just because it found an answer. It should first be able to determine whether the context behind that answer is still authoritative enough to support the action.
Log in or sign up for Devpost to join the conversation.