-
-
Landing Page
-
The problem
-
Native Integration
-
The resolved state after Rosetta runs.
-
How Rosetta works
-
1 - Harvest - Reads the full Datahub metadata graph: terms, schema, lineage, ownership
-
2 - Detect - Finds semantic conflicts where teams define the same metric differently
-
3 - Measure - Maps downstream blast radius across datasets, dashboards and AI models
-
4 - Reconcile - proposes a canonical definition - requires human approval before any change
-
5 - Write Back - upsets canonical GlosseryTerm to Datahub - links assets - depreciates old terms
-
Write Plan generated
-
Semantic Consistency Report
-
The technical diagram shows the full system: DataHub source → 5 agents → write-back.
-
Data Provenance
Inspiration
The most dangerous data problem is not always a wrong value.
Sometimes, it is a correct value with the wrong meaning.
Across an enterprise, two teams can use the same metric name while applying different definitions and business logic. Every pipeline can succeed. Every schema check can pass. Yet dashboards, reports, automated workflows, and AI models can still act on incompatible interpretations.
For humans, semantic drift creates reconciliation work, mistrusted dashboards, and governance debt.
For AI agents, it creates confident but incorrect decisions at scale.
As organizations give AI systems greater access to enterprise data and greater authority to act, unresolved meaning becomes an AI safety problem. An agent can retrieve the correct field, execute the correct query, and follow its instructions correctly, yet still reach the wrong conclusion because the organization never agreed on what the data means.
Existing tools can validate data quality and document definitions. But documentation alone does not reveal when definitions conflict, how far the conflict has spread, or what governed action should happen next.
We built Rosetta to close that gap.
Rosetta is a linter for meaning across the DataHub graph.
Because trustworthy AI requires more than valid data.
It requires shared meaning.
What it does
Rosetta detects conflicting definitions, explains why they matter, traces their impact through lineage, recommends a canonical meaning, and turns human agreement into a governed remediation plan.
Its five-agent workflow is:
- Harvester: Discovers definitions, ownership, and semantic context.
- Conflict Detector: Identifies terms that appear equivalent but carry incompatible meanings.
- Blast-Radius Analyzer: Follows DataHub lineage to find affected datasets, dashboards, models, and downstream systems.
- Reconciliation Broker: Compares competing definitions and recommends a canonical resolution.
- Writer: Prepares an auditable remediation plan for human approval, execution, and verification.
For every conflict, Rosetta shows:
- the competing meanings and why they are incompatible
- their sources and responsible owners
- the downstream assets exposed through lineage
- the recommended canonical definition
- the governed action required to resolve the conflict
Our healthcare proof scenario uses the official hackathon sample dataset published on GitHub, containing 55,500 synthetic patient records. It does not use real patient data, and the sample dataset is not represented as being hosted in DataHub.
One finding shows that billing_amount carries two incompatible meanings:
- Clinical: Total charges, including reversals
- Finance: Positive recognized revenue only
Rosetta makes the conflict visible, connects it to affected records and downstream assets, and generates a reviewable reconciliation plan.
Across the proof scenario, it demonstrates how hidden ambiguity can be converted into:
- Prevention: Catch semantic conflicts before AI systems scale them.
- Explainability: Show why competing meanings cannot safely be treated as equivalent.
- Impact awareness: Trace ambiguity through lineage rather than reviewing definitions in isolation.
- Accountability: Keep consequential changes under explicit human control.
- Reusable knowledge: Preserve resolved meaning for future people, analytics, and agents.
How we built it
We use DataHub as the operational context graph for metadata, definitions, ownership, and lineage. Rosetta adds a semantic consistency layer that reasons across that graph.
Rosetta supports two clearly separated operating modes:
- Demo Mode: Runs without credentials using a deterministic scenario based on the GitHub sample data. It generates findings and remediation plans, but labels them VALIDATED · NOT EXECUTED.
- Connected Mode: Reads metadata and lineage from a configured DataHub environment. Human-approved remediation plans can then be executed and verified through metadata read-back where supported.
The implementation combines:
- DataHub GraphQL and REST integration for metadata, glossary, ownership, and lineage
- MCP Server support so external agents can discover and use Rosetta's capabilities
- Agent Context Kit workflows for structured orchestration
- A deterministic five-agent pipeline for repeatable detection, analysis, reconciliation, and planning
Detection combines structured semantic rules with metadata, ownership, and lineage evidence, producing repeatable findings that reviewers can inspect. Rosetta evaluates signals such as units, aggregation logic, inclusion and exclusion rules, time windows, domain context, and downstream exposure.
Safety is built into the workflow:
- Demo Mode never presents a simulated write as executed.
- Connected Mode requires explicit human approval.
- Approval is bound to the exact proposed plan using a SHA-256 hash.
- A changed plan requires new approval.
- Executed changes are verified through metadata read-back where supported.
- Each stage produces evidence for review and audit.
Challenges we ran into
The hardest challenge was distinguishing genuine semantic conflict from harmless variation in language.
Different wording can express the same meaning, while nearly identical definitions can hide a consequential difference, such as whether refunds are included, which time window applies, or which aggregation is permitted.
We addressed this by combining semantic comparison with structured evidence, including ownership, units, aggregation rules, lineage, and inclusion or exclusion logic.
The second challenge was turning a definition disagreement into operational impact. A conflict matters because of what depends on it. DataHub lineage lets Rosetta show how ambiguity can propagate across datasets, dashboards, models, and AI consumers.
The third challenge was safe action. We did not want an autonomous agent silently rewriting organizational meaning. Our governing principle became:
The agent proposes. People decide. The system verifies.
Accomplishments that we're proud of
We built a working semantic-governance lifecycle:
detect → explain → trace → recommend → approve → execute → verify
Rosetta can:
- discover potentially equivalent business terms
- detect and explain incompatible definitions
- connect findings to reviewable evidence
- measure impact through DataHub lineage
- rank conflicts by severity and blast radius
- recommend a canonical definition
- identify responsible owners
- generate a structured remediation plan
- bind human approval to the exact plan
- distinguish validated simulation from execution
- verify supported metadata changes after execution
- expose its capabilities to other agents through MCP
We are especially proud that Rosetta does not treat governance as passive documentation. It makes meaning testable, impact visible, and remediation actionable.
Its contribution to Agents for Good is foundational:
Rosetta helps prevent AI systems from scaling unresolved ambiguity into confident, consequential decisions.
It is designed to support AI that is more explainable, accountable, privacy-conscious, and governed by people.
What we learned
The most dangerous AI failures are not always model failures. Sometimes the model works correctly, but the organization has supplied conflicting context.
DataHub gives an agent the graph it needs to understand where meaning lives, who owns it, and what depends on it. Rosetta turns that context into a semantic control loop.
We learned that trustworthy governance agents need:
- Evidence, so findings can be examined
- Lineage, so impact can be understood
- Human approval, so authority remains accountable
- Plan integrity, so approval cannot be reused for a changed action
- Verification, so the recorded outcome reflects what happened
Most importantly, we learned that semantic consistency is not merely a documentation concern.
It is infrastructure for trustworthy AI.
What's next for Rosetta — the Semantic Consistency Agent for DataHub
Next, we plan to add:
- continuous semantic monitoring as metadata changes
- pull-request-style review for definition updates
- policy-based approval routing
- richer unit and aggregation validation
- multilingual definition comparison
- confidence calibration and reviewer feedback
- expanded MCP workflows for external agents
- semantic consistency checks in data and AI release pipelines
Our long-term vision is for Rosetta to become a semantic safety layer for every system that depends on organizational data.
Before an AI agent answers a question, builds a report, recommends an action, or triggers a workflow, Rosetta should help ensure that the meaning behind the data is clear, consistent, and governed.
Data quality tells us whether the numbers are valid.
Rosetta helps ensure everyone agrees on what those numbers mean.
Log in or sign up for Devpost to join the conversation.