The End of Schema Silos: Why We Built 13 Credential-Free Data-Estate Integrations

Every system in your data estate holds a fragment of what your data means — and none of them holds the whole. We built CoreModels to gather those fragments into one governed graph, and we did it without ever asking for a single password. Here's why that posture matters as much as the graph itself.

Your estate already knows what it means. It just can't say it in one place.

Look at where the meaning of a single concept — say, an order — actually lives in a modern estate. dbt knows how the orders model is built, which columns are tested, and what its contract promises downstream. Snowflake knows the physical types, the primary keys, and which objects depend on which. Salesforce knows the picklist of valid order statuses your sales team actually uses. Confluent Schema Registry knows the shape of the event that fires when an order is placed. Airflow knows which pipeline touches it and when. Airbyte knows how it lands. And if you work in research, REDCap and cBioPortal hold data dictionaries whose definitions were argued over for months.

Each of these is authoritative about its fragment. None can see the others. So the whole-estate picture lives in wikis, spreadsheets, and the heads of a few senior engineers — and it rots the moment someone renames a column. When a new engineer, an auditor, or an AI agent asks "what does this field actually mean, and who agrees?", there is no system of record to answer.

That's the silo problem. It isn't a storage or pipeline problem — it's a meaning problem, and it's why we built integrations for thirteen platforms: Airbyte, Apache Airflow, Google BigQuery, cBioPortal, Confluent Schema Registry, Databricks Unity Catalog, dbt, Microsoft Fabric, AWS Glue Data Catalog, Neo4j, REDCap, Salesforce, and Snowflake.

Why none of them asks for your credentials

Here is the design decision we get asked about most: not one of these thirteen integrations connects to your systems. CoreModels never holds your credentials. Ever.

Instead, every integration consumes artifacts your vendor tooling already produces, extracted by you, on your side of the fence. For dbt, that's the manifest that dbt parse writes on every build. For Databricks, Snowflake, BigQuery, and Fabric, it's the result of an information-schema query you run yourself and download. For Confluent, it's an export of your Schema Registry subjects. For Neo4j, the output of its schema introspection. For REDCap, the data dictionary CSV. For Salesforce, the object describe results. You produce the file; you can open it and read every byte before you send it.

We chose this posture deliberately, because it changes the trust conversation:

• There is no network path from CoreModels into your warehouse, your CRM, or your cluster. Nothing to firewall, no new inbound connection to review.
• There is no service account to provision, scope, rotate, or worry about. A common blocker to adopting a metadata tool — the security review of yet another credentialed connection — simply doesn't apply.
• The exchange is inspectable. An artifact is a file. Your security team can diff it, redact it, or gate it however they like.
• It works everywhere. Regulated environments, locked-down clinical systems, estates where a third-party connection would take a quarter to approve — an artifact upload works on day one.

A schema is knowledge, not access. We built the integrations to receive knowledge and nothing else.

Additive import, human-gated meaning

Credential-free covers how knowledge gets in. The second half of the trust story is what we're allowed to do with it once it arrives — and the answer is: less than you'd expect, on purpose.

Import is additive. When you import a dbt project or a Unity Catalog schema, CoreModels adds datasets, fields, and lineage to the graph. It never overwrites governed nodes your team has already curated. Re-importing is safe; the fragment enriches the graph, it doesn't bulldoze it.

Audit and generate never write. Auditing your estate against the governed model is strictly read-only. Generating artifacts from the model writes nothing to the graph. The verbs that observe cannot mutate.

Meaning changes go through humans. Where machine assistance exists, it proposes — it does not decide. Our ontology tooling can suggest ranked candidate terms from public ontology services, but the suggestions are advisory only; binding a term to a node is a separate, explicit, human-directed act. Our AI-assisted schema mapping can propose a mapping plan, but every plan — human-authored or AI-proposed — passes through the same validation gate before anything runs, and the AI's self-reported confidence is never trusted by that gate.

We call this additive import with human-gated meaning. It's the reason teams can point CoreModels at their whole estate without a change-control meeting: the graph accumulates knowledge freely, but the governed meaning — the part your organization stakes decisions on — only ever changes when a human with the right project role says so.

What one governed graph actually buys you

Once the fragments live in one graph, four things become possible that no single silo could do.

You can audit the estate against the model — continuously. Every integration can audit fresh artifacts against the governed graph and report coverage gaps, drift, and conformance issues: a field whose type drifted from the governed model, a dataset nobody has mapped, a public dbt model whose contract isn't enforced, a narrowed enum. Our GitHub Action runs this audit on pull requests, posts the report as a PR comment, and fails the build when errors are found — so a schema change that silently breaks governed meaning never merges. There's a status badge for your README, a history trail to watch drift over time, and a re-audit verb that checks the stored snapshot of your estate against the current model — so when the model evolves, you immediately see which systems just fell out of line.

You can generate the fragments back out. For most of the thirteen platforms — eleven of them today — the flow runs in reverse: the governed graph becomes the source, and vendor artifacts become outputs. Enforced dbt model contracts with tests and accepted values drawn from governed taxonomies. Databricks Delta DDL with keys and constraints. Registry-ready Avro schemas for Confluent. The model stops being documentation about your systems and starts being the thing your systems are built from.

Humans and agents consult the same source. The graph is exposed over the Model Context Protocol at an OAuth-protected /mcp endpoint, with read-only tools on the public surface: an agent can list projects, pull a project summary, search the graph, run the same schema audit your CI runs, or export the model in the format its task needs. Write-capable tools live on a separate admin surface and are gated by per-project roles. Your AI agents get the same answer your engineers get, from the same governed source — and they can't quietly rewrite it.

And you can reconcile across silos. When dbt and Snowflake each govern their own view of the same physical table, a reconcile operation links them as the same relation — so the graph knows it's one table with two vantage points, not two tables.

Honest about what doesn't fit

One more thing we refuse to do: pretend translation is free. Formats differ in what they can express, and any tool that moves schemas between them either hides that or reports it. CoreModels reports it. Every import, export, and transformation returns a lossiness ledger — a plain statement of what was dropped, approximated, relaxed, or narrowed, and why. If a target format can't represent a controlled vocabulary, we tell you exactly that, at exactly that path, instead of silently emitting something weaker and calling it success.

That honesty is the same philosophy as the credential-free posture and the human-gated writes, applied end to end: you should always know precisely what CoreModels received, what it changed, and what it couldn't carry. Trust isn't a feature you add to a metadata platform. It's the architecture.

Thirteen silos, one governed graph, zero credentials. Each integration ships with a quickstart that shows the exact extraction recipe for its artifacts — start with the system your team argues about most.

CoreModels is built by ARAMAI. See the integration quickstarts in our docs to run your first import and audit.