--- title: "CoreModels — One connected core model of what your data means." description: "Warehouses and pipelines, APIs and event streams, ontologies and content models, published standards and the schemas you wrote yourself. A library of connectors, and one governed model your team edits and every agent reads." canonical: "https://www.coremodels.io/" last_updated: "2026-09-15" --- AI builds. Humans govern. Schemas connect both. # One connected core model of what your data means. Warehouses and pipelines, APIs and event streams, ontologies and content models, published standards and the schemas you wrote yourself. A library of connectors, and one governed model your team edits and every agent reads. [Get started](https://www.coremodels.io/pricing)[See all connectors](https://www.coremodels.io/connectors) 1. 1Step 1Connect your modelsCoreModels reads the structure you already publish — a dbt manifest, a warehouse catalogue, a JSON Schema, a schema.org vocabulary, the taxonomy or ontology your team maintains. Nothing to migrate, nothing to rebuild. Connect one, or connect them all. 2. 2Step 2Map it together, with AIThe joins, the equivalences, the relationships — CoreModels helps your AI infer them across every source. Your human team talks them over and commits in a shared workspace, with AI as collaborator. Integrated, accountable, decision-traced. 3. 3Step 3Point your agent at itClaude, Cursor, your own agents — they read the model and build from it. Assets, queries, reports, the daily work of the business. Coherent by construction. [dbt](https://www.coremodels.io/connector/dbt)[JSON Schema](https://www.coremodels.io/connector/jsonschema)[Snowflake](https://www.coremodels.io/connector/snowflake)[Salesforce](https://www.coremodels.io/connector/salesforce)[Google BigQuery](https://www.coremodels.io/connector/bigquery)[Databricks](https://www.coremodels.io/connector/databricks)[Confluent](https://www.coremodels.io/connector/confluent)[REDCap](https://www.coremodels.io/connector/redcap) [17 platforms · 10 formats · labelled for what you can do today →](https://www.coremodels.io/connectors) ## One model. Every system. Every agent. The meaning your business agreed on, written once and versioned — readable by every agent you run, across every system you own. When the model changes, everything reading it changes with it. [Start your 14-day trial](https://www.coremodels.io/pricing) ## Who this is for ### Data and pipeline teams A dbt manifest, a warehouse catalogue, an Airflow DAG. You already publish the structure; nobody has written down what it means where it meets the rest of the business. [Find your connector →](https://www.coremodels.io/connectors) ### Content, taxonomy and semantics teams A schema.org vocabulary, a SKOS taxonomy, the ontology your team maintains. The definitions are yours. CoreModels makes them the ones every agent reads. [Find your connector →](https://www.coremodels.io/connectors) ### API and integration teams A JSON Schema, a Protocol Buffers file, an Avro contract. The shape systems promise each other, governed once and mapped to what the business calls it. [Find your connector →](https://www.coremodels.io/connectors) ## Pricing A library of connectors. Simple pricing per builder, per team, or for the whole enterprise Solo work. Team evaluation. ### Builder $49/ month - 1 builder seat · up to 3 projects - Up to 100,000 nodes per model - Unlimited view-only collaborators Where teams build in production. ### Team $990/ month - 10 builder seats included · $99/month per additional seat · up to 10 projects - Up to 1,000,000 nodes per model - Unlimited view-only collaborators Founding teams: $11,880 $5,880 for the first year, billed annually — the equivalent of $490 / month · renews at $11,880 / year · first 10 teams · ends 30 September. [See the founding offer](https://www.coremodels.io/pricing#founding) No limits. Governed at scale. ### Enterprise from $4,000/ month - Unlimited projects, users & schema scale - SSO · SLA · private vaults - A named contact [See plans](https://www.coremodels.io/pricing) ## Want the whole picture? The CoreModels Solution Framework: what a core model is, where the methodology came from, why coherence is a capability, and how the platform is built. [Explore the framework](https://www.coremodels.io/framework) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "CoreModels Solution Framework | CoreModels" description: "How an organization keeps one connected core model of what its data means — across every system it runs and every agent it points at that data — and what CoreModels does to make that model real, governed, and readable at runtime." canonical: "https://coremodels.io/framework" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # One connected core model of what your data means — and the framework for keeping it. How an organization keeps one connected core model of what its data means — across every system it runs and every agent it points at that data — and what CoreModels does to make that model real, governed, and readable at runtime. The landing page says what CoreModels does in three steps: connect your models, map them together with AI, point your agent at the result. This framework is for the reader who wants the rest — what a core model actually is, where the idea came from, why it holds up in an enterprise that is filling with agents, how the platform is built, who it is for, and what it sits inside. Seven pages, in the order the argument runs. Each one stands on its own, so you can start where your question is. ## The seven pages 1. [01The Core ModelA core model is the one place your organization writes down what its data means, so every system and every agent can read it instead of guessing.](https://www.coremodels.io/framework/core-model) 2. [02CoherenceA request inherits terms the estate holds. Those terms are mapped to meaning across many uses. When the meaning survives every mapping, that is coherence — and it is a capability, not a value statement.](https://www.coremodels.io/framework/coherence) 3. [03Why CoreModelsYour systems already know what your data is. None of them knows what it means across the others. CoreModels holds each model as it is and keeps the mappings between them alive.](https://www.coremodels.io/framework/why) 4. [04How it worksConnect and ingest, model and map, collaborate and govern, expose and execute, adapt and scale — the mechanism behind the three steps on the landing page.](https://www.coremodels.io/framework/how-it-works) 5. [05CapabilitiesGraph-based modeling, adjustable meta-models, collaboration and suggestions, import-map-compare, precision editing, validation and governance, transformation across formats, and the agent endpoint.](https://www.coremodels.io/framework/capabilities) 6. [06Who it servesSix kinds of team keep meaning somewhere. One model lets them keep it together — data and pipeline, standards and ontology, API and interface, content and semantics, research and domain, business systems and contracts.](https://www.coremodels.io/framework/who) 7. [07The Schematica SuiteCoreModels is the engine. The Suite is what it powers: the Schematica Library, the MCP server, the design plugins — and the wider ecosystem of standards they connect to.](https://www.coremodels.io/framework/suite) ## The core model, in one paragraph A core model is the one place an organization writes down what its data means. It holds the types, elements, taxonomies and relationships an enterprise has already settled — in its warehouse and its pipelines, its APIs and event streams, its ontologies and content models, the published standards it follows and the schemas it wrote itself — virtualized into one canonical layer, and projected back out in whichever format each system or agent speaks. People edit it. Every agent reads it. When it changes, everything reading it changes with it. AI builds. Humans govern. Schemas connect both. The framework is the long form of that sentence. Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "The Core Model | CoreModels Solution Framework" description: "A core model is the one place your organization writes down what its data means, so every system and every agent can read it instead of guessing." canonical: "https://coremodels.io/framework/core-model" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # The Core Model A core model is the one place your organization writes down what its data means, so every system and every agent can read it instead of guessing. CoreModels virtualizes diverse schemas into a canonical type layer, then projects the exact types and elements each query needs — in whichever format the agent or the system speaks. That canonical layer is the core model. ## What it is Every enterprise already has a model of its business. It has several, in fact: the warehouse has one, the CRM has one, the content platform has one, the API contracts have one, the industry standard the compliance team follows has one. Each was settled by people who had good reasons, and each is expert in something the others cannot hold. The warehouse cannot hold what the content model knows about audience and sequence. The taxonomy cannot hold what the transformation code knows about lineage. The translation memory knows a term in twelve languages and nothing about which system is allowed to change it. A core model does not replace any of them. It holds each model as it is and keeps the mappings between them alive — which sense of a term applies at which seam, which system the business considers true for a given entity, and who is allowed to change each. It is not a fifth place where the definition lives, slightly differently again. It is the place where the correspondences are written down once and read every time. In CoreModels, one core model is a project: one governed model and everything in it — types, elements, taxonomies, mappings, versions, and the connectors that feed it. Most teams run one per domain or per source system, and map between them. ### The anatomy of a core model ### Types The things the business talks about — Customer, Encounter, Order, Article, Product — each defined once, with the constraints that make it that thing and not another. ### Elements The fields a type carries, with meaning attached: what a value denotes, which values are permitted, what an agent keeps getting wrong about it, and what it must never be used for. ### Taxonomies The controlled vocabularies and classification schemes the organization already maintains — status codes, audience tags, product hierarchies, subject headings — governed as first-class terms rather than strings. ### Relationships and mappings How a type sits in the model (parent, subtype, component) and how it corresponds to the same entity elsewhere: the join across systems, the equivalence across schemas, the mapping to a public standard. ### Versions Every change is a version. The model has a history, a diff, and a branch when a team needs to work ahead of what is published. Nothing is overwritten; everything is reviewable. ### Connectors The sources that feed the model and the formats it projects into — a dbt manifest, a warehouse catalog, a JSON Schema, an ontology. The model knows where each of its definitions came from. ### What it is not It is not a warehouse, a catalog, a metrics layer, a master-data system or a vector index. A catalog knows its tables. A metrics layer holds measures. A master-data system holds identity. A component content system holds components. A knowledge graph holds whatever someone loaded into it. Each is real and each stays in place. A core model sits below the catalog and across the systems, and it is written where a machine can read it — in the schema, not in prose about the schema. ## Where it came from CoreModels grew out of the Core Content Model®, a methodology developed by Cruce Saunders and the [A] senior content engineering team. It was developed initially to serve the needs of the Mayo Clinic, and expanded over many implementations with some of the largest enterprise publishers in the world. The problem it was built for predates language models by a long way. A large enterprise already holds its knowledge in many representations at once — a content model here, a data model there, a schema for each system, a format for each channel, a standard the industry expects it to conform to — and each was settled by different people for good reasons. The work at the Mayo Clinic was not, for the most part, designing a new content model. It was organizing what they already had, across all of those representations, into a core model: an abstraction layer that holds the existing models and the mappings between them. That is the whole point. Not a new model to maintain beside the others, but the layer that contains them — so a component means the same thing on the website, in the app, in the document a regulator receives, and in every format and standard it has to travel through. The methodology maps more than channels and systems. It maps formats, representational states and standards — the same entity as a FHIR resource, a warehouse table, a JSON Schema, a schema.org type and a taxonomy term, held together by typed correspondences rather than by anyone’s memory. Language models multiplied the handoffs and sped them up. The discipline that held meaning steady across channels now has to hold it across models, agents, warehouses, and everything they touch. CoreModels is that discipline turned into a platform: the methodology as a hosted modeling workspace where models are authored, governed, versioned and exported, and — since the arrival of agents — served at runtime to the systems that need to look a term up before they act. The methodology The Core Content Model®: one canonical model every channel and system schema maps to. Developed by Cruce Saunders and the [A] senior content engineering team, first for the Mayo Clinic, then across many implementations with some of the largest enterprise publishers in the world. The proof The methodology was proven at Adobe, Cisco, Eli Lilly, Mayo Clinic, Microsoft, PayPal and Sage Bionetworks, where we organized the content and data models they already had — across systems, formats, representational states and standards — into one harmonized, mapped core model for their applications. CoreModels the product grew out of that work. The platform CoreModels: the methodology as software. Types, elements, taxonomies and relation groups authored in a graph-based workspace, governed by people, versioned, and exported to the formats each system needs. The agentic turn The MCP agent endpoint, the Schematica Library, a library of connectors and recipes, and a transformation engine that carries a model across schema formats with an honest account of what each format cannot hold. The model stopped being a design artifact and became runtime infrastructure. In use Sage Bionetworks builds and governs its own core model in CoreModels, harmonizing research data models across consortia — the methodology, run by the customer, in the product. Today ARAMAI is the product group of Ariesnet, Inc., a Texas corporation. CoreModels is its platform, as part of the Schematica suite of solutions. Ariesnet contracts, builds and integrates for clients, and operates; ARAMAI does the research and makes the software. CoreModels® is a registered trademark. Core Content Model® is a registered trademark. ## Why it makes critical sense in the agentic enterprise Here is a failure that did not look like one. An account manager asks an assistant for a renewal summary. The assistant reads the CRM, where the account’s customer record carries a segment: mid-market. It reads billing, where customer is a contract tier: enterprise, because of a legacy bundle. It reads the help center, where customer is an audience tag on the articles that account gets shown. It writes “Enterprise customer, mid-market segment, renewing in Q4” — fluent, blended, and nobody in the room can tell which sense of the word carried the pricing. The renewal email goes out with enterprise language. The summary is stored. Next week another agent builds the quarterly deck from that memory, and “enterprise” is now a fact about the account that no system ever asserted. Notice what the failure was not. It was not that billing and the CRM disagree; those are real meanings, each settled by people with good reasons, and neither is wrong. The failure is that at the moment of the request nothing could say which sense was in force for this handoff, so the assistant blended them, and three hops later the blend looked like knowledge. Agents run on leverage, and leverage is symmetric. A good harness propagates a wrong term exactly as faithfully as a right one, and faster the better it gets — into tool calls, into memory, into the next agent’s input, into the summary written back as fact. The industry has not ignored this. Grounding, citations, evaluation suites and data contracts all help, and all of them stand on the same floor: a definition pasted into a system prompt does not survive the next agent or last week’s memory write; retrieval by similarity finds language that sounds like the term and cannot record that it guessed; evaluations grade the answer, not the binding the answer was made from. A core model is the floor. It is where every term has an authority — a place, not a person’s memory — becomes true for the systems that need it: meaning written where a machine can read it, bindings that survive the write, and a lookup before every make-up. When two authorities conflict, the model records the contest and hands it to the owner instead of inventing a third meaning. The same answer serves the harder seam. No estate is alone: a supplier’s system hands you a purchase order whose unit is a case where yours is a pallet; a partner’s agent reads your catalog with its own sense of available. Two agents that share a protocol but not meaning — what we call the Stranger Problem — need something to check against before they act. Coherence between estates is built on coherence within them, and a core model is the within. ### Human-in-the-model, not human-in-the-loop Dropping a person into a loop to approve what a machine already did sets them up to rubber-stamp, or to fail. The workable division is older and simpler: humans set direction, encode meaning and own the judgment and the exceptions; machines do the volume and the assembly. In a core model, people settle the calls that carry consequence once, in the model, and are nowhere near the request path afterwards. Every agent reads what they settled. The people who structure knowledge — the content practitioners, the data modelers, the taxonomists and ontologists — are not being written out of the story by agents. They are becoming its authors again. Read on for [why coherence is a capability](https://www.coremodels.io/framework/coherence), or go straight to [why CoreModels](https://www.coremodels.io/framework/why) rather than the stack you already run. ## Built on a methodology proven in enterprise environments The Core Content Model® methodology was proven at these organizations, where we organized the content and data models they already had — across systems, formats, representational states and standards — into one harmonized, mapped core model for their applications. CoreModels the product grew out of that work. Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkCoherence →A request inherits terms the estate holds. Those terms are mapped to meaning across many uses. When the meaning survives every mapping, that is coherence — and it is a capability, not a value statement.](https://www.coremodels.io/framework/coherence) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Coherence: meaning survives many handoffs | CoreModels Solution Framework" description: "A request inherits terms the estate holds. Those terms are mapped to meaning across many uses. When the meaning survives every mapping, that is coherence — and it is a capability, not a value statement." canonical: "https://coremodels.io/framework/coherence" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # Coherence: meaning survives many handoffs A request inherits terms the estate holds. Those terms are mapped to meaning across many uses. When the meaning survives every mapping, that is coherence — and it is a capability, not a value statement. Nothing an assistant produces is made from nothing. Every answer, draft, module and plan is a composite of what was fed in, and what was fed in was made by someone, somewhere, earlier. Coherence is meaning surviving that transit — and it comes from humans, AI, content, data, graphs and systems working well together. This page digests the essay Coherence Is a Capability by Cruce Saunders, founder of ARAMAI and architect of CoreModels. The essay is the canonical source; this is the map. ## The request and the estate Someone asks an assistant for something the company should already be able to produce — who the customer is on this account, what the policy says, a first draft of the release notes. A prompt fires. A window is assembled from last week’s tickets, a CRM record, a help-center article. Tools are called. Something clean comes back and is stored for the next turn. That is the request: built from nothing each time, leaving only its product behind. It fails in an afternoon, and somebody on the platform team sees it fail, because a request failing is loud. Everything the request touched was already there before it started. The account object, the billing plan, the article, the topic in the component content system, the policy with a version number on it. None of it was created for this request, and all of it sits whether or not anyone opens an assistant today. That standing material is the estate. It fails slowly, over years, and nothing looks broken while it does. Underneath the estate is the ground: what the terms mean, who says so, and whether that still holds when work crosses a seam. ## Why the request cannot fix this from inside Organizations don’t adopt AI. They grow capabilities. Each wave of the last three years arrived as a question, and each question, once an organization learned to ask it well, grew into a practice with a team and a budget line. What should the model do: prompt engineering. What should it see: context engineering. How should the whole system behave: harness engineering — the tools, memory, guardrails and loop around the model, which is where agent work became systems work and stopped fitting inside one job description. Each question contains the one before it, and the reason to keep widening is leverage. Which is the thing the sequence hides: leverage is symmetric. Think of a relay race where the baton is a word. Every runner is fast, every handoff is clean, nobody drops anything — and if the first runner was handed the wrong baton, the team still finishes first, in perfect form, carrying the wrong thing across the line. Do, see, behave: the last three years optimized behavior, and were right to. Not one of those questions decides who is allowed to say what a term means. ## The roles are already here Authority over meaning has capabilities too, and they predate this conversation by decades. Data engineering asks: what records do we have, and do they survive the trip? Pipelines, contracts, lineage, types — mature, well tooled, respected, and present nearly everywhere. Content engineering asks a three-part question the others don’t: what did we actually say, what shape does it live in, and how does it move? Model, metadata, schema, taxonomy — the authored structure. A structured component carries what a record carries, plus audience, sequence, variant conditions, the reason a sentence sits where it sits, and unlike a record it never stops moving. Treating content as data alone isn’t wrong. It’s thin. These two are peers. Neither contains the other. Both already live in most large organizations, and they usually report to people who don’t attend each other’s meetings. ## The ground is underneath, not further out Inside a request, nesting means scope: harness contains context contains prompt, and moving outward widens your view of the same work. The relationship between the request and the estate is a different kind of nesting. The request sits on top of the estate, and the estate sits on the ground. Everything above inherits whatever is settled, or unsettled, below. That is why a very good harness over an unsettled customer does not give a slightly worse answer. It gives a confident, fast, well-formatted wrong answer, every time. So the missing thing is semantic engineering. Not another practice added to the list, and not a fourth ring drawn further out. It is the ground the other practices stand on, and it asks a plain question: what do the terms mean, and who says so? ## The definitions already exist Most of the answer is written down. The CRM has a definition of an account. The ERP has an order object with fields somebody fought over for a quarter. The content platform has a content type with a required audience field. A hospital has HL7 and FHIR. The data contracts already say what a customer is — in four places, differently. Decades of settled argument, written into data models, content models and standards. Two things are missing, small to say and hard to do: those definitions are not reachable at the moment the request needs them, and they have never been mapped to each other. Reconciling them means connecting the models, not merging them. Each is a place a definition lives, and each is expert in something the others cannot hold. Every attempt to collapse them into one master model has produced a very expensive fifth place where the definition lives, slightly differently again. Which is also the answer to “we have this.” A metrics layer holds measures. A catalog holds lineage. A master-data system holds identity. A component content system holds components. A knowledge graph holds whatever someone loaded into it. Each is real, and none of them holds the mappings between the rooms: which sense applies at which seam, and who may change it. That is the unoccupied job. It is the job CoreModels was built to do — hold each model as it is and keep the mappings between them alive — and it is a job that has to be done whether or not anyone buys anything. ## The same work, named | The question | Practice | What it settles | Where it already lives | | --- | --- | --- | --- | | What should the model do? | Prompt | Words are an engineering surface. | Instruction libraries, playbooks | | What should it see? | Context | The surround is designed. | Retrieval, memory, knowledge bases | | How should the system behave? | Harness | Leverage compounds both ways. | Tools, guardrails, agent platforms | | What records do we have? | Data | Standing material must survive the trip. | Warehouses, contracts, CRM / ERP | | What did we say, in what shape? | Content | Structure carries intent worth keeping. | DITA / CCMS, taxonomy, variants | | What do the terms mean, and who says so? | Semantic | Every term has an authority. | CRM, ERP, FHIR, DITA, contracts | | How does meaning survive the handoffs? | Coherence | Mappings between the rooms, maintained. | Schemas and taxonomies at the seams | ## Growing the capability A lot of large organizations already hold most of the practices in that table. What they don’t have is composition. The practices live as silos with their own vocabularies and their own meetings, and a term changes meaning every time it crosses a seam. Agents make this worse before they make it better: every department can now run its own self-improving loop tuned to its own metric, and a silo that optimizes itself faster does not become more coherent with its neighbors. It becomes more confidently different. The correction isn’t a merger. It’s a grammar between disciplines — shared reference structures that let each practice stay expert in its lane while meaning survives the handoffs. Maintained by people, consulted by machines. Here is what a week of that looks like. Pick customer. Write the four definitions side by side — the CRM’s, billing’s, the help center’s, the warehouse’s — each in the words its own system uses. Name who may change each one. Publish the mapping somewhere a machine can read it, in the schema, not in prose about the schema. Point the harness at it. Then watch the next twenty retrievals. Some will resolve cleanly. Some will hit a seam where two authorities disagree, and the right behavior there is not to pick or to blend but to record the contest and hand it to the owner. Two of the twenty will be surprises: a distinction discovered in a bug fix that deserves to outlive the bug, or a mapping that has to be republished because billing renamed a tier on Tuesday. That is the job. ### Coherence needs a practice Not a big-bang ontology program, not a merged master model, and not a platform purchase that counts as the capability. Not a new department either: centers of excellence fail when they are nobody’s job. The ones that work are funded and chartered, centralize the pattern-making, and leave implementation where it already lives. Coherence needs a practice of that shape, crossing the rooms that already exist — a shared reference structure both can point at, and a named owner for each seam where meaning is known to leak. Not an owner of the CRM and an owner of the help center. An owner of customer, wherever it travels. The change moves at the pace of the estate, not the pace of a request. Start with what you have. Reconcile the settled definitions first. Name the authorities. Tend the seams. Let the harness look things up instead of guessing, and let the retrieval logs tell you which terms are still contested. Mining produces candidates. Governance gives them status. ## The short form ### The request Prompt, context, harness. What should the model do, see, and how should the system behave. Rebuilt each invocation; fails loudly, locally. ### The estate Data engineering and content engineering. Peers. What records survive the trip; what we said, in what shape, and how it moves. Stands between sessions; fails quietly, globally. ### The ground Semantic engineering. What the terms mean, and who says so. Every term has an authority — a place, not a person’s memory. ### Coherence The mappings between the rooms, maintained. Humans encode meaning and own judgment; machines do the volume and the assembly. Reconcile what’s settled. Own the seams. Watch the slow drift. Look up before you make up. We’ve spent three years making the request smarter. The estate is where the meaning was the whole time. The ground is where it gets settled. And coherence — meaning surviving its own handoffs — is a capability. Capability is the thing that compounds, and coherence compounds unusually well, because meaning is shared infrastructure: one team’s investment in it lowers the cost of every other team’s data and AI work. Where CoreModels sits in this picture: on the ground, holding the mappings. [Why CoreModels →](https://www.coremodels.io/framework/why) Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkWhy CoreModels →Your systems already know what your data is. None of them knows what it means across the others. CoreModels holds each model as it is and keeps the mappings between them alive.](https://www.coremodels.io/framework/why) Previous: [The Core Model](https://www.coremodels.io/framework/core-model) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Why CoreModels | CoreModels Solution Framework" description: "Your systems already know what your data is. None of them knows what it means across the others. CoreModels holds each model as it is and keeps the mappings between them alive." canonical: "https://coremodels.io/framework/why" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # Why CoreModels Your systems already know what your data is. None of them knows what it means across the others. CoreModels holds each model as it is and keeps the mappings between them alive. A single-source annotation tool answers one question about a field: what does it mean? An agent working across the enterprise needs four answered — what it means, where it lives, what it connects to, and how it sits in the model. Answering all four across sources is the product, and the reason the stack you already run is not enough. ## The gap, in four dimensions Dimension Without a core model With CoreModels Meaning A field’s definition lives in a YAML comment, a wiki page, or one person’s memory. Two tests that disagree both pass. Definitions, permitted values and the mistakes an agent keeps making sit on the element itself, where a machine can read them. Location The same entity exists in the warehouse, the CRM and the content model, and nothing says which one the business considers true. Every entity is located: which system holds which sense, and which sense is in force at this seam. Connection The join across systems is re-derived by every pipeline and guessed by every agent, differently. Joins and equivalences are mapped once — customer_id to accountRef to Person — and read by every consumer. Relationship How a term sits in the model — parent, subtype, mapped equivalent to a public standard — is written nowhere. Relationships are typed, versioned and traceable, from your own schema to the standard it conforms to. ## What your stack already does, and what it does not A transformation tool knows its project. A catalog knows its tables. A metrics layer holds measures; a master-data system holds identity; a component content system holds components; a knowledge graph holds whatever someone loaded into it. Each is real, and each is expert in something the others cannot hold. Pointing an agent at any one of them is a reasonable first move, and for questions that stay inside that system it works. None of them holds the mappings between the rooms. None can say that customer_id in the warehouse is the same entity as accountRef in the CRM and Person in the content model — or which of the three the business considers true at this seam, or who is allowed to change that. That judgment does not exist in any of your systems. It exists in your people, and until now it has stayed there. CoreModels is where it gets written down once, and read a thousand times. It consumes what your tools already produce — a manifest, a catalog, a schema, a vocabulary — as first-class inputs, and gives back the one thing none of them can: the connected picture, governed by the people who own the meaning, readable at runtime by every agent you run. ## Why CoreModels Bridging the gap between humans, systems and AI. ### Built for modern data pipelines At the heart of ETL and ELT workflows, CoreModels functions as a structural and semantic control layer that governs the transformation process across data systems. It manages how data is reshaped, validated and mapped, ensuring every transformation maintains consistency with both technical definitions and business meaning. By centralizing transformation logic, mappings and schema relationships, CoreModels lets pipelines adapt as models evolve. ### Alignment across humans, systems and AI When schemas and transformation logic are hidden in code, subject-matter experts rely on developers for every update, and AI systems lose context. CoreModels exposes and connects these definitions, establishing a shared foundation where humans and machines interpret data consistently. That alignment minimizes friction, eliminates redundancy, and reduces rework across complex ecosystems. ### Designed for flexibility Data structures, APIs and AI workflows evolve faster than traditional tools keep up. CoreModels is a graph-based low-code modeling platform built on adjustable meta-model templates that support a wide range of representation formats. Whether managing JSON Schemas, JSON-LD definitions, or the configurations that drive transformations and orchestration, it adjusts to organizational and technical needs. ### A unified environment for data ecosystems Teams model, extend and connect structural and semantic definitions within one environment, which keeps them resilient as data ecosystems change. The unified approach minimizes duplication, prevents schema drift, and ensures reliable, governed data flow across distributed and hybrid architectures. ## Neither humans nor AI is a dependency The governance-minded buyer worries that agents will decide what the data means. The automation-minded buyer worries that every request will wait on a person. CoreModels is built so that neither is true. The machine proposes first: it infers the joins, the equivalences and the relationships it can see across every source. Your human team settles the calls that carry consequence — not every field needs a ruling; the ones that do, get one — and commits them in a shared workspace, with AI as collaborator. Nobody hand-labels a warehouse. Nobody ships a definition the business never agreed to. And once settled, the people are out of the request path: the model answers. [How it works, step by step →](https://www.coremodels.io/framework/how-it-works) Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkHow it works →Connect and ingest, model and map, collaborate and govern, expose and execute, adapt and scale — the mechanism behind the three steps on the landing page.](https://www.coremodels.io/framework/how-it-works) Previous: [Coherence](https://www.coremodels.io/framework/coherence) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "From ingestion to execution in five steps | CoreModels Solution Framework" description: "Connect and ingest, model and map, collaborate and govern, expose and execute, adapt and scale — the mechanism behind the three steps on the landing page." canonical: "https://coremodels.io/framework/how-it-works" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # From ingestion to execution in five steps Connect and ingest, model and map, collaborate and govern, expose and execute, adapt and scale — the mechanism behind the three steps on the landing page. The landing page compresses this into three steps — connect your models, map it together with AI, point your agent at it. Here are the five the platform actually runs, and what each one does with the material you already have. 1. 1Connect and ingestCoreModels reads the structure you already publish. A dbt project writes a manifest; a warehouse exposes its information schema; an API is described by a JSON Schema or a Protocol Buffers file; a content team maintains a schema.org vocabulary or a SKOS taxonomy; a research study lives in a REDCap codebook. Each connector knows the artifact its source already produces and imports it as-is — no passwords, no migration, no rebuild. Connect one, or connect them all.Every connector carries recipes: named, pre-scoped entry points that solve one recognizable problem for one kind of team, with a walkthrough and no requirement to learn a new vocabulary first. [See the connector catalog](https://www.coremodels.io/connectors) · [Read the guides](https://www.coremodels.io/guides) 2. 2Model and mapImported structure becomes a core model: types, elements, taxonomies and the relationships between them, in a graph you can see. Then the mapping. CoreModels proposes the joins, the equivalences and the relationships it can infer across every source — the same customer under three names, the same status vocabulary with two spellings, the field that corresponds to a public standard. Compare versions side by side. Reconcile mismatches.A transformation engine sits underneath: one neutral representation between schema formats, so a model imported from one can be projected into another with an honest account of what the target format cannot hold. [The Schema Converter](https://www.coremodels.io/connector/converter) 3. 3Collaborate and governYour human team talks the proposals over and commits, in a shared workspace, with AI as collaborator. Not every field needs a ruling; the calls that carry consequence get one. Validation rules — required attributes, custom relationships, constraints, permitted values — catch errors before they propagate. Every decision is versioned and traced, so a definition has an author, a date and a reason.This is human-in-the-model: people set the meaning once, here, and are nowhere near the request path afterwards. 4. 4Expose and executeThe governed model is served to everything that needs it. Agents — Claude, Cursor, your own — read it through the MCP endpoint on every plan, using the same permissions as the person whose credentials they run under, and can write back within those permissions; every write is versioned and reviewable like anyone else’s. Pipelines and applications read the same model through the API. Contracts, tests and downstream artifacts are generated from the governed definitions rather than typed by hand.Each agent gets up to 15 concurrent in-flight requests; Enterprise plans set throughput in contract. [The MCP server and tool reference in the docs](https://learn.coremodels.io/) 5. 5Adapt and scaleModels change because the business changes. Versioned schemas, branching workflows and automated validation keep the model consistent as it evolves; when a source renames a tier on Tuesday, the mapping is republished and everything reading the model changes with it. Extend the meta-model templates, track the standards your model conforms to as they move, and add new formats as they arrive. ## Collaboration without bottlenecks ### Subject-matter experts edit meaning directly Business experts add, modify and manage definitions and rules in a grid a finance lead can edit, not a YAML file. No developer intervention for a schema change. ### Collaboration with suggestions Collaborative editing with suggestions and comments keeps everyone aligned. Teams work on a model the way they work on a shared document — propose, discuss, commit. ### Audit and versioning Every change is versioned. Track who changed what and when, branch when a team needs to work ahead, and keep a full history across the whole model library. ## What an agent sees An LLM writing SQL against your warehouse has three bad options: guess from the column name, read the SQL, or ask a human. CoreModels gives it a fourth. Before it answers, the agent looks the term up — its definition, its permitted values, the note about what it is commonly mistaken for, what it must not be used for, and what it maps to in the systems next door. The answer is built from what the business agreed, not from what the column happened to be called. Three steps, five steps: the homepage and this page describe one mechanism at two altitudes. Connect your models is step 1. Map it together, with AI is steps 2 and 3. Point your agent at it is steps 4 and 5. Nothing on the landing page is a different product from what is here. [What a Core Model can do once it exists →](https://www.coremodels.io/framework/capabilities) Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkCapabilities →Graph-based modeling, adjustable meta-models, collaboration and suggestions, import-map-compare, precision editing, validation and governance, transformation across formats, and the agent endpoint.](https://www.coremodels.io/framework/capabilities) Previous: [Why CoreModels](https://www.coremodels.io/framework/why) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "What a Core Model can do once it exists | CoreModels Solution Framework" description: "Graph-based modeling, adjustable meta-models, collaboration and suggestions, import-map-compare, precision editing, validation and governance, transformation across formats, and the agent endpoint." canonical: "https://coremodels.io/framework/capabilities" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # What a Core Model can do once it exists Graph-based modeling, adjustable meta-models, collaboration and suggestions, import-map-compare, precision editing, validation and governance, transformation across formats, and the agent endpoint. An inventory, without adjectives. Everything here is in the product today; where a capability is early access, the connector page says so. ## What a Core Model can do Six capabilities of the modeling workspace, as they look in the product. ### Graph-Based Low-Code Modeling Platform CoreModels provides visual editors for entities, relationships, and constraints — letting you build and evolve data models without writing code. Everything is connected in a single schema graph. ### Adjustable Meta-Models CoreModels comes with default meta-model templates for common formats — all customizable. Extend existing templates or build your own to match your organization's needs. - •JSON Schema for API and service definitions - •JSON-LD and linked-data models for rich semantics - •Configurations for transformations and orchestration - •Custom formats for organizational needs ### Effortless Collaboration & Suggestions Collaborate with your team on data models in real time. Get feedback, make changes, and ensure everyone is on the same page with built-in suggestions and comments. ### Import, Map & Compare Seamless Ingestion: Bring in models from existing systems or upload new definitions via simple import flows. Mapping & Comparison: Align disparate schemas, highlight differences, and reconcile mismatches quickly. Expandable Export: Share refined models in the formats you need — documentation, code generation, or integration. ### Precision Editing & Customization Fine-tune your data models to meet specific needs. Specify required attributes, create custom relationships, and control every detail of your schema definitions. ### Validation & Governance Rule Definition: Specify required attributes, custom relationships, and constraints. Automated Validation: Catch errors before they propagate, guaranteeing schema integrity across pipelines. Audit Trails: Maintain transparent records of who changed what and when, ensuring compliance and trust. Built as a cloud-native service, CoreModels scales to handle large datasets and complex model libraries. It integrates smoothly into your existing stack and keeps performance high as your usage grows. ## Transformation across formats Underneath every import and export is a transformation engine with one neutral representation at its center. A model that arrives as a JSON Schema can leave as a JSON-LD context, a ShEx shape, an Avro record, a SQL DDL, or an OWL class — and the engine keeps a ledger of what each target format cannot hold, so a lossy projection is declared rather than discovered. The same engine reconciles a schema imported from one platform against the same schema imported from another. [The Schema Converter →](https://www.coremodels.io/connector/converter) ## The agent endpoint ### On every plan Agents read the governed model through the MCP endpoint on Builder, Team and Enterprise. Agents are not seats; viewers are free and unlimited. ### The person’s permissions An agent runs under the credentials of the person who connected it and can do what they can do — read, and write within the same limits. ### Every write is a version An agent’s changes are versioned like anyone else’s, so they are reviewable and reversible. Agent prompts and traffic are not used to train models. ### Bounded traffic Each agent gets up to 15 concurrent in-flight requests; above that it receives a rate-limit response and retries. Enterprise plans set throughput in contract. ## A library of connectors 16 platforms and 10 formats today, labelled for what you can do with each. Platforms are the systems your schemas run in; formats are the languages they are written in. Every card on the catalog says whether it is generally available, early access, or guided. ### Platforms Airbyte · Apache Airflow · Google BigQuery · cBioPortal · Confluent · Schema Converter · Databricks · dbt · Microsoft Fabric · AWS Glue · Neo4j · Open Semantic Interchange · REDCap · Salesforce · Snowflake · Azure Synapse ### Formats Apache Avro · JSON-LD · JSON Schema · LinkML · ODCS · MACH ODM · OWL · Protocol Buffers · ShEx · SQL [Browse the catalog →](https://www.coremodels.io/connectors) ## Built as a service Built as a cloud-native service, CoreModels scales to large datasets and complex model libraries and keeps performance high as usage grows. Builder allows 100,000 nodes per model, Team 1,000,000, Enterprise unlimited — a node being any type, element, taxonomy term or value in a model; a 300-model dbt project at about eight columns each is roughly 2,400 nodes before vocabularies. Enterprise adds RBAC, SSO/SAML, IP allowlisting, audit logs, private schema vaults, dedicated infrastructure, on-premise and private-cloud deployment, and a 99.9% uptime commitment in contract. [Plans and limits →](https://www.coremodels.io/pricing) Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkWho it serves →Six kinds of team keep meaning somewhere. One model lets them keep it together — data and pipeline, standards and ontology, API and interface, content and semantics, research and domain, business systems and contracts.](https://www.coremodels.io/framework/who) Previous: [How it works](https://www.coremodels.io/framework/how-it-works) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Who it serves | CoreModels Solution Framework" description: "Six kinds of team keep meaning somewhere. One model lets them keep it together — data and pipeline, standards and ontology, API and interface, content and semantics, research and domain, business systems and contracts." canonical: "https://coremodels.io/framework/who" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # Who it serves Six kinds of team keep meaning somewhere. One model lets them keep it together — data and pipeline, standards and ontology, API and interface, content and semantics, research and domain, business systems and contracts. The people who structure knowledge already exist in your organization, usually in teams that don’t attend each other’s meetings. A core model is where what each of them settled becomes readable by the others — and by every agent. ## Six constituencies, one model | Who | What they bring | Connectors that serve them | | --- | --- | --- | | Data, warehouse and pipeline | Manifests, catalogs, contracts — the structure the pipeline already publishes. | [dbt](https://www.coremodels.io/connector/dbt) · [Snowflake](https://www.coremodels.io/connector/snowflake) · [Google BigQuery](https://www.coremodels.io/connector/bigquery) · [Databricks](https://www.coremodels.io/connector/databricks) · [Microsoft Fabric](https://www.coremodels.io/connector/fabric) · [Azure Synapse](https://www.coremodels.io/connector/synapse) · [AWS Glue](https://www.coremodels.io/connector/glue) · [Airbyte](https://www.coremodels.io/connector/airbyte) · [Apache Airflow](https://www.coremodels.io/connector/airflow) · [Confluent](https://www.coremodels.io/connector/confluent) | | Standards and ontology | The vocabularies an industry agreed on, and the ontology the organization maintains. | [OWL](https://www.coremodels.io/connector/owl) · [JSON-LD](https://www.coremodels.io/connector/jsonld) · [ShEx](https://www.coremodels.io/connector/shex) · [LinkML](https://www.coremodels.io/connector/linkml) · [Open Semantic Interchange](https://www.coremodels.io/connector/osi) · [MACH ODM](https://www.coremodels.io/connector/odm) | | API and interface | The shapes systems promise each other. | [JSON Schema](https://www.coremodels.io/connector/jsonschema) · [Protocol Buffers](https://www.coremodels.io/connector/protobuf) · [Apache Avro](https://www.coremodels.io/connector/avro) | | Content, taxonomy and semantics | The vocabulary and structure the content team stewards — schema.org, SKOS, the taxonomy that took years to settle. | [JSON-LD](https://www.coremodels.io/connector/jsonld) · [Neo4j](https://www.coremodels.io/connector/neo4j) · [MACH ODM](https://www.coremodels.io/connector/odm) | | Research and domain | The codebook that is the schema of the study. | [REDCap](https://www.coremodels.io/connector/redcap) · [cBioPortal](https://www.coremodels.io/connector/cbioportal) | | Business systems and contracts | The org whose schema can change in forty seconds from Setup, and the contract that says what the data promises. | [Salesforce](https://www.coremodels.io/connector/salesforce) · [ODCS](https://www.coremodels.io/connector/odcs) | Content and semantics people bring their vocabularies — a schema.org profile, a SKOS taxonomy, an ontology. CoreModels holds those as first-class models and maps them to the data and API schemas next door. It does not connect to a content platform; it connects to the structure the content platform was built on. ## By role ### Data engineers and developers Authoritative schemas via API and MCP. Less guesswork, fewer integration errors, transformations driven by machine-readable definitions instead of rewritten code. ### AI and ML engineers A structured, validated schema network agents query at runtime. Fewer hallucinated field names, correct data shapes, and pipelines that adapt when the model changes. ### Enterprise architects A governed, versioned view of relationships and dependencies across the enterprise, with industry standards — FHIR, schema.org — mapped rather than re-implemented. ### Subject-matter experts Define and manage business definitions and rules directly, collaborate without waiting for developers, and keep a traceable record for compliance. ### Content engineers and taxonomists The people who already steward a vocabulary become the authority every agent reads from. The structure they maintain stops being documentation and becomes runtime infrastructure. ### Industry specialists Domain models from the Schematica Library — healthcare, legal, e-commerce, web standards — adapted to the organization and mapped to its own systems. ## Where it is used ### Healthcare data modeling Streamline mapping between FHIR resources, device schemas and clinical data structures. Co-develop and refine models across teams, implement transformations quickly, and keep the record a regulator can follow — so the organization spends its effort on patients and research rather than plumbing. ### Cross-domain integration Connecting CRM and ERP, harmonizing product catalogs across regions, bridging legal document repositories with case management: typed mappings and semantic validation that make one schema graph do the work of dozens of point-to-point scripts. ### AI-ready knowledge infrastructure Agents perform better when they understand the shape and meaning of data. A machine-readable schema network lets them validate inputs, generate transformations and adapt to change — reading authoritative definitions at runtime instead of inferring them from names. ### Rapid schema evolution Business rules and data structures change constantly. Visual editors, collaboration and automated validation let teams evolve a model in hours rather than weeks, while governance rules prevent drift and breaking changes. [What CoreModels sits inside →](https://www.coremodels.io/framework/suite) Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [Next in the frameworkThe Schematica Suite →CoreModels is the engine. The Suite is what it powers: the Schematica Library, the MCP server, the design plugins — and the wider ecosystem of standards they connect to.](https://www.coremodels.io/framework/suite) Previous: [Capabilities](https://www.coremodels.io/framework/capabilities) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "The Schematica Suite | CoreModels Solution Framework" description: "CoreModels is the engine. The Suite is what it powers: the Schematica Library, the MCP server, the design plugins — and the wider ecosystem of standards they connect to." canonical: "https://coremodels.io/framework/suite" last_updated: "2026-09-15" --- [CoreModels Solution Framework](https://www.coremodels.io/framework) 1. [1The Core Model](https://www.coremodels.io/framework/core-model) 2. [2Coherence](https://www.coremodels.io/framework/coherence) 3. [3Why CoreModels](https://www.coremodels.io/framework/why) 4. [4How it works](https://www.coremodels.io/framework/how-it-works) 5. [5Capabilities](https://www.coremodels.io/framework/capabilities) 6. [6Who it serves](https://www.coremodels.io/framework/who) 7. [7The Schematica Suite](https://www.coremodels.io/framework/suite) # The Schematica Suite CoreModels is the engine. The Suite is what it powers: the Schematica Library, the MCP server, the design plugins — and the wider ecosystem of standards they connect to. Two words that are easy to confuse and deliberately kept apart. The Schematica Suite is the set of products CoreModels belongs to. The Schematica ecosystem is the wider world of standards, vocabularies and communities those products connect to. CoreModels is the engine of the first and a citizen of the second. ## The Suite ### CoreModels The platform: one connected core model, governed by people, read by every agent. [The Core Model →](https://www.coremodels.io/framework/core-model) ### Schematica Library A curated, community-driven catalog of production-ready data models, ontologies, taxonomies and content structures across industry domains — healthcare, legal, e-commerce, web standards, enterprise. Browse, preview, and activate any model into CoreModels. [library.schematica.io →](https://library.schematica.io/) ### The MCP server Open MCP access to the Library, so an assistant can discover what exists before it builds — and the CoreModels endpoint beside it, so it can read the definition of every item and field in a governed model. [The MCP server →](https://library.schematica.io/mcp-server) ### The design plugins SchemaFlow, RealContent and ContentFlow bring structured models into Figma and FigJam — content models built to SEO standards, live structured content in designs, and conversational flows sourced from data. [schematica.io →](https://www.schematica.io/) ## From discovery to execution 1. 1DiscoverBrowse the Schematica Library for a model that already fits — a FHIR profile, a schema.org product, an industry taxonomy — instead of starting from a blank page. 2. 2ActivateImport it into CoreModels, adapt it to your organization, extend it with your own definitions, and map it to the systems you actually run. 3. 3OperationalizeExpose the governed result through the API and the MCP endpoint, so pipelines, integration platforms and agents read authoritative definitions at runtime. Discovery becomes execution. ## The ecosystem CoreModels does not ask an organization to adopt a new standard. It reads and writes the ones already in play — JSON Schema, JSON-LD, ShEx, OWL, LinkML, Avro, Protocol Buffers, ODCS, the Open Semantic Interchange, MACH ODM, FHIR and schema.org among them — and holds the mappings between a standard and the schemas that conform to it. When a standard moves, the model tracks the move; when two standards describe the same thing differently, the model records both and the correspondence between them. [Every format and platform, in the catalog →](https://www.coremodels.io/connectors) ## Enterprise and Partner Enterprise is one organization governing its own schemas: SSO, audit logs, an SLA, dedicated infrastructure, and an agreement procurement can sign. The Partner Program is a hub governing a shared core across independent units — a research consortium, a holding company, a federation of agencies — with a federated workspace architecture, schema propagation and drift control across units, and a discounted Enterprise license. Partner is applied for, not purchased. [Plans, Enterprise and Partner →](https://www.coremodels.io/pricing) ## The company ARAMAI is the product group of Ariesnet, Inc., a Texas corporation. CoreModels is its platform, as part of the Schematica suite of solutions. Ariesnet contracts, builds and integrates for clients, and operates; ARAMAI does the research and makes the software. [About ARAMAI →](https://www.aramai.net/) CoreModels® is a registered trademark. Try it [Start your 14-day trial](https://www.coremodels.io/pricing) Nothing is charged during the trial. Plans and limits are on the pricing page. [End of the frameworkBack to the framework →CoreModels Solution Framework: the seven pages in one screen.](https://www.coremodels.io/framework) Previous: [Who it serves](https://www.coremodels.io/framework/who) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "CoreModels — One connected core model of what your data means." description: "Warehouses and pipelines, APIs and event streams, ontologies and content models, published standards and the schemas you wrote yourself. A library of connectors, and one governed model your team edits and every agent reads." canonical: "https://www.coremodels.io/q-a" last_updated: "2026-09-15" --- # CoreModels FAQ Questions and answers on data modeling, schemas, governance, and interoperability. Showing questions 1-100 of 1000 ## Frequently Asked Questions ### 1. What is a data model, and what problems does it solve in software and enterprise systems? A data model is a structured definition of the entities, attributes, and relationships in a business domain, expressed in a way that both humans and machines can agree on. It solves the shared-understanding problem: without one, every team invents its own vocabulary, every system stores data differently, and every integration becomes a bespoke translation project. A well-designed data model becomes the contract that aligns applications, analytics, APIs, and reporting. ### 2. How does a data model differ from a database schema, and why does that distinction matter? A data model describes what things exist and how they relate, independent of any technology; a database schema is the physical implementation of that model on a specific platform such as PostgreSQL tables or MongoDB collections. The distinction matters because the data model should outlive any particular database. It is the durable artifact that lets you migrate stores, generate APIs, and reason about the business without rewriting everything each time. ### 3. What are the primary goals of data modeling in a modern organization? The main goals are clarity (everyone agrees on what an entity means), consistency (the same concept is represented the same way across systems), reusability (shared definitions cut duplicate work), governance (rules and quality checks travel with the model), and interoperability (data flows cleanly across internal and external boundaries). A good model is the backbone for all of them at once. ### 4. Why is data modeling considered a discipline rather than merely a technical task? Good data modeling requires domain understanding, stakeholder negotiation, long-term judgment about trade-offs, and ongoing stewardship — not just notation skills. It sits closer to systems architecture than to coding: decisions made in a model propagate for years and touch every team that consumes the data, which is why experienced modelers treat it as a practice, not a deliverable. ### 5. What is the difference between a data model, an information model, and a knowledge model? A data model defines structure for storage and exchange; an information model adds business semantics and context on top such as meaning, lifecycle, and rules; a knowledge model goes further by expressing relationships, inferences, and reasoning, typically as ontologies or knowledge graphs. Each layer is more expressive and more abstract than the one below it. ### 6. How does a well-designed data model reduce long-term technical debt? It prevents duplicated entity definitions, contradictory field meanings, and brittle point-to-point integrations — the three biggest sources of enterprise data debt. When everyone works from a shared model, new features compose rather than conflict, and migrations become targeted rather than organization-wide. ### 7. What are the main audiences for a data model, and how do their needs differ? Business stakeholders need clarity on concepts and rules; developers need types, constraints, and reference semantics; analysts need stable entity definitions and lineage; governance teams need ownership, sensitivity tags, and policies. A single model should serve all of them, usually through different views or documentation lenses. ### 8. Why is naming so important in a data model, and what makes a naming convention effective? Names are the interface humans have with the model, and bad names cause lasting miscommunication. Effective conventions are consistent (same pattern everywhere), unambiguous (one concept per name), free of implementation leakage (no tbl_ prefixes), and aligned with the business domain rather than with legacy system quirks. ### 9. What makes one data model better than another for the same business problem? Better models are simpler where the domain is simple, expressive where it is complex, stable under expected change, testable with concrete examples, and easy for a new team member to learn. There is no universal score — fit to purpose and ability to evolve are the strongest signals that a model is working. ### 10. How does business context influence data modeling decisions? Business context determines which distinctions matter: a retail model might treat customer and guest differently because refund policies differ, while a healthcare model might not draw that line at all. Modeling decisions should flow from real operational differences, not from theoretical purity or from whatever the source system happens to store. ### 11. What are the typical stages of a data modeling project from discovery to delivery? Stages usually include discovery (interviews and artifact review), conceptual modeling (shared language), logical modeling (structure and constraints), physical mapping (target technology), implementation and migration, and finally stewardship — documentation, training, and ongoing governance. Skipping any stage tends to cost more time later than it saves upfront. ### 12. What role does abstraction play in data modeling, and when can it go too far? Abstraction lets one Type represent many variants and one relationship represent many cases, cutting duplication. It goes too far when the model becomes unrecognizable to domain experts, when every concrete question requires three layers of indirection to answer, or when the schema could model anything and therefore explains nothing specific. ### 13. How do entities, attributes, and relationships map to real-world concepts? Entities correspond to things the business talks about such as Customer, Order, or Article; attributes describe those things like name, status, or publication date; relationships express how they connect, for example an Order belonging to a Customer. In CoreModels these map directly to Types, Elements, and Relations. ### 14. What are the most common pitfalls beginners make when modeling data? Typical pitfalls include modeling the UI instead of the domain, treating every field as a string, over-relying on booleans where an enum would serve better, failing to model time explicitly, and mixing identity with descriptive attributes. All of them are reversible but get expensive once production data has accumulated. ### 15. How do you decide when two concepts in a business domain should be the same entity versus separate entities? Two concepts are the same entity when they share identity and behave identically under business rules; they are separate when their lifecycle, constraints, or relationships genuinely differ. Customer and Lead may look alike but often have distinct identity, state, and permissions — that is a signal they should be modeled separately. ### 16. What is the difference between a data model and a data architecture? A data model describes the structure of information; data architecture describes the systems and flows that move, store, and transform that information. The model is the what; the architecture is the where and how. Both are needed, and they are designed by overlapping but distinct roles. ### 17. How do domain-driven design (DDD) principles inform data modeling? DDD encourages modeling around bounded contexts, using the language domain experts actually use (ubiquitous language), and allowing the same concept to have different representations in different contexts. Applied to data modeling, it prevents the anti-pattern of a single god-schema trying to serve every use case at once. ### 18. What is a bounded context, and how does it shape the scope of a model? A bounded context is a defined boundary within which a model and its vocabulary are consistent. Customer might mean one thing in marketing and something different in billing. Scoping models to bounded contexts avoids conflicting definitions and keeps each model coherent, even across a large organization. ### 19. How does modeling for analytics differ from modeling for transactional systems? Transactional models optimize for integrity and write performance, so they tend to be normalized and row-oriented. Analytical models optimize for reading and aggregation, so they favor denormalization, star schemas, and columnar layouts. The distinction drives choices about duplication, history retention, and grain. ### 20. What are the trade-offs between rigid structure and flexible structure in a data model? Rigid structures catch errors early and enable rich tooling but resist change; flexible structures adapt quickly but push validation to runtime and harm discoverability. Most production systems benefit from a rigid core of entities, identifiers, and key fields, with flexible extension points for variation at the edges. ### 21. Why is documentation inseparable from a useful data model? A model is only as useful as its interpretability, and field names alone rarely capture intent, units, lifecycle, or edge cases. Without documentation, every consumer has to reverse-engineer the rules, which is exactly what a model was supposed to prevent in the first place. ### 22. How does modeling for an API differ from modeling for internal storage? API models prioritize stability, backward compatibility, and external clarity; internal storage models can change more freely as long as the API contract holds. The two may share a core but often diverge around naming, granularity, and what is exposed versus hidden. Treating them as one model invites accidental breakage. ### 23. What is the role of a data modeler versus a data architect versus a data engineer? A data modeler designs the conceptual and logical structures; a data architect defines the broader systems, standards, and integration patterns; a data engineer builds and operates the pipelines and platforms that implement them. The roles overlap, but their time horizons and scope differ enough that most organizations need all three perspectives. ### 24. How can a data model serve as a contract between producers and consumers of data? A data model formalizes expectations on both sides: producers agree to deliver data shaped a certain way, and consumers agree to accept it. Combined with validation rules and versioning policies, the model becomes an enforceable contract rather than an informal convention that quietly drifts over time. ### 25. What are the consequences of having no formal data model in a growing system? The system develops incompatible copies of the same concept, integrations multiply as point-to-point translations, reporting becomes unreliable, and every new hire has to rediscover domain truth from the code. Costs compound silently until a costly rewrite forces the issue. ### 26. How do stakeholder interviews contribute to a successful data model? Interviews surface the real rules, edge cases, and vocabulary — things no database schema exposes. They also build buy-in, because people support models they helped shape. Skipping interviews is how modelers end up accurate on paper but wrong in practice. ### 27. Why is it valuable to model time explicitly rather than only storing timestamps? Timestamps capture when a record changed, but they do not capture when a fact was true. Modeling effective dates, valid ranges, or versioned states lets you ask what you knew at a given moment — essential for audit, analytics, and reversing mistakes without rewriting history. ### 28. How do you measure the quality of a data model before it reaches production? Useful measures include coverage (does it represent every known use case?), stability (how often does it need changes?), reviewability (can non-experts follow it?), validation coverage (are the rules testable?), and reuse (are shared concepts actually shared?). None is sufficient alone, but together they give a reliable picture. ### 29. What does single source of truth mean in the context of data modeling? Single source of truth means every concept has one authoritative definition and one authoritative system of record, and other systems refer to it rather than duplicate it. Without this, teams get caught in endless debates about whose number is right and which system is authoritative. ### 30. How should organizations govern the evolution of their data models over time? Governance includes clear ownership, a review process for changes, versioning and deprecation policies, impact analysis before breaking changes, and traceability back to business decisions. In CoreModels, Git-backed workflows, roles, and change tracking support this natively. ### 31. What is a conceptual data model, and who is its primary audience? A conceptual model describes the key business concepts and how they relate, using domain language and minimal technical detail. Its primary audience is business stakeholders, product managers, and domain experts — people who need to agree on what exists before anyone designs how it is stored. ### 32. How does a logical data model differ from a conceptual one? A logical model adds structural detail including attributes, data types, keys, cardinalities, and formal constraints, without tying itself to a specific database technology. It translates what exists into what each thing is made of and how they formally relate. ### 33. What defines a physical data model, and why is it platform-specific? A physical model specifies exactly how the logical model is realized on a chosen platform: table and column names, index strategies, partitioning, storage types, and performance tuning. It is platform-specific because each technology has different capabilities, limits, and idioms that shape the implementation. ### 34. Why do many teams skip the conceptual stage, and what problems does that create? Teams skip it because it feels abstract and they want to start building. The result is that technical decisions encode hidden business assumptions that nobody validated, leading to rework when stakeholders finally see the model and realize it does not match reality. ### 35. How do you transition cleanly from a conceptual model to a logical one? Walk each concept into formal Types, each descriptive detail into Elements with data types and constraints, and each conceptual relationship into a formal Relation with cardinality. Preserve names where possible, and document any renames explicitly so the audit trail is visible. ### 36. What details typically appear in a logical model that are absent from a conceptual one? Logical models add data types, nullability, primary and foreign keys, required and optional flags, explicit cardinalities, and declarative constraints. These details matter to implementers but would overwhelm a conceptual conversation with stakeholders. ### 37. How are primary keys and foreign keys introduced during logical modeling? Primary keys formalize entity identity, either natural (business-meaningful) or surrogate (synthetic). Foreign keys formalize relationships from conceptual connected-to statements. Choosing well here shapes every downstream implementation, so it deserves careful thought. ### 38. What platform-specific concerns surface only at the physical modeling stage? Partitioning strategy, indexing, column types, compression, character sets, deployment topology, sharding, and engine-specific features all come up only at the physical stage. Decisions here are reversible but expensive, so they deserve the same rigor as logical design. ### 39. When is it appropriate to let the physical model diverge from the logical one? When performance, storage, or platform constraints require it — for example, denormalizing for read speed, splitting a logical entity across two tables, or adding derived columns for analytics. Any divergence should be documented so the logical model remains the conceptual anchor. ### 40. How do conceptual models support business–IT alignment? They provide a shared language that both sides can critique without prerequisite technical knowledge. When a business expert can read and correct the model, the alignment cost of every downstream decision drops dramatically. ### 41. What notation styles are commonly used for conceptual models? Common styles include entity-relationship diagrams (Crow's Foot, Chen), UML class diagrams, and increasingly graph-based views like the ones in CoreModels. The choice matters less than consistency within the organization, because readability scales with familiarity. ### 42. How do you represent business rules in a conceptual model without over-specifying? Capture rules as short natural-language statements attached to entities, such as an Order must have at least one LineItem, rather than encoding them in notation. Formalization can wait for the logical model; at the conceptual stage, readability wins. ### 43. What are the signs that a conceptual model is too detailed? Signs include business stakeholders disengaging, every review meeting becoming a data-type debate, diagrams that do not fit on a screen, and distinctions that no business process actually cares about. A conceptual model that tries to be complete is usually the wrong kind of model. ### 44. How does the conceptual-logical-physical progression apply to non-relational stores? The progression is just as valuable even if the physical target is a document or graph database. The conceptual and logical layers remain identical; only the physical realization changes — nested documents, collections, or graph nodes instead of tables. ### 45. How can conceptual models be reused across multiple physical implementations? A conceptual model is intentionally technology-neutral, so one model can feed a relational warehouse, a document store, and an API at the same time. The logical layer may branch per target, but the conceptual anchor stays shared, which is exactly the reuse benefit. ### 46. What is the role of entities, attributes, and relationships at each level? At the conceptual level they express business meaning; at the logical level they gain types and formal constraints; at the physical level they become tables, columns, indexes, and foreign keys. The same three primitives carry through — they just accumulate detail at each step. ### 47. How do cardinalities evolve as a model moves from conceptual to physical? They start as loose statements such as a customer can have multiple orders, firm up into formal logical cardinalities like 1..* or 0..1, and become physical implementations such as foreign keys, junction tables, or embedded arrays. Each refinement adds precision but also commitment. ### 48. What trade-offs arise when mapping a logical model to a document database? Document databases reward embedding for read performance but punish it when shared data changes. The trade-off is between document size and update complexity, and between query shape and storage shape. Access patterns usually drive the right answer for each collection. ### 49. How can tools automate the transition from logical to physical models? Tools can generate DDL, migrations, ORM mappings, or index recommendations from a logical model. Automation handles the mechanical work; human judgment is still needed for naming, partitioning, and performance tuning. CoreModels supports export paths for JSON Schema, JSON-LD, and code generation. ### 50. What is the risk of designing the physical model first and back-filling a logical one? The logical model becomes a rationalization of whatever the database accidentally became, rather than a principled design. Over time this hides bad decisions and makes them very hard to unwind, because the physical choices are treated as fixed rather than as implementation details. ### 51. How do you keep conceptual, logical, and physical models synchronized as changes happen? Treat them as linked artifacts with a single source of truth for the shared parts, use versioning to track divergence, automate generation from upper to lower layers where possible, and review changes as they propagate. CoreModels does this through its graph metamodel and Git integration. ### 52. What governance artifacts should accompany each modeling level? Conceptual models need business sign-off and a glossary; logical models need naming standards, validation rules, and impact analysis; physical models need migration plans, performance benchmarks, and rollback procedures. Each artifact serves a different risk at its level. ### 53. How do canonical models relate to logical and physical models? A canonical model is typically a logical model shared across many systems, each of which has its own physical model. The canonical layer is the integration lingua franca; physical layers are local implementations that map to and from it. ### 54. When should a logical model be shared externally, and when should it stay internal? Share externally when you expose APIs, integrate with partners, or publish standards — external consumers need something stable to build against. Keep internal when the model is still evolving or contains implementation-specific shortcuts that would mislead outside users. ### 55. How does CoreModels' graph approach relate to the conceptual/logical/physical distinction? CoreModels captures conceptual and logical layers natively — Types, Elements, Taxonomies, and Relations express meaning and structure without locking into a physical target. Exports to JSON Schema, JSON-LD, or code artifacts then materialize physical implementations downstream. ### 56. What is an entity-relationship (ER) diagram, and when is it most useful? An ER diagram visually represents entities, their attributes, and the relationships between them. It is most useful when the audience needs to see the shape of a domain at a glance — during discovery, design reviews, and stakeholder alignment sessions. ### 57. How do you decide what qualifies as an entity versus an attribute of another entity? If something has its own identity, lifecycle, or relationships, it is an entity; if it only describes another thing and does not stand alone, it is an attribute. An Address is usually an attribute of Customer — unless your business cares about addresses as first-class records with their own history. ### 58. What are the different notation styles (Chen, Crow's Foot, UML) and where does each shine? Chen notation is expressive and academic, Crow's Foot is compact and database-friendly, UML integrates with software engineering workflows. Pick whichever your team can read fluently — consistency matters more than purity of style. ### 59. How are weak entities represented and why do they exist? Weak entities depend on a parent for identity — a LineItem has no meaning without its Order. Notation marks them with doubled boxes or diamonds. They exist because some real-world things genuinely only exist as parts of others, and modeling them as independent would lie about the domain. ### 60. What is the difference between an identifying and a non-identifying relationship? An identifying relationship contributes to the child's identity, meaning the parent's key is part of the child's key; a non-identifying relationship is just a reference. Identifying relationships are stricter and imply a dependent lifecycle, which has cascading implications. ### 61. How do you model many-to-many relationships, and what is an associative entity? Many-to-many relationships are resolved through an associative (junction) entity that has foreign keys to both sides, plus any attributes of the relationship itself. This is how you model things like enrollments between Students and Courses, where the enrollment date belongs to neither side alone. ### 62. When should a recursive (self-referential) relationship be introduced? When instances of an entity relate to other instances of the same entity — an Employee who reports to an Employee, or a Category nested within a Category. Recursive relationships model hierarchies and networks cleanly without inventing artificial parent types. ### 63. How are supertypes and subtypes expressed in ER modeling? Supertypes hold common attributes; subtypes add specialization. Notation typically shows an inheritance arrow or a specialization triangle. This maps directly to SubClassOf relations in CoreModels, which preserves the semantics across exports. ### 64. What are the common mistakes when assigning cardinalities in an ER diagram? Common mistakes include confusing can have with must have (optionality vs. cardinality), assuming the current data reflects the rule, and ignoring what happens at the edges — what if zero, what if thousands. Each of these hides a future bug. ### 65. How do you represent optionality versus mandatory participation? Optionality is about whether participation is required (0..1 or 1..1 at the minimum side); cardinality is about the maximum (1 or many). Good notation makes both visible at each end of the relationship rather than collapsing them into a single symbol. ### 66. What is the role of surrogate keys in ER modeling? Surrogate keys are synthetic identifiers that carry no business meaning — they exist purely to provide stable, unique identity. They insulate the model from business-key changes such as renames or merges that would otherwise ripple everywhere. ### 67. When is it appropriate to model composite primary keys? Composite keys are appropriate when the natural identifier is genuinely a combination like order number plus line number, or in associative entities where the combination of foreign keys is what uniquely identifies a row. Outside those cases, a surrogate is usually cleaner. ### 68. How do you translate ER diagrams into normalized relational tables? Each entity becomes a table, each attribute a column, each one-to-many relationship a foreign key, each many-to-many a junction table. Apply normal forms to remove redundancy. Tool support makes this largely mechanical, but naming and index decisions still need human review. ### 69. What visual cues help readers quickly understand an ER diagram? Consistent notation, left-to-right data flow where possible, grouping by subdomain, colored shading for categories, clear labels on every relationship, and a legend. The goal is that a new reader can orient themselves in under a minute without asking for context. ### 70. How can ER diagrams be misleading for modern NoSQL systems? ER diagrams assume normalized structure and foreign keys, which do not exist natively in document or key-value stores. The diagram may still be useful as a conceptual view, but the physical design in NoSQL often requires denormalization and embedding that the diagram does not express. ### 71. How does ER modeling handle time-variant information? Time-variant data typically requires effective-date attributes, history tables, or versioned entities. Classic ER notation can express this, but temporal modeling benefits from explicit patterns like slowly changing dimensions or bi-temporal schemas that make time a first-class concept. ### 72. What role does an ERD legend play in team communication? A legend ensures that every reader interprets symbols and relationships the same way — especially in teams that mix notation styles or have new members. It is a small investment that prevents a disproportionate amount of miscommunication later. ### 73. How do you avoid entity explosion in complex domains? Group related entities into subdomains, use inheritance or composition to collapse near-duplicates, defer rare edge cases to extension fields, and zoom the diagram per audience. If a single diagram has a hundred boxes, the problem is navigation, not the domain. ### 74. When should business rules stay out of the ERD, and when should they be represented? Rules that affect structure such as cardinalities, required fields, and identifying relationships belong in the ERD. Rules that are procedural, stateful, or conditional usually belong in accompanying documentation or in a validation layer, not as diagram clutter. ### 75. How do enumerations and controlled vocabularies appear in ER diagrams? They are typically represented as reference entities with a many-to-one relationship, or as annotated attribute constraints. In CoreModels these are modeled as Taxonomies linked via ControlledList relations, which preserves the semantics on export. ### 76. How do you model hierarchies like organization charts with ER techniques? With a self-referencing relationship — an Employee has a manager who is also an Employee. For deep hierarchies, consider materialized paths, nested sets, or graph models if relational self-reference becomes awkward to query efficiently. ### 77. What tools are commonly used to create and maintain ER diagrams? ERD-specific tools like ER/Studio and erwin, general diagramming tools like Lucidchart and draw.io, database-integrated tools like DBeaver and DataGrip, and modern graph-native platforms like CoreModels. Choose based on whether you need to generate physical models, collaborate live, or integrate with code. ### 78. How does ER modeling complement or conflict with domain-driven design? ER and DDD can coexist: DDD provides the contextual boundaries and ubiquitous language, while ER provides the structural diagramming inside each bounded context. Conflict arises only when teams try to force one global ER diagram across many contexts at once. ### 79. How do you review an ER diagram with non-technical stakeholders? Walk through one entity at a time in business terms, read relationships as sentences such as a Customer can place many Orders, surface the rules behind each cardinality, and ask whether it matches reality. Non-technical reviewers catch business errors that specialists miss. ### 80. How do CoreModels Types and RelationGroups relate to classic ER constructs? CoreModels Types correspond to entities, Elements to attributes, Relations to relationships, and RelationGroups to categories of relationships like has-a (domainIncludes), is-a (SubClassOf), and can-be (rangeIncludes). The expressive power is a superset of classic ER because every construct is itself a node in a graph. ### 81. What is the relational model, and why has it endured for so long? The relational model organizes data into tables of rows and columns with formal set-theoretic operations. It endures because of its solid mathematical foundation, a universal query language in SQL, mature tooling, and decades of proven reliability at enterprise scale. ### 82. What does relational integrity mean, and how is it enforced? Relational integrity means the data is consistent with the model's constraints — no orphaned references, no duplicate identities, no invalid values. It is enforced through primary keys, foreign keys, unique constraints, check constraints, and not-null declarations at the database level. ### 83. How do primary keys, foreign keys, and unique constraints work together? Primary keys identify each row uniquely; foreign keys link rows across tables; unique constraints enforce uniqueness on non-primary columns. Together they form the integrity web that makes relational queries predictable and relational joins safe. ### 84. What is normalization, and what problem does each normal form solve? Normalization removes redundancy and update anomalies. First normal form eliminates repeating groups, second removes partial dependencies on composite keys, third removes transitive dependencies, and higher forms (BCNF, 4NF, 5NF) address increasingly subtle anomalies that mostly matter in specialized domains. ### 85. When is denormalization appropriate, and what are the trade-offs? Denormalization is appropriate when read performance, reporting speed, or query simplicity outweigh the cost of duplicated data. The trade-offs include larger storage, harder updates, and more opportunity for inconsistency if writes are not carefully managed through application logic or triggers. ### 86. How do you decide between a natural key and a surrogate key? Use a natural key when the business identifier is truly immutable, unique, and short — such as country codes or ISBNs. Use a surrogate when the natural candidate is long, mutable, or potentially duplicated. Most production systems lean on surrogates and keep natural keys as unique indexes. ### 87. What are composite keys, and when are they the right choice? Composite keys combine multiple columns to form a unique identifier — often in associative tables like student_id plus course_id, or in domains where identity is genuinely multi-part such as order_id plus line_number. They are correct when the combination has semantic meaning on its own. ### 88. How do indexes affect data modeling decisions? Indexes do not change the logical model but they strongly shape the physical one. Choices about clustered versus non-clustered, covering indexes, and partitioning follow from expected query patterns. Over-indexing slows writes; under-indexing slows reads. Balance is specific to workload. ### 89. What is referential integrity, and how is it maintained across systems? Referential integrity means every foreign key points to a valid primary key. It is maintained within a database by declared constraints, and across systems by contracts, event choreography, or reconciliation jobs — each with different guarantees about latency and strictness. ### 90. How do you model inheritance (table-per-hierarchy, table-per-type, table-per-concrete-class) in a relational database? Table-per-hierarchy puts all subtypes in one wide table with a discriminator column; table-per-type uses a base table plus child tables joined by key; table-per-concrete-class duplicates base columns per subtype. Each trades query simplicity against storage efficiency and integrity. ### 91. How do you model polymorphic relationships without sacrificing integrity? Options include a separate link table per target type (integrity-preserving but verbose), a typed foreign key (convenient but integrity-weak), or using a supertype table that every variant inherits from. The right choice depends on query patterns and tolerance for denormalization. ### 92. What are views, materialized views, and when should each be used in modeling? A view is a saved query that presents a reshaped virtual table; a materialized view stores the result for faster reads at the cost of freshness. Use views to simplify access without duplicating data, and materialized views when read performance dominates over real-time accuracy. ### 93. How do constraints (CHECK, NOT NULL, DEFAULT) reinforce a data model? They move validation from application code into the database, where it cannot be bypassed by direct inserts or forgotten by a new service. They also act as executable documentation of business rules — if a rule lives in a CHECK constraint, it is both enforced and visible. ### 94. When should stored procedures or triggers encode modeling rules versus the application layer? Use database-level enforcement for invariants that must hold regardless of how data arrives — integrity, audit trails, derived timestamps. Keep business workflows in the application layer where they are easier to test, version, and evolve alongside product changes. ### 95. What is the role of third normal form (3NF) versus Boyce–Codd normal form (BCNF)? 3NF eliminates transitive dependencies where non-key attributes depend on other non-key attributes; BCNF is a stricter form that also handles overlapping candidate keys. BCNF is usually the goal for transactional systems, though most real schemas stop at practical 3NF and live happily. ### 96. How do you model slowly changing dimensions in a relational warehouse? Type 1 overwrites history, Type 2 keeps versioned rows with effective dates, Type 3 keeps limited prior values in additional columns, and hybrid types combine these. The choice depends on how much history analysts need and how costly extra rows are at your volume. ### 97. What are star schemas and snowflake schemas, and how do they differ? Star schemas have a central fact table surrounded by denormalized dimension tables — fast and simple. Snowflake schemas normalize the dimensions further into sub-dimensions — less redundant but requiring more joins. Star is typical for reporting, snowflake for storage efficiency at larger scale. ### 98. How does relational modeling handle hierarchical and recursive data? Through self-referencing foreign keys (simple but slow for deep queries), adjacency lists, materialized paths, nested sets, or closure tables. Each approach trades read versus write performance and query complexity differently, and the best choice depends on how hierarchies are traversed in practice. ### 99. What is the impact of data types (VARCHAR, TEXT, NUMERIC, UUID) on model quality? Data types encode validation, storage footprint, and semantics. Wrong choices — everything as VARCHAR, timestamps as strings, currency as floats — cause subtle bugs that compound over time. Pick types that match the data's real nature, not whatever was convenient for the first insert. ### 100. How do you evolve a relational schema with zero downtime? Use additive changes first (new nullable columns, new tables), ship code that reads both old and new shapes, backfill data in the background, switch writes to the new shape, and finally remove the old. Breaking changes are almost always avoidable with enough steps and patience. CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connectors | CoreModels" description: "Bring the file your tools already produce — a dbt manifest, a registry dump, a warehouse extract. No passwords. Every card says what you can do today." canonical: "https://www.coremodels.io/connectors" last_updated: "2026-09-15" --- # Connectors for the stack you already run Bring the file your tools already produce — a dbt manifest, a registry dump, a warehouse extract. No passwords. [Import your dbt project](https://www.coremodels.io/connector/dbt) Search connectors Showing 26 of 26 connectors in Alls Alls Platforms Formats [AirbyteGovern the catalog every sync trusts - before a silent type change lands in the warehouse.Connect Airbyte →](https://www.coremodels.io/connector/airbyte)[Apache AirflowGovern the scheduler that already knows your freshness, ownership, and lineage.Connect Apache Airflow →](https://www.coremodels.io/connector/airflow)[ConfluentPut meaning under every Kafka subject the Schema Registry already inventories.Connect Confluent →](https://www.coremodels.io/connector/confluent)[DatabricksGive Unity Catalog something to check thousands of columns against.Connect Databricks →](https://www.coremodels.io/connector/databricks)[dbtYour dbt project already holds the definitions, copied into every `accepted_values` list that tests a column. Bring a manifest; we connect the copies into one vocabulary you govern and your agent can read.Import your dbt project →](https://www.coremodels.io/connector/dbt)[Google BigQueryTurn INFORMATION_SCHEMA from an inventory into a contract you can audit.Connect Google BigQuery →](https://www.coremodels.io/connector/bigquery)[JSON SchemaStop asking a validator four questions it was only built to answer one of.Import a JSON Schema file →](https://www.coremodels.io/connector/jsonschema)[SalesforceGovern the org whose schema can change in forty seconds from Setup.Connect Salesforce →](https://www.coremodels.io/connector/salesforce)[SnowflakeYour Snowflake schema is not a contract. Generate one from the governed model.Connect Snowflake →](https://www.coremodels.io/connector/snowflake)[Apache AvroOne governed reading of the schema that currently lives in four places.Import a Apache Avro file →](https://www.coremodels.io/connector/avro)[AWS GlueStop treating a crawler snapshot as the meaning of your lake.Connect AWS Glue →](https://www.coremodels.io/connector/glue)[Azure SynapseRecord the constraints that die on the way to a registered schema.Connect Azure Synapse →](https://www.coremodels.io/connector/synapse)[cBioPortalGovern the four comment rows that are the schema of your study.Connect cBioPortal →](https://www.coremodels.io/connector/cbioportal)[JSON-LDMake the vocabulary you already trust executable downstream.Import a JSON-LD file →](https://www.coremodels.io/connector/jsonld)[LinkMLLet the pipeline read the model that is already right.Import a LinkML file →](https://www.coremodels.io/connector/linkml)[MACH ODMStop shipping a recollection of the standard as if it were the standard.Import a MACH ODM file →](https://www.coremodels.io/connector/odm)[Microsoft FabricCatch the warehouse type change that never pages anyone.Connect Microsoft Fabric →](https://www.coremodels.io/connector/fabric)[Neo4jWrite down the graph schema MERGE has been inferring for you.Connect Neo4j →](https://www.coremodels.io/connector/neo4j)[ODCSMake the contract a derived artifact of governed meaning, not a YAML twin of the table.Import a ODCS file →](https://www.coremodels.io/connector/odcs)[Open Semantic InterchangePut two revenue numbers next to the same definition.Connect Open Semantic Interchange →](https://www.coremodels.io/connector/osi)[OWLKeep the ontology and the application schema from becoming two portraits of Person.Import a OWL file →](https://www.coremodels.io/connector/owl)[Protocol BuffersCarry reserved field numbers with the meaning, not only with the .proto file.Import a Protocol Buffers file →](https://www.coremodels.io/connector/protobuf)[REDCapDiff the codebook so a study change is a review, not a memory.Connect REDCap →](https://www.coremodels.io/connector/redcap)[Schema ConverterA neutral hub between fourteen schema formats, with an honest lossiness ledger.Connect Schema Converter →](https://www.coremodels.io/connector/converter)[ShExKeep the four assertions in every shape constraint from dying in a hand copy.Import a ShEx file →](https://www.coremodels.io/connector/shex)[SQLGive the column nobody can explain a rule the database can actually carry.Import a SQL file →](https://www.coremodels.io/connector/sql) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "CoreModels Pricing — Builder $49, Team $990, Enterprise" description: "Builder $49/mo. Team $990/mo with 10 seats. Founding teams $5,880 for year one, billed annually, through 30 September. 14-day free trial." canonical: "https://coremodels.io/pricing" last_updated: "2026-09-15" --- # Your schemas, connected. So AI can build across them. CoreModels holds the mappings and governed meaning between your data and content platforms, warehouse, API and ontology schemas, and the public standards they connect to. Whatever you build or transform with AI works from the connected picture: no manual stitching, no guessed structure, no hallucinated mappings. Pipelines, integrations, agents and apps all read from one Core Model. A library of connectors. Simple pricing per builder, per team, or for the whole enterprise. 14-day free trial · No charge during trial · Cancel anytime · Unlimited view-only users on every plan · Agent endpoint on every plan Solo work. Team evaluation. ### Builder $49/ month 14-day free trial One seat, full access. For individual practitioners and team evaluators exploring CoreModels before bringing it to their team. 1 builder seat · up to 3 projects Up to 100,000 nodes per model Unlimited view-only collaborators Full import & export suite Standard transformation profiles Schema validation suite Schematica Library access MCP agent endpoint · 15 concurrent requests per agent Version history — 30 days Standard API access Usage dashboard Email support · 2 business days By starting a trial you agree to the [Terms of Service](https://www.coremodels.io/legal/terms) and [Privacy Policy](https://www.coremodels.io/legal/privacy). Payment is taken by Ariesnet, Inc. under Schematica, our suite of solutions — your card statement will show SCHEMATICA. [Start free trial](https://go.coremodels.io/payment/subscribe?plan=personal) Where teams build in production. ### Team Founding teams: $11,880 $5,880 for the first year, billed annually — the equivalent of $490 / month · renews at $11,880 / year · first 10 teams · ends 30 September $990/ month 14-day free trial Built for teams actively modeling in production. Versioning, governance, and the collaboration depth real workflows require. Everything in Builder, plus: 10 builder seats included · $99/month per additional seat · up to 10 projects Up to 1,000,000 nodes per model Schema versioning with branching Changelog Version history — 90 days Expanded API access Usage analytics & team dashboard Extended export formats Unlimited view-only collaborators Transformation profiles Full import & export suite MCP agent endpoint · 15 concurrent requests per agent Email support · 24h response By starting a trial you agree to the [Terms of Service](https://www.coremodels.io/legal/terms) and [Privacy Policy](https://www.coremodels.io/legal/privacy). Payment is taken by Ariesnet, Inc. under Schematica, our suite of solutions — your card statement will show SCHEMATICA. [Claim a founding seat](https://go.coremodels.io/payment/subscribe?plan=team&period=annual)[Start free trial](https://go.coremodels.io/payment/subscribe?plan=team) No limits. Governed at scale. ### Enterprise from $4,000/ month For organizations where schema governance is mission-critical. Tailored to your infrastructure, team size, and compliance requirements. RBAC · SSO/SAML · IP allowlisting Audit logs 99.9% uptime SLA with service credits [Read the SLA](https://www.coremodels.io/legal/sla) Private schema vaults Dedicated infrastructure & enhanced performance Private cloud & on-premise deployment — priced separately Unlimited projects, users & schema scale Full import & export suite All export formats Custom transformation profiles Schema lineage & cross-system mapping MCP agent endpoint · governed throughput Governed API throughput Git integration + CI/CD triggers Full version history & backups Dedicated onboarding support Priority support · 4 business hours · named contact Data residency, SSO provider, and deployment model set in contract. [Contact Sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) All paid plans include unlimited view-only users at no cost. Share a project with a public view link when you choose to. Off by default. If billing pauses, projects remain in read-only mode. Connector status — GA or early access — is shown on every [connector page](https://www.coremodels.io/connectors). ## Built on a methodology proven in enterprise environments The Core Content Model® methodology was proven at these organizations, where we organized the content and data models they already had — across systems, formats, representational states and standards — into one harmonized, mapped core model for their applications. CoreModels the product grew out of that work. Founding teams ## $5,880 for the first year. Then $11,880. Everything in Team, billed annually — $5,880 for your first year instead of the $11,880 list price, the equivalent of $490 / month. It renews at list. Founding seats are annual only; the standard Team plan can still be paid monthly. For the first 10 teams. Closes 30 September or when the seats are gone. [Claim a founding seat](https://go.coremodels.io/payment/subscribe?plan=team&period=annual) By starting a trial you agree to the [Terms of Service](https://www.coremodels.io/legal/terms) and [Privacy Policy](https://www.coremodels.io/legal/privacy). Payment is taken by Ariesnet, Inc. under Schematica, our suite of solutions — your card statement will show SCHEMATICA. ## Questions Choosing a plan ### Which plan is for me? Builder if one person is doing the modeling and others need to read it. Team if two or more people edit the same models. Enterprise if you need SSO, an SLA, dedicated infrastructure, or an agreement your procurement team signs. ### What is a "project"? One governed model and everything in it: types, elements, taxonomies, mappings, versions, and the connectors that feed it. Most teams run one project per domain or per source system. ### What counts as a node? Any type, element, taxonomy term, or value in a model. A 300-model dbt project at about 8 columns each is roughly 2,400 nodes before vocabularies. Builder allows 100,000 nodes per model, Team 1,000,000. If you hit a cap, tell us. ### What is a seat? A person who can edit. Viewers are free and unlimited on every plan, and agents are not seats. Trial and billing ### Does the trial need a card? Yes. Nothing is charged during the 14 days. Cancel before day 15 and you are never charged. [Full Billing, Cancellation & Refunds →](https://www.coremodels.io/legal/refunds) ### What happens when the trial ends? Your projects stay, read-only, until you subscribe. Nothing is deleted. ### Can I cancel? Any time, from your account. You keep access to the end of the paid period. Monthly plans are not refunded for partial months; annual plans are refundable within 14 days. ### Can we pay by invoice? Team and Enterprise can pay annually by invoice, net 30. Builder is by card. ### How does the founding offer work? The first 10 teams pay $5,880 for their first year, billed annually in advance, instead of the $11,880 list price — the equivalent of $490/month. It renews at the list price. Founding seats are annual only; the standard Team plan can still be paid monthly. Extra seats beyond 10 are $99/month each. Seats, projects, and growth ### We are five editors. Do we need Team? If the five need to edit the same models, yes — five Builder accounts are five separate workspaces. Team includes 10 seats; you don’t have to use them all. ### What if we need more than 10 seats or 10 projects? Seats: $99/month each, added from your account. Projects: Team includes 10. If you need more, tell us how many — we price additional projects on Team without moving you to Enterprise. ### Can we switch plans? Upgrade any time, prorated. Downgrade at the next renewal. If a downgrade puts you over the smaller plan’s limits, the extra items become read-only rather than deleted. Agents and the MCP endpoint ### Do agents count as seats? No. Agents read the governed model through the MCP endpoint on every plan, using the same permissions as the person whose credentials they run under. ### Are there limits on agent traffic? Each agent gets up to 15 concurrent in-flight requests. Above that it receives a rate-limit response and retries. Enterprise plans set throughput in contract. ### My agent can already read dbt, or my warehouse. Why CoreModels? A tool knows its own project: dbt knows your dbt, a catalog knows its tables. Neither knows that customer_id in the warehouse is the same entity as accountRef in the CRM and Person in your content model, or which of the three the business considers true. That judgment lives in your people; CoreModels is where it is written down once and read by every agent, across every system. It consumes what your tools already produce as inputs, and most teams run both. [Why CoreModels →](https://www.coremodels.io/framework/why) ### Can agents write, or only read? Both, within the permissions of the account they run under. Every write is versioned, so an agent’s changes are reviewable and reversible like anyone else’s. Agent prompts and agent traffic are not used to train models. Security and legal ### Who owns our models? You do. Export everything at any time with the export tools. We do not sell your data and we do not use it to train models. [Terms of Service →](https://www.coremodels.io/legal/terms) ### Do you need our warehouse credentials? No. CoreModels imports the artifacts your tools already produce. [Security Overview →](https://www.coremodels.io/legal/security) ### Is there a DPA? Yes, for Team and Enterprise, including EU Standard Contractual Clauses where required. [Data Processing Addendum →](https://www.coremodels.io/legal/dpa) ### Is there an SLA? Enterprise plans carry a 99.9% monthly uptime commitment with service credits. Builder and Team run on the same infrastructure without a credit schedule. [Service Level Agreement →](https://www.coremodels.io/legal/sla) ### Who is the contracting entity? Ariesnet, Inc., a Texas corporation. Enterprise agreements, DPAs, and security questionnaires go through Ariesnet. ### Do you have an accessibility statement? We are working toward WCAG 2.1 AA; a VPAT is available on request. ### Can we get an MSA and order form? Yes. Enterprise engagements run on our Master Subscription Agreement and an order form your procurement team can redline. Ask us. ### How do we onboard you as a vendor? We provide a W-9, banking details for invoice payment, and complete vendor forms on request. Invoices are issued by Ariesnet, Inc. ### What currency do you bill in? Prices are listed in US dollars. At checkout you may be shown, and charged, the total in your local currency at the payment processor's rate. Enterprise and Partner ### What does "from $4,000/month" include? SSO/SAML, audit logs, the SLA, dedicated infrastructure, and an agreement your procurement team can sign. The exact number depends on scale and deployment model. ### Enterprise or Partner? Enterprise is one organization governing its own schemas. Partner is a hub governing a shared core across independent units — a consortium, a holding company, a federation of agencies. Partner is applied for, priced annually, and includes a discounted Enterprise license. ### Can you run the first model with us? Yes. Guided engagements are available for teams that want ARAMAI alongside them for the first model. Ask us. Not a tier — a relationship ### Partner Program Discounted Enterprise License For organizations governing a shared schema core across multiple independent units — teams, divisions, departments, or partner organizations that each manage their own schemas while a common foundation must stay governed and consistent. What qualifies Research consortia, holding companies, franchise networks, global NGOs, government agencies, and any organization with a hub-and-spoke data governance requirement. [Apply for Partnership →](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) What partners receive Everything in Enterprise Federated Workspace Architecture — Core + Unit Workspaces Schema propagation & drift control across units Cross-unit audit logs Dedicated governance partner — regular check-ins & follow-up Roadmap access & co-development What partners contribute Co-marketing and logo placement Collaborative research opportunities Product feedback and roadmap co-development Press release and case study collaboration Pricing negotiated annually based on the scope of the partnership and number of federated units. The Partner Program is applied for — not purchased. 14-day free trial on Builder and Team · Cancel anytime · No charges during trial CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Guides | CoreModels" description: "Articles that explain the gap, then point at the recipe that closes it." canonical: "https://www.coremodels.io/guides" last_updated: "2026-09-15" --- # Guides Articles that explain the gap, then point at the recipe that closes it. [Airbyte10 guides](https://www.coremodels.io/connector/airbyte#uses)[Apache Airflow10 guides](https://www.coremodels.io/connector/airflow#uses)[Confluent10 guides](https://www.coremodels.io/connector/confluent#uses)[Databricks10 guides](https://www.coremodels.io/connector/databricks#uses)[dbt18 guides](https://www.coremodels.io/connector/dbt#uses)[General10 guides](https://www.coremodels.io/connector/general#uses)[Google BigQuery10 guides](https://www.coremodels.io/connector/bigquery#uses)[JSON Schema10 guides](https://www.coremodels.io/connector/jsonschema#uses)[Salesforce10 guides](https://www.coremodels.io/connector/salesforce#uses)[Snowflake10 guides](https://www.coremodels.io/connector/snowflake#uses)[Apache Avro10 guides](https://www.coremodels.io/connector/avro#uses)[AWS Glue10 guides](https://www.coremodels.io/connector/glue#uses)[Azure Synapse11 guides](https://www.coremodels.io/connector/synapse#uses)[cBioPortal12 guides](https://www.coremodels.io/connector/cbioportal#uses)[JSON-LD10 guides](https://www.coremodels.io/connector/jsonld#uses)[LinkML10 guides](https://www.coremodels.io/connector/linkml#uses)[MACH ODM10 guides](https://www.coremodels.io/connector/odm#uses)[Microsoft Fabric10 guides](https://www.coremodels.io/connector/fabric#uses)[Neo4j10 guides](https://www.coremodels.io/connector/neo4j#uses)[ODCS10 guides](https://www.coremodels.io/connector/odcs#uses)[Open Semantic Interchange10 guides](https://www.coremodels.io/connector/osi#uses)[OWL10 guides](https://www.coremodels.io/connector/owl#uses)[Protocol Buffers10 guides](https://www.coremodels.io/connector/protobuf#uses)[REDCap10 guides](https://www.coremodels.io/connector/redcap#uses)[ShEx10 guides](https://www.coremodels.io/connector/shex#uses)[SQL10 guides](https://www.coremodels.io/connector/sql#uses) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Terms of Service | CoreModels" description: "The terms that govern your use of CoreModels: the service, your account, plans and payment, your data, acceptable use, availability, and liability." canonical: "https://coremodels.io/legal/terms" last_updated: "2026-09-15" --- # Terms of Service Last updated: 3 September 2026 Contracting entity: Ariesnet, Inc. These terms govern your use of CoreModels, a service operated by Ariesnet, Inc. (“Ariesnet”, “we”). ARAMAI is the product group of Ariesnet, Inc., a Texas corporation. CoreModels is its platform, as part of the Schematica suite of solutions. Ariesnet contracts, builds and integrates for clients, and operates; ARAMAI does the research and makes the software. Payments are processed under the Schematica name, so your card statement and payment receipts will show SCHEMATICA. By creating an account or starting a trial you agree to these terms. If you are accepting on behalf of an organization, you confirm you have authority to do so. 1. The service. CoreModels lets you import, govern, and publish schemas and the meaning between them, and exposes that model to people and to AI agents. We may improve, add to, or retire features. We give at least 30 days’ notice before removing a feature that a paid plan depends on. 2. Your account. You are responsible for activity under your account and for keeping credentials secure. Builder accounts are for one named person. Team seats may be reassigned between people on your team. 3. Plans, trials, and payment. Plans and prices are as shown at coremodels.io/pricing on the day you subscribe. Trials require a payment method and are not charged until the trial ends. Subscriptions renew automatically until cancelled. Prices for an active subscription do not change without 30 days’ notice. Taxes are added where required. See [Billing, Cancellation & Refunds](https://www.coremodels.io/legal/refunds). 4. Your data. You own the schemas, models, mappings, and content you bring to or create in CoreModels (“Customer Data”). We do not sell Customer Data, and we do not use Customer Data to train machine-learning models. We process it only to run the service for you and as described in the Privacy Policy and, for organizations, the [Data Processing Addendum](https://www.coremodels.io/legal/dpa). You can export Customer Data at any time using the export tools in the product. 5. Acceptable use. Don’t use the service to break the law, to infringe someone else’s rights, or to attack, overload, or reverse-engineer it. Automated access is allowed and expected through the MCP endpoint and API within the rate limits shown on the pricing page. 6. Our IP. The CoreModels software, the Schematica library structure, and our documentation are ours. Public standards and schemas from the Schematica Library remain under their own licenses. 7. Availability and support. We work to keep the service available and to respond to support requests within the times shown for your plan. Enterprise customers receive the [Service Level Agreement](https://www.coremodels.io/legal/sla). Builder and Team plans are provided with commercially reasonable efforts and no uptime commitment. 8. Suspension and termination. You can cancel at any time from your account. If your subscription lapses, your projects become read-only; nothing is deleted for 90 days, after which we may delete them. We may suspend accounts that violate these terms, with notice where practical. 9. Disclaimers and limits. The service is provided “as is” to the extent permitted by law. Neither party is liable for indirect or consequential loss. Our total liability under these terms is limited to the fees you paid in the 12 months before the claim. Nothing limits liability that cannot be limited by law. 9a. Intellectual-property indemnity. For Team and Enterprise subscriptions, we will defend you against third-party claims that the CoreModels service, as provided by us, infringes their intellectual property, and pay resulting damages awarded or agreed in settlement, provided you notify us promptly and let us control the defence. This does not cover claims arising from Customer Data, your modifications, or use in breach of these terms. 9b. Confidentiality. Each of us will keep the other's non-public information confidential and use it only for the purposes of the service. Customer Data is your confidential information. 9c. Publicity. We will not name you as a customer, or use your name or logo, without your written consent. 10. Enterprise agreements. If you have signed a separate agreement with Ariesnet, that agreement controls where it conflicts with these terms. 11. Governing law. Texas law applies. Disputes are resolved in the state or federal courts in Texas, unless your enterprise agreement says otherwise. 12. Changes. We may update these terms. Material changes are announced by email or in-product at least 30 days before they take effect. Questions: [legal@aramai.net](mailto:legal@aramai.net) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Data Processing Addendum | CoreModels" description: "How CoreModels handles personal data for organizations subject to GDPR or similar law: our processor commitments, where data is processed, subprocessors, and how to request the full DPA." canonical: "https://coremodels.io/legal/dpa" last_updated: "2026-09-15" --- # Data Processing Addendum Last updated: 3 September 2026 Contracting entity: Ariesnet, Inc. If you are an organization subject to GDPR, UK GDPR, or similar law, Ariesnet acts as your processor for the personal data inside Customer Data, and you are the controller. Our full DPA is available on request; it includes the EU Standard Contractual Clauses where required. What we commit to in the DPA. Process personal data only on your instructions and to provide the service · keep it confidential · apply the technical and organisational measures in our [Security Overview](https://www.coremodels.io/legal/security) · notify you of a personal-data breach without undue delay and in any case within 48 hours of confirming it · help you respond to data-subject requests · delete or return personal data at the end of the contract · use only the subprocessors listed below · allow audits on reasonable notice. We give at least 30 days' notice before adding or replacing a subprocessor, and you may object on reasonable data-protection grounds. On termination we delete Customer Data within 90 days and confirm deletion in writing on request. Where data is processed. United States Subprocessors: Stripe (payment processing),Azure (hosting provider),Google and Microsoft (authentication provider, and email provider),PostHog (analytics),Brevo (CRM) Request the DPA: [legal@aramai.net](mailto:legal@aramai.net) with your organization name and the plan you are on. Team and Enterprise customers can sign it; Builder accounts are covered by the Privacy Policy. Questions: [legal@aramai.net](mailto:legal@aramai.net) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Security Overview | CoreModels" description: "Written for a buyer’s security review: credential-free import, isolation, encryption, access control, agent access through the MCP endpoint, backups, and how to report a vulnerability." canonical: "https://coremodels.io/legal/security" last_updated: "2026-09-15" --- # Security Overview Last updated: 3 September 2026 Contracting entity: Ariesnet, Inc. Written for a buyer’s security review. Where a line says “on request”, email [legal@aramai.net](mailto:legal@aramai.net). Credential-free import. CoreModels imports the artifacts your tools already produce (for example dbt manifests, JSON Schema files, OpenAPI documents). It does not need your warehouse, database, or API credentials to build a model. Isolation. Each customer’s projects are logically isolated. Enterprise plans can be deployed on dedicated infrastructure or in your private cloud. Encryption. Data in transit is encrypted using TLS 1.2 or higher. All customer data is encrypted at rest using industry-standard encryption. Encryption keys are managed and rotated following best practices. Access control. Role-based access on all plans (builder / view-only). Enterprise adds SSO/SAML, IP allow-listing, and audit logs. Agents and the MCP endpoint. Agents authenticate with the same credentials as people and inherit the same project permissions. Each principal is limited to 15 concurrent in-flight requests; Enterprise throughput is set in contract. Access. Production access is limited to named engineers, protected by MFA, and logged. Backups and retention. Backups run daily. The retention window and the restore-test cadence are available on request. Certifications. We do not currently hold SOC 2 or ISO 27001 certification. These are on our roadmap. While certification is on the roadmap. We will complete your security questionnaire (SIG Lite, CAIQ, or your own) within 10 business days. We will schedule an external penetration test before the first Enterprise renewal. Enterprise contracts can include a right to audit on 30 days' notice. Vulnerability reporting. [security@aramai.net](mailto:security@aramai.net) We acknowledge within 2 business days. Subprocessors and hosting region. See the [Data Processing Addendum](https://www.coremodels.io/legal/dpa). Questions: [legal@aramai.net](mailto:legal@aramai.net) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Service Level Agreement | CoreModels" description: "The Enterprise service level agreement for CoreModels: a 99.9% monthly uptime commitment, how uptime is measured, the credit schedule, and support response times." canonical: "https://coremodels.io/legal/sla" last_updated: "2026-09-15" --- # Service Level Agreement Last updated: 3 September 2026 Contracting entity: Ariesnet, Inc. This SLA applies to Enterprise plans and to any plan where an Ariesnet agreement says it applies. Builder and Team plans are not covered by uptime credits. Commitment. Monthly uptime of 99.9% for the CoreModels application, API, and MCP endpoint, measured per calendar month. How we measure. Uptime = (minutes in the month − minutes of Downtime) ÷ minutes in the month. “Downtime” means the service returns errors or is unreachable for all users for more than 5 consecutive minutes, as recorded by our monitoring tools. Until a public status page is live, uptime reports are available on request (generated from our hosting provider's monitoring). What is not Downtime. Scheduled maintenance (announced at least 48 hours ahead, at most 4 hours per month, outside 09:00–18:00 US Central); rate-limit responses returned when a client exceeds the limits on the pricing page; problems caused by your network, your integrations, or third parties outside our control; force majeure; and beta or early-access features, which are labelled as such. Credits. | Monthly uptime | Credit (% of that month’s fee) | | --- | --- | | 99.0% – < 99.9% | 10% | | 95.0% – < 99.0% | 25% | | < 95.0% | 50% | Credits are your sole remedy for missed uptime, apply to future invoices, and must be requested within 30 days of the month in question. Support response. Enterprise: priority queue, first response within 4 business hours (US Central), named contact for onboarding. Team: email, first response within 24 hours. Builder: email, first response within 2 business days. Data durability. Customer Data is backed up daily. Retention windows and the restore-test cadence are available on request. Questions: [legal@aramai.net](mailto:legal@aramai.net) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Billing, Cancellation & Refunds | CoreModels" description: "How billing works on CoreModels: the 14-day trial, monthly and annual plans, changing plans, the founding team rate, lapsed accounts, and taxes." canonical: "https://coremodels.io/legal/refunds" last_updated: "2026-09-15" --- # Billing, Cancellation & Refunds Last updated: 3 September 2026 Contracting entity: Ariesnet, Inc. Who charges you. Ariesnet, Inc. takes payment under Schematica, our suite of solutions. Your card statement and payment receipts will show SCHEMATICA. If you do not recognise a charge, that is why — contact us before disputing it and we will sort it out. Trials. 14 days, a payment method is required, and nothing is charged during the trial. If you cancel before the trial ends you are never charged. If you do nothing, the plan you chose starts on day 15. Monthly plans. Charged on the same day each month. Cancel any time from your account; you keep access until the end of the paid period. We do not refund partial months. Annual plans and invoices. Team and Enterprise can pay annually by invoice, net 30. Annual plans are refundable in full within 14 days of the first payment, and not after that. Changing plans. Upgrade any time; the difference is prorated. Downgrade takes effect at the next renewal. If a downgrade puts you over the smaller plan’s limits (seats, projects, nodes), the extra items become read-only, not deleted. Founding teams. A founding seat is an annual Team subscription: $5,880 charged in advance for the first year instead of the $11,880 list price — the equivalent of $490/month — renewing at the list price. The Annual plans clause above governs it, including the 14-day refund window. Additional seats beyond 10 are billed at the standard seat price. Cancel any time to stop the renewal; the founding rate is not transferable to a new account. Lapsed accounts. If payment fails we retry for 14 days and email you. After that the account becomes read-only. Nothing is deleted for 90 days. Taxes. Prices exclude VAT, GST, and sales tax, which we add where we are required to collect them. Questions: [legal@aramai.net](mailto:legal@aramai.net) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Airbyte | CoreModels" description: "Govern the catalog every sync trusts - before a silent type change lands in the warehouse." canonical: "https://coremodels.io/connector/airbyte" last_updated: "2026-09-15" --- Early access # Connect Airbyte Govern the catalog every sync trusts - before a silent type change lands in the warehouse. [Connect Airbyte](https://go.coremodels.io/app/new/airbyte/generic)[Airbyte site](https://airbyte.com/) Recipes ## Recipes Recipes for Airbyte ### Blank Airbyte project A preconfigured home for governing Airbyte catalogs - bring your catalog now or later. [Related use →](https://www.coremodels.io/connector/airbyte/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/airbyte/generic) ### CI Drift Gate for Airbyte Fail the build before a source schema change lands in your warehouse. [Related use →](https://www.coremodels.io/connector/airbyte/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/airbyte/ci-drift-gate) ### First Governed Import for Airbyte Turn your Airbyte catalog into a governed model in one upload. [Related use →](https://www.coremodels.io/connector/airbyte/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/airbyte/first-governed-import) ### Source Onboarding Review Govern a new source at the door - before its first sync. [Related use →](https://www.coremodels.io/connector/airbyte/h1-need)[Start this recipe](https://go.coremodels.io/app/new/airbyte/source-onboarding-review) Connector summary ## What the recipes deliver Import an Airbyte catalog and CoreModels turns each stream’s declared schema - property names, types, nullability, enums, primary keys, and sync modes - into a governed model. Re-import later and the audit trail shows exactly which streams drifted, instead of waiting for a dashboard to go quietly wrong. ## How CoreModels works with Airbyte Airbyte connections already know more than most teams use. Every stream publishes a JSON Schema plus keys, cursors, and supported sync modes. That declaration is usually treated as plumbing - discovered once, configured once, trusted forever. CoreModels treats the catalog as an estate you can govern. Streams become types, properties become elements, enums become taxonomies, and keys become identity rules. The first import records a baseline. Every later catalog snapshot is audited against that baseline, so a numeric total that became a currency-prefixed string is a named finding, not an incident three days later. Pair the import with the CI drift gate recipe and the check runs where reviews already happen. Pair it with source onboarding review and new connections get a human look at meaning before they ever write a warehouse table. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemSchema Changes Don't Knock: Why Airbyte Pipelines Need a Front DoorAn application team ships a routine release, and somewhere in their product database a numeric total becomes a string with a currency prefix. No announcement reaches the data team - schema changes don't knock. Airbyte keeps syncing, because moving data is its job. The warehouse keeps loading, because storing data is its job. Every sync stays green while the numbers drift quietly out of truth, until a human happens to squint at them. The only thing that broke was the meaning of the data, and meaning was the one thing no part of that pipeline was watching.Recipe: Source Onboarding Review](https://www.coremodels.io/connector/airbyte/h1-need)[OutcomesThe Quiet Week: Life With a Governed Airbyte ConnectionThe most convincing demo of schema governance is a boring week. No archaeology through sync logs, no "who changed this?" threads, no Friday backfill. What follows is a composite week for a data engineer who owns an Airbyte deployment after the catalog is governed in CoreModels - and, running alongside it, the same week as it used to go.Recipe: CI Drift Gate for Airbyte · First Governed Import for Airbyte · Source Onboarding Review](https://www.coremodels.io/connector/airbyte/h2-outcomes)[GovernanceFive Commitments We Make Before Touching Your Airbyte CatalogAny tool that asks to sit between your data sources and your governed schemas is asking for a lot of trust. We think that trust should rest on verifiable commitments rather than assurances - specific behaviors, designed into the system, that you can test before you rely on them. Here are the five that govern how CoreModels handles an Airbyte catalog, and why each one exists.](https://www.coremodels.io/connector/airbyte/h3-governance)[EcosystemOpen Pipes, Open Meaning: Airbyte's Place in a Neutral Governance LayerAirbyte's founding bet was that data movement should be open: an open-source platform, a connector catalog anyone can extend, and - the part that matters most for governance - schemas declared in the open. Every Airbyte stream describes itself with JSON Schema inside a catalog document: property names and types, nullability expressed as type arrays, enums, primary keys, supported sync modes. You can extract that catalog from your own instance with a single API call. No proprietary binary, no export ceremony.](https://www.coremodels.io/connector/airbyte/h4-ecosystem)[AgentsFrom Plausible to Provable: Giving AI Agents the Truth About Your Airbyte StreamsWatch a coding agent write transformation logic against ingested data and you can see the exact moment it starts making things up. Asked to build staging models over an Airbyte-landed orders stream, it will confidently produce column lists it inferred from the table name, treat every id as a unique key, assume updated_at implies incremental sync, and enumerate status values it has seen in other companies' schemas. The output is fluent, well-formatted, and structurally fictional - not because the model is weak, but because nothing in its context contained the actual schema. Agents don't fail loudly on missing ground truth; they interpolate over it.](https://www.coremodels.io/connector/airbyte/h5-agents)[QuickstartZero to First Audit: Putting an Airbyte Catalog Under GovernanceEverything in this tutorial happens in a shell. There is no agent to install in your Airbyte deployment, no warehouse connection to configure, and no credential of yours that ever reaches CoreModels. You export one JSON document that Airbyte already produces, upload it, and ask a question about it.Recipe: Blank Airbyte project · First Governed Import for Airbyte](https://www.coremodels.io/connector/airbyte/t1-quickstart)[APIEvery Verb, Every Role: The Airbyte HTTP SurfaceOne sentence in the controller sets the shape of everything below it: the vendor integration surface is read-authority. Import writes to the graph, and only additively. Audit and generate never write anything. Recording an audit run in the history is opt-in bookkeeping - except for re-audit, which always records its run because that is the whole point of the verb.](https://www.coremodels.io/connector/airbyte/t2-api)[MCPTool Calls, Not Screenshots: Running an Airbyte Audit from an AI AgentThere are two ways to let an AI assistant help with an ingestion catalog. The first is to paste the catalog into a prompt and ask what looks risky - fast, ungrounded, unverifiable. The second is to give the assistant a tool that runs the real audit against your governed model and returns coded findings. This article is about the second one.](https://www.coremodels.io/connector/airbyte/t3-mcp)[AutomationA Drift Gate for Airbyte: CI, Badges, and the Heartbeat Between RunsA dbt gate has an obvious trigger: someone opens a pull request, the project compiles, and the compiled artifact is the thing you audit. Airbyte has no build step. A catalog is discovered, not compiled, and the schema it describes belongs to a system nobody in the repository controls. So the first question for an Airbyte drift gate is not "which endpoint do I call" - it is "where does catalog.json come from, and when".Recipe: CI Drift Gate for Airbyte](https://www.coremodels.io/connector/airbyte/t4-automation)[Deep diveInside the Airbyte Connector: Identity, Types, Checks, and the Limits We PublishEvery vendor CoreModels integrates parses into one neutral shape: datasets with fields and normalized checks, plus lineage between them. Vendor detail rides in metadata bags, never as new top-level concepts, and connectors are pure - they parse, map types and contribute audit rules, never touching the graph.Recipe: Source Onboarding Review](https://www.coremodels.io/connector/airbyte/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Apache Airflow | CoreModels" description: "Govern the scheduler that already knows your freshness, ownership, and lineage." canonical: "https://coremodels.io/connector/airflow" last_updated: "2026-09-15" --- Early access # Connect Apache Airflow Govern the scheduler that already knows your freshness, ownership, and lineage. [Connect Apache Airflow](https://go.coremodels.io/app/new/airflow/generic)[Apache Airflow site](https://airflow.apache.org/) Recipes ## Recipes Recipes for Apache Airflow ### Blank Apache Airflow project Govern your orchestration estate from your own REST API exports - no credentials, ever. [Related use →](https://www.coremodels.io/connector/airflow/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/airflow/generic) ### CI Drift Gate for Airflow Catch pipeline drift before it ships. [Related use →](https://www.coremodels.io/connector/airflow/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/airflow/ci-drift-gate) ### Cross-DAG lineage map Chain lineage through shared assets: producer DAG to asset to consumer DAG. [Related use →](https://www.coremodels.io/connector/airflow/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/airflow/cross-dag-lineage-map) ### First governed Airflow import Zero to first audit: your DAG estate governed from one API response. [Related use →](https://www.coremodels.io/connector/airflow/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/airflow/first-governed-import) Connector summary ## What the recipes deliver Import Airflow DAG metadata and CoreModels records schedule, ownership, dataset dependencies, and cross-DAG wiring as a governed graph. You can see which downstream jobs would keep running green if an upstream DAG is paused - before a dashboard goes quietly stale. ## How CoreModels works with Apache Airflow Airflow already knows which DAG produces which dataset, who owns it, how often it should run, and which other DAGs wait on it. That knowledge is operational, not governed: pause the wrong DAG and downstream work keeps succeeding on yesterday’s file. A CoreModels import turns DAGs, tasks, datasets, and schedule rules into a model you can inspect, map, and re-audit. The cross-DAG lineage recipe makes hidden waits visible. The drift gate fails a change that drops a producer or rewires a dependency without updating the governed picture. This is not a replacement for Airflow. It is a governed reading of the estate Airflow already runs - so orchestration stops being the one layer every incident walks through and nobody can query. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Scheduler Knows Everything About Your Data. Nobody Governs the Scheduler.Picture a failure any Airflow estate can produce. The revenue dashboard is wrong for nine days. Not down - wrong, which is worse, because down gets noticed. During a migration someone paused the DAG that rebuilds the orders file. The downstream DAG that feeds the dashboard keeps right on running, every run green, consuming a file that has quietly stopped changing. Airflow does exactly what it was told. That is the problem: nothing in the system is broken, and nothing in the system is accountable either.Recipe: Cross-DAG lineage map](https://www.coremodels.io/connector/airflow/h1-need)[OutcomesWhat Changes on an Ordinary Tuesday, Once Your Airflow Estate Is GovernedGovernance tooling should be judged by what it changes about an ordinary working day - not the demo day, the Tuesday. So instead of listing features, here is a walk through the moments that go differently once your Airflow deployment has a governed model behind it: after you have extracted your DAG list, tasks, and data-aware scheduling assets from your own REST API, imported them into CoreModels, and wired the audit into CI.Recipe: First governed Airflow import](https://www.coremodels.io/connector/airflow/h2-outcomes)[GovernanceFive Questions to Ask Before Any Tool Touches Your Airflow MetadataYour orchestration metadata is a map of how your business actually runs - what moves, when, owned by whom, feeding what. Any tool that wants to import it should be interrogated first. Here are the five questions we think you should ask, and how our Apache Airflow connector answers them. We are publishing the answers because the posture is the product: a governance tool you cannot trust is worse than none.](https://www.coremodels.io/connector/airflow/h3-governance)[EcosystemAirflow Sits in the Middle of Your Stack. Govern It Without Wrapping It.Draw a map of a typical modern data platform and Apache Airflow is rarely at the edge. It is the connective tissue: it triggers the ingestion jobs, kicks off the dbt build, loads the warehouse, refreshes the feature tables, and moves the files everything else depends on. An Apache Software Foundation project with pipelines defined as Python DAGs and a broad provider ecosystem, Airflow became, for many data teams, simply the scheduler - the thing all the other tools are arranged around.](https://www.coremodels.io/connector/airflow/h4-ecosystem)[AgentsYour AI Agent Shouldn't Have to Read Python to Understand Your PipelinesWatch what a coding agent does when you ask it why a table is stale. It opens the DAG repository, reads some Python, greps for table names, follows a few imports, and produces a fluent explanation of what it thinks the pipelines do. The prose is confident. The structure underneath it is guessed - and orchestration is one of the worst places in your stack to guess.](https://www.coremodels.io/connector/airflow/h5-agents)[QuickstartZero to First Audit: Bringing an Apache Airflow Deployment under CoreModels GovernanceYour Airflow deployment can already describe itself. The stable REST API v1 will tell you every DAG, every task, and - if you use data-aware scheduling - every asset your pipelines produce and consume. What it will not tell you is whether any of that still matches what your organization thinks it runs: who owns each pipeline, which assets are consumed but produced by nothing, which consumers are quietly running on stale data because every producer is paused.Recipe: Blank Apache Airflow project · First governed Airflow import](https://www.coremodels.io/connector/airflow/t1-quickstart)[APIThe Airflow Integration API, End to End: Every Route, Role, and PayloadEvery vendor integration in CoreModels answers the same first question the same way. Ask the platform what it knows how to govern:](https://www.coremodels.io/connector/airflow/t2-api)[MCPGoverning Airflow with an AI Agent: The CoreModels MCP Tools in Practice"Which of our pipelines have no accountable owner, and is anything downstream of a paused DAG?" That is a governance question, and until recently answering it meant a human clicking through the Airflow UI and cross-referencing a wiki. With CoreModels, an AI agent answers it directly: the same import/audit machinery we expose over HTTP is exposed over the Model Context Protocol, so an agent connected to your CoreModels server can inspect connector capabilities, run a full drift-and-hygiene audit of an Airflow deployment, and read back a human-quality report - all through typed tool calls.](https://www.coremodels.io/connector/airflow/t3-mcp)[AutomationCatch Pipeline Drift Before It Ships: A CI Gate and Drift Loop for AirflowOrchestration drift is the quiet kind of failure. Nobody deletes a pipeline; a schedule is flipped to manual during an incident and never flipped back, and for three weeks a downstream table renders yesterday's world with perfect confidence. Nobody removes a dataset from governance; a DAG is renamed in a refactor and the governed model now describes a pipeline that no longer exists. None of this throws an exception - which is exactly why it belongs in CI, where a machine checks it on every change.Recipe: CI Drift Gate for Airflow](https://www.coremodels.io/connector/airflow/t4-automation)[Deep diveLineage First: How CoreModels Maps an Airflow Estate into the Governed GraphAirflow is not a schema estate. A warehouse table has columns with types; a dbt model has a contract; an Avro subject has fields. A DAG has none of those - it has tasks, a schedule, an owner, and (with data-aware scheduling) declared relationships to the data it produces and consumes. So when we built the Apache Airflow connector for CoreModels, the design question was not "how do we pretend DAGs are tables?" but "what is orchestration's actual governance value?" The answer we committed to: the DAG-to-asset dependency graph, and pipeline hygiene. This connector is lineage-first, and every mapping decision below follows from that.Recipe: Cross-DAG lineage map](https://www.coremodels.io/connector/airflow/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Apache Avro | CoreModels" description: "One governed reading of the schema that currently lives in four places." canonical: "https://coremodels.io/connector/avro" last_updated: "2026-09-15" --- Format # Connect Apache Avro One governed reading of the schema that currently lives in four places. [Import a Apache Avro file](https://go.coremodels.io/app/new/avro)[Apache Avro site](https://avro.apache.org/) Recipes No recipes yet for Apache Avro. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import an Avro schema and CoreModels records records, fields, types, defaults, and enums as governed meaning. Compatibility is no longer only a registry check - it is a definition you can audit, map to other formats, and generate back from. ## How CoreModels works with Apache Avro Avro is precise about structure and compatibility. It is not a catalog of business meaning. Field docs rot, enums fork, and the same record is copied into Spark, the registry, and a downstream SQL table by hand. CoreModels decodes Avro into the same internal model used for JSON Schema, Protobuf, and SQL. Names, types, null unions, defaults, and symbols become elements and taxonomies. You can then audit a newer schema against the governed baseline, or encode the governed model back out to Avro with an honest ledger of anything the round trip cannot preserve. Use it when the schema is the contract consumers actually compile against - and you need that contract to survive the other three copies. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Four Places Your Avro Schema Isn'tSomeone posts a question in a team channel: what are the legal values of status on the orders stream?](https://www.coremodels.io/connector/avro/h1-need)[OutcomesThe Day After Import: What a Team Can Do Once Avro Is a ProjectionFour requests land on a platform team in one week. None is unusual, and each is, underneath, the same request wearing a different hat.](https://www.coremodels.io/connector/avro/h2-outcomes)[GovernanceNothing Silent: The Rules Behind Every Avro Round TripThe dangerous transformation is not the one that fails.](https://www.coremodels.io/connector/avro/h3-governance)[EcosystemAvro Won a Layer, Not the EstateEvery durable format is built around one decision, and Avro's is easy to name: the schema travels with the data. A reader does not guess; it is handed the writer's schema and reconciles it with its own. That single choice produced the compact encoding, the evolution rules, the registries, and the reason Avro is still a default schema language of event streaming.](https://www.coremodels.io/connector/avro/h4-ecosystem)[AgentsStop Guessing the Union Branch: Avro for AI AgentsAn agent is asked to produce test records for an orders topic. It has seen ten sample messages, and it writes what those samples look like: a JSON object with an age of 30.](https://www.coremodels.io/connector/avro/h5-agents)[QuickstartYour First Avro Transform: One Call, Three Things to ReadYou have an .avsc file. Somewhere downstream, somebody needs the same shape as JSON Schema, or as a table, or as a data contract - and they need to know what the conversion cost. This article gets you from that file to a converted schema in a single HTTP call, and then teaches you to read the three parts of the answer: the schema, the plan, and the lossiness ledger.](https://www.coremodels.io/connector/avro/t1-quickstart)[APIAvro Over HTTP: Four Endpoints and Their Honest LimitsEvery transform route in CoreModels answers with the same envelope, so learning the contract once buys you the whole surface:](https://www.coremodels.io/connector/avro/t2-api)[MCPHanding Avro to an Agent: transform_schema End to EndAsk a language model to "convert this Avro schema to LinkML" and it will improvise - plausible YAML on a good day, invented field names on a bad one. Connect it to CoreModels over MCP and the same sentence becomes a tool call: typed arguments, a deterministic engine, and a machine-readable account of what the conversion cost. This article is the whole loop for Avro - connection, exact arguments, a real conversion, and what a well-behaved agent does with the answer.](https://www.coremodels.io/connector/avro/t3-mcp)[AutomationShip the Plan, Not the Script: Avro Pipelines That ReplayHere is a job every streaming platform eventually has. An internal topic carries a rich record; a partner, a public catalog, or another business unit gets a redacted projection of it. Somebody writes a script. The script knows which fields to drop and which to rename, and that knowledge lives nowhere else. Six months later the source schema gains a field, the script silently passes it through, and the first person to notice is on the other side of the boundary.](https://www.coremodels.io/connector/avro/t4-automation)[Deep diveEvery Avro Construct, and Where It Lands in the IRDoes an int come back as an int?](https://www.coremodels.io/connector/avro/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Google BigQuery | CoreModels" description: "Turn INFORMATION_SCHEMA from an inventory into a contract you can audit." canonical: "https://coremodels.io/connector/bigquery" last_updated: "2026-09-15" --- Early access # Connect Google BigQuery Turn INFORMATION_SCHEMA from an inventory into a contract you can audit. [Connect Google BigQuery](https://go.coremodels.io/app/new/bigquery/generic)[Google BigQuery site](https://cloud.google.com/bigquery) Recipes ## Recipes Recipes for Google BigQuery ### Blank BigQuery project A preconfigured home for governing your BigQuery estate - bring your extract now or later. [Related use →](https://www.coremodels.io/connector/bigquery/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/bigquery/generic) ### CI Drift Gate for BigQuery Fail the Dataform/Terraform PR when the estate drifts from the governed model. [Related use →](https://www.coremodels.io/connector/bigquery/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/bigquery/ci-drift-gate) ### Estate Documentation Audit Find every undocumented table and every ungoverned STRUCT/ARRAY/JSON payload. [Related use →](https://www.coremodels.io/connector/bigquery/h2-outcomes)[Start this recipe](https://go.coremodels.io/app/new/bigquery/estate-documentation-audit) ### First Governed Import for BigQuery Turn one INFORMATION_SCHEMA query into a governed estate. [Related use →](https://www.coremodels.io/connector/bigquery/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/bigquery/first-governed-import) ### Generate BigQuery DDL from the Governed Model Close the loop: meaning goes back where BigQuery users actually read it. [Related use →](https://www.coremodels.io/connector/bigquery/h2-outcomes)[Start this recipe](https://go.coremodels.io/app/new/bigquery/generate-back) Connector summary ## What the recipes deliver Import BigQuery table metadata and CoreModels turns datasets, tables, columns, types, and nullability into a governed estate. The next INFORMATION_SCHEMA snapshot is not just another inventory - it is a drift report against meaning you already agreed. ## How CoreModels works with Google BigQuery BigQuery’s information schema is fast, free, and complete. It answers what the estate looks like right now. It does not answer what the estate is supposed to mean, who approved the last type change, or which tables are undocumented on purpose versus by accident. CoreModels imports that metadata as types and elements, records the first audit, and treats every later extract as a candidate for drift. The estate documentation audit recipe flags tables and columns that never received a description. Generate-back emits DDL aligned with governed types so the warehouse and the model do not fork. Wire the CI drift gate and a pull request that retypes a revenue column fails with the column named - before the query still runs and the number is quietly wrong. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemA Complete Answer That Tells You Nothing: The BigQuery Metadata ProblemThere is a query most BigQuery engineers can write from memory. Select from INFORMATION_SCHEMA.COLUMNS, join TABLES, and you get a perfect inventory of the estate: every table, every column, every data_type, every is_nullable flag, in order. It is fast, it is free, and it is complete.Recipe: Estate Documentation Audit](https://www.coremodels.io/connector/bigquery/h1-need)[OutcomesThe First Thing You Notice Is What Stops HappeningGovern a BigQuery estate with CoreModels and the change is less a new capability than an absence. The archaeology stops. The "does anyone know what this column is" thread stops. The quarterly scramble to work out what changed since the last review stops, because the answer is already written down, dated, and fingerprinted.Recipe: CI Drift Gate for BigQuery · Estate Documentation Audit · First Governed Import for BigQuery · Generate BigQuery DDL from the Governed Model](https://www.coremodels.io/connector/bigquery/h2-outcomes)[GovernanceFollow One Column: Where the Machine Stops and a Person StartsTrust in a governance tool is not established by a promise on a landing page. It is established by being able to point, precisely, at the places where automation ends and human judgement begins - and by those places being the same ones every time.](https://www.coremodels.io/connector/bigquery/h3-governance)[EcosystemThirteen Connectors, One Model: Where BigQuery FitsAsk a CoreModels deployment which vendors it knows and it will tell you at runtime. The vendors endpoint returns every registered connector with its key, display name, capabilities and the artifacts it expects: bigquery, snowflake, databricks, fabric, glue, dbt, confluent, airbyte, airflow, neo4j, salesforce, redcap, cbioportal.](https://www.coremodels.io/connector/bigquery/h4-ecosystem)[AgentsWhat Your Agent Reads in the Four Seconds Before It Writes the QueryThe interesting question about AI agents and BigQuery is not whether an agent can write SQL. It plainly can. The question is what it consults in the moment before it does.](https://www.coremodels.io/connector/bigquery/h5-agents)[QuickstartYour First BigQuery Drift Audit with CoreModelsZero to a recorded schema audit of a BigQuery dataset: one SQL query, two HTTP calls, no credentials shared.Recipe: Blank BigQuery project · First Governed Import for BigQuery · Generate BigQuery DDL from the Governed Model](https://www.coremodels.io/connector/bigquery/t1-quickstart)[APIThe CoreModels BigQuery Integration, Route by RouteThe complete HTTP surface for governing a BigQuery estate: every verb, every role, every payload.](https://www.coremodels.io/connector/bigquery/t2-api)[MCPGoverning BigQuery from an AI Agent over MCPThe same import–audit–generate loop, driven by tool calls instead of curl - including how agents ship multi-megabyte extracts.](https://www.coremodels.io/connector/bigquery/t3-mcp)[AutomationA CI Drift Gate for BigQuery: Fail the PR, Not the DashboardTurning the CoreModels schema audit into an automated gate - the v1 API, errorCount semantics, the badge, the history trail, and the two directions drift can come from.Recipe: CI Drift Gate for BigQuery](https://www.coremodels.io/connector/bigquery/t4-automation)[Deep diveInside the BigQuery Connector: How an Estate Becomes a Governed GraphWhat actually happens between a flat JSON extract and a queryable governed model - identities, type mappings, metadata mixins, audit rules, and the approximations we admit to.Recipe: Estate Documentation Audit](https://www.coremodels.io/connector/bigquery/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect cBioPortal | CoreModels" description: "Govern the four comment rows that are the schema of your study." canonical: "https://coremodels.io/connector/cbioportal" last_updated: "2026-09-15" --- Early access # Connect cBioPortal Govern the four comment rows that are the schema of your study. [Connect cBioPortal](https://go.coremodels.io/app/new/cbioportal/generic)[cBioPortal site](https://www.cbioportal.org/) Recipes ## Recipes Recipes for cBioPortal ### cBioPortal governed baseline The study's clinical schema, governed - headers only, so no patient data ever leaves your site. [Related use →](https://www.coremodels.io/connector/cbioportal/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/cbioportal/generic) ### Clinical attribute registry One governed dictionary for every study - because 24 spellings of radiation therapy is not a vocabulary. [Related use →](https://www.coremodels.io/connector/cbioportal/h6-attribute-registry)[Start this recipe](https://go.coremodels.io/app/new/cbioportal/attribute-registry) ### Consortium conformance loop Retire the curation checklist - a drift loop for every study in the portfolio. [Related use →](https://www.coremodels.io/connector/cbioportal/h7-portfolio-conformance)[Start this recipe](https://go.coremodels.io/app/new/cbioportal/consortium-conformance) ### Staging-file preflight Start valid instead of fixing invalid - headers minted from governed meaning. [Related use →](https://www.coremodels.io/connector/cbioportal/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/cbioportal/staging-preflight) ### Study-update gate Republishing a study shouldn't silently change what its attributes mean. [Related use →](https://www.coremodels.io/connector/cbioportal/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/cbioportal/ci-drift-gate) Connector summary ## What the recipes deliver Import cBioPortal clinical files and CoreModels treats the four `#` header rows - display names, descriptions, datatypes, and priority - as a governed attribute registry. Staging preflight, consortium conformance, and CI gates catch study drift before it lands in a public portal. ## How CoreModels works with cBioPortal cBioPortal studies look like data files. They are also schemas: attribute IDs, human labels, datatypes, and descriptions live in a fragile header convention. Multiply that by a portfolio of studies and you get silent divergence - the same clinical concept spelled three ways, typed two ways, described in none. CoreModels imports those headers into a governed attribute registry. The staging preflight recipe checks a study before load. Consortium conformance compares a study against an agreed portfolio model. The CI drift gate fails a change that retypes an attribute the consortium already published. The point is not to replace cBioPortal. It is to give study metadata the same governance you would demand of any other production schema. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemFour Comment Rows Are the Schema of Your StudyOpen data_clinical_sample.txt from any cBioPortal study and look at the top of the file. Four lines beginning with #, then a row of attribute IDs, then the data. Those four lines carry the display names, the human descriptions, the datatypes - STRING, NUMBER, BOOLEAN - and the priorities for every clinical attribute in the study. They are the study's complete declared clinical meaning.](https://www.coremodels.io/connector/cbioportal/h1-need)[OutcomesThe Study Update That Reviews ItselfThe clearest way to describe what changes when a cBioPortal study is governed is to follow one ordinary study update through a working week - the same update your team already ships, with the governance layer switched on.Recipe: Staging-file preflight](https://www.coremodels.io/connector/cbioportal/h2-outcomes)[GovernanceWhere the Software Stops: Governing a cBioPortal StudyThere is one question worth asking any tool you point at a clinical schema: what is it allowed to change without asking you?Recipe: Study-update gate](https://www.coremodels.io/connector/cbioportal/h3-governance)[EcosystemA Study Is Never Only a cBioPortal StudyTrace one clinical attribute backwards from a cBioPortal study and watch how many systems it passes through. It was captured in a form or an EDC instrument. It was cleaned somewhere. It was joined to a specimen table in a warehouse. Somebody transformed it into an analysis-ready model. Then it was written into four # header rows of a staging file, validated, and uploaded - and along the way it was named four different things by four different teams, each of whom was right within their own system.](https://www.coremodels.io/connector/cbioportal/h4-ecosystem)[AgentsWhat an Agent Should Know Before It Answers a Question About Your StudyThe question that exposes an ungoverned study is a boring one. "Is OS_MONTHS a number here, and what is it measured from?"](https://www.coremodels.io/connector/cbioportal/h5-agents)[Use caseTwenty-Four Ways to Say Radiation TherapyA public audit of 375 cBioPortal studies went looking for how the same clinical concepts were encoded from study to study - by hand, header by header. Radiation therapy alone turned up under 24 distinct encodings: different attribute IDs, different datatypes, different value conventions, all describing the same treatment. Multiply that by every common concept - smoking status, tumor stage, vital status - and the shape of the problem is plain. The platform's cross-study query tools are excellent; the attributes they query were never designed to line up. A cohort filter that matches one study's encoding silently misses the patients recorded under the other twenty-three.Recipe: Clinical attribute registry](https://www.coremodels.io/connector/cbioportal/h6-attribute-registry)[Use caseThe Curation Checklist Does Not ScaleAsk how a cancer study gets into the public cBioPortal datahub and stays good, and the answer is a checklist. A GitHub issue opens, a curator works through the required files and formats, a reviewer checks boxes, a pull request merges. It is careful, human, and it works - once, per study, at submission time. Now ask the harder question. Fifteen published studies, three curators, standards that have moved twice since the oldest study went up: who re-checks study number seven?Recipe: Consortium conformance loop](https://www.coremodels.io/connector/cbioportal/h7-portfolio-conformance)[QuickstartZero to first audit: putting a cBioPortal study's clinical schema under governanceThe clinical schema of a cBioPortal study does not live in a database, a catalog, or an API. It lives in the first five lines of two tab-separated text files that a curator maintains by hand. Those five lines decide whether an attribute passes portal validation, what it is called in the UI, whether it is a number or a string, and how prominently it is displayed. They are also, in most study repositories, the least reviewed lines in the project.Recipe: cBioPortal governed baseline · Staging-file preflight](https://www.coremodels.io/connector/cbioportal/t1-quickstart)[APIEvery cBioPortal route, every role: the CoreModels HTTP surface for study governanceAsk the API what it can do for cBioPortal before you write a line of client code:](https://www.coremodels.io/connector/cbioportal/t2-api)[MCPHanding a cBioPortal study to an agent: governance over MCP"Check whether the study files on this branch still match what we govern, and tell me what changed."](https://www.coremodels.io/connector/cbioportal/t3-mcp)[AutomationOne character, one broken study: automating cBioPortal drift checks in CIHere is a pull request diff from a study repository:Recipe: Study-update gate](https://www.coremodels.io/connector/cbioportal/t4-automation)[Deep diveFollowing one clinical attribute all the way into the graphTake a single column out of a cBioPortal patient staging file:](https://www.coremodels.io/connector/cbioportal/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Confluent | CoreModels" description: "Put meaning under every Kafka subject the Schema Registry already inventories." canonical: "https://coremodels.io/connector/confluent" last_updated: "2026-09-15" --- Early access # Connect Confluent Put meaning under every Kafka subject the Schema Registry already inventories. [Connect Confluent](https://go.coremodels.io/app/new/confluent/generic)[Confluent site](https://www.confluent.io/) Recipes ## Recipes Recipes for Confluent ### Blank Confluent Schema Registry project Govern your streaming estate from a subjects export - registry credentials stay yours. [Related use →](https://www.coremodels.io/connector/confluent/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/confluent/generic) ### CI Drift Gate for Confluent Schema Registry Fail the build before the consumer breaks. [Related use →](https://www.coremodels.io/connector/confluent/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/confluent/ci-drift-gate) ### Contract-triad governance for the registry Avro, JSON Schema and Protobuf in one governed estate - coverage gaps stay visible. [Related use →](https://www.coremodels.io/connector/confluent/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/confluent/contract-triad) ### First governed registry import Zero to first audit: your Schema Registry as a governed model. [Related use →](https://www.coremodels.io/connector/confluent/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/confluent/first-governed-import) ### Registry-ready Avro back out Governed model in, schemas/{Record}.avsc out. [Related use →](https://www.coremodels.io/connector/confluent/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/confluent/generate-back) Connector summary ## What the recipes deliver Import Schema Registry subjects and CoreModels records each schema version as governed structure - fields, types, compatibility, and contracts you can audit. Consumers get more than a shape: they get a definition of what they may depend on. ## How CoreModels works with Confluent Confluent Schema Registry is a complete inventory: subject, version, id, type, document. Compatibility rules protect binary readers. They do not protect business meaning, enumerations, or the triad of produce / consume / land-in-warehouse. A CoreModels import decodes Avro, JSON Schema, or Protobuf subjects into one model. The contract-triad recipe keeps those three surfaces aligned. Generate-back and the drift gate close the loop so a field that became optional in the registry cannot silently disagree with the table it lands in. Use this when Kafka is the system of record for events - and you need events, tables, and APIs to share a governed reading of the same fields. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Meaning Gap Under Every Kafka TopicAsk your Schema Registry for its subject list and you get an inventory: a name per subject, each with a version, a schema id, a schema type, and a schema document. It is a complete answer to the question what shape is this?Recipe: Contract-triad governance for the registry](https://www.coremodels.io/connector/confluent/h1-need)[OutcomesDay Two: Five Things a Streaming Team Can Do Once the Registry Is GovernedSomeone posts in the platform channel: does shipped_at ever arrive null on the shipment events topic?Recipe: First governed registry import](https://www.coremodels.io/connector/confluent/h2-outcomes)[GovernanceReceipts, Not Reassurance: How We Govern a Registry We Never TouchA successful import in CoreModels returns two lists. One is errors, which is empty - the run proceeded. The other is lossiness, and it is often not empty at all: an itemized statement of everything the import approximated, counted without parsing, or deliberately left out.Recipe: Registry-ready Avro back out](https://www.coremodels.io/connector/confluent/h3-governance)[EcosystemA Subject Is a Border CrossingTwo teams that will never attend the same meeting still have to agree on something, and in a Kafka estate that something is a subject in the Schema Registry. The producer owns a service and a release train; the consumer owns a different service, a different train, and different assumptions. Between them sits one versioned schema document that neither fully owns and both depend on.](https://www.coremodels.io/connector/confluent/h4-ecosystem)[AgentsGive the Agent Something to CiteAn engineer types into an assistant: add a refund_reason field to the payments event and update the two consumers that need it.](https://www.coremodels.io/connector/confluent/h5-agents)[QuickstartConfluent Schema Registry to CoreModels: Zero to First AuditYour Schema Registry already knows every event contract in your streaming platform - every subject, every version, every Avro record your producers have ever registered. What it does not know is what those contracts mean, whether the meaning is still what your consumers agreed to, and who is guarding it. In this tutorial we take a real registry from nothing to a completed schema audit in CoreModels: export the subjects with one shell loop, import the estate into a governed project, run the first audit, and read the result line by line.Recipe: Blank Confluent Schema Registry project · First governed registry import](https://www.coremodels.io/connector/confluent/t1-quickstart)[APIThe Complete HTTP Surface for Confluent Schema Registry GovernanceThis is the reference we wish every integration shipped with: every route, every role, every payload - nothing implied. CoreModels exposes eight core verbs for a Schema Registry estate across two HTTP surfaces, and this article walks all of them with real request and response bodies. The vendor key is confluent; the connector declares Import, Audit, Generate, so every verb below is genuinely available - including artifact generation, which not all of our connectors support.](https://www.coremodels.io/connector/confluent/t2-api)[MCPAsk Your Agent Whether the Kafka Schemas Drifted: Confluent Governance over MCP"Did anything in the registry drift from what we agreed?" is a question a platform engineer answers with three terminal commands and a diff. It is also, increasingly, a question they type into a chat window - and the agent on the other end needs real tools, not guesses. CoreModels ships its Confluent Schema Registry governance as a set of MCP tools, so any MCP-capable agent - Claude, Claude Code, or anything speaking streamable HTTP - can run the same import, audit, generate, and status verbs the HTTP API exposes, with the same role enforcement and the same read-only guarantees.](https://www.coremodels.io/connector/confluent/t3-mcp)[AutomationFailing the Build Before the Consumer Breaks: A CI Drift Gate for Confluent Schema RegistryThe Schema Registry's compatibility checks are necessary and not sufficient. They guarantee a new schema version can be deserialized by existing consumers - wire compatibility. They say nothing about whether amount is still the governed Double your downstream jobs assume, whether an enum quietly grew a symbol nobody reviewed, or whether a topic your reports depend on disappeared from the registry altogether. Those are questions about meaning, and meaning drift in streaming breaks things at runtime, in production, at consumer speed. This article wires the CoreModels schema audit into CI as a merge gate for schema changes, then completes the loop with the status badge, the rolling history, one-call re-audits, and the scheduled heartbeat.Recipe: CI Drift Gate for Confluent Schema Registry](https://www.coremodels.io/connector/confluent/t4-automation)[Deep diveAnatomy of a Governed Streaming Estate: How the Confluent Connector Maps Subjects into the GraphA schema registry is three naming systems wearing one trench coat. There is the subject (orders-value), the registry's versioned unit. There is the record (com.acme.Order), the Avro type the schema declares. And there is the topic (orders), the physical stream the subject-name strategy encodes. Most tooling collapses these into one string and loses information doing it. This deep dive walks exactly how CoreModels maps a Confluent Schema Registry export into the governed graph - what becomes a Type, an Element, a Taxonomy or a reference; what rides metadata; which audit rules are this vendor's; and where the mapping is lossy, because a governance product that hides its own approximations cannot be trusted about anyone else's.Recipe: Contract-triad governance for the registry · Registry-ready Avro back out](https://www.coremodels.io/connector/confluent/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Convert any schema through CoreModels | CoreModels" description: "A neutral hub between fourteen schema formats, with an honest lossiness ledger." canonical: "https://coremodels.io/connector/converter" last_updated: "2026-09-15" --- Early access # Convert any schema through CoreModels A neutral hub between fourteen schema formats, with an honest lossiness ledger. [Connect Schema Converter](https://go.coremodels.io/app/new/converter/contract-authoring-odcs)[Schema Converter site](https://coremodels.io/) Recipes ## Recipes Recipes for Schema Converter ### Author an ODCS v3 Data Contract From governed model to Bitol Open Data Contract Standard - no retyping. [Start this recipe](https://go.coremodels.io/app/new/converter/contract-authoring-odcs) ### Blank conversion project A neutral hub between fourteen schema formats - start empty or seed it with a schema. [Start this recipe](https://go.coremodels.io/app/new/converter/generic) ### JSON Schema to SQL DDL From the JSON world's common tongue to CREATE TABLE - in your dialect. [Start this recipe](https://go.coremodels.io/app/new/converter/jsonschema-to-sql) ### LinkML to Synapse Registered Schema The LinkML-to-Synapse toolchain every DCC currently hand-builds - with the subset losses declared. [Start this recipe](https://go.coremodels.io/app/new/converter/linkml-to-synapse) ### Protobuf to Avro Move a contract across the registry triad without retyping it. [Start this recipe](https://go.coremodels.io/app/new/converter/proto-to-avro) ### Semantic Model for dbt (Apache Ossie JSON) Export your governed meaning as osi-json - the serialization dbt ingests. [Start this recipe](https://go.coremodels.io/app/new/converter/semantic-to-dbt) ### Synapse schema migration schematic sunsets at the end of 2026. Migrate your data model with a fidelity report, not a rewrite. [Start this recipe](https://go.coremodels.io/app/new/converter/synapse-schema-migration) Connector summary ## What the recipes deliver Start a conversion project and CoreModels decodes a schema into its neutral model, then encodes it into another format. Every translation ships a lossiness ledger: what was preserved, what was approximated, and what could not travel. ## How CoreModels works with Schema Converter CoreModels conversion is not a best-effort pretty-printer. Decode understands JSON Schema, ShEx, Avro, JSON-LD, SQL, OSI, OWL, LinkML, Protobuf, ODCS, and ODM. Encode covers the same set minus ODM (entity docs are authored, not generated), and adds Synapse as encode-only draft-07 JSON Schema. Recipes cover the conversions teams actually fight: JSON Schema to SQL, LinkML to Synapse, Protobuf to Avro, semantic models to dbt, Synapse schema migration, and ODCS contract authoring. Each run lands in a project you can audit, map, and regenerate. If you only need a one-off file, you will still get the ledger. If you need a pipeline, the same project becomes the place later translations are checked against. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. Use articles for Schema Converter will appear here as they are published. CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Databricks | CoreModels" description: "Give Unity Catalog something to check thousands of columns against." canonical: "https://coremodels.io/connector/databricks" last_updated: "2026-09-15" --- Early access # Connect Databricks Give Unity Catalog something to check thousands of columns against. [Connect Databricks](https://go.coremodels.io/app/new/databricks/generic)[Databricks site](https://www.databricks.com/) Recipes ## Recipes Recipes for Databricks ### Blank Databricks Unity Catalog project Three SQL-editor queries to a governed lakehouse - no credentials, ever. [Related use →](https://www.coremodels.io/connector/databricks/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/databricks/generic) ### CI Drift Gate for Unity Catalog Wire a Unity Catalog drift gate into CI - and keep it honest after merge. [Related use →](https://www.coremodels.io/connector/databricks/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/databricks/ci-drift-gate) ### Delta DDL back to Databricks Governed model in, coremodels_delta_tables.sql out. [Related use →](https://www.coremodels.io/connector/databricks/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/databricks/generate-back) ### First governed Unity Catalog import One information_schema extract to a governed lakehouse and a first audit. [Related use →](https://www.coremodels.io/connector/databricks/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/databricks/first-governed-import) ### Lineage-aware lakehouse governance Govern tables with the dependency graph that explains them. [Related use →](https://www.coremodels.io/connector/databricks/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/databricks/lineage-aware-governance) Connector summary ## What the recipes deliver Import Unity Catalog metadata and CoreModels turns catalogs, schemas, tables, and column types into a governed estate - including lineage-aware checks. Six thousand columns stop being an inventory you cannot interrogate. ## How CoreModels works with Databricks A mid-size Databricks estate is impressive on paper and exhausting in practice: three-level namespaces, thousands of columns, comments wherever someone bothered. The questions that eat the week - may this column change, who consumes it, is documentation real - are not catalog questions. CoreModels imports the estate, records the first audit, and uses later extracts as drift candidates. Lineage-aware governance ties producers to consumers so a type change is not a local edit. Generate-back and the CI gate put the check in the same place code already reviews. This is how a lakehouse gets a contract without pretending the catalog was one. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemSix Thousand Columns, and Nothing to Check Them AgainstRun one query against system.information_schema in a mid-size Unity Catalog estate and what comes back is genuinely impressive: every table and view addressed as catalog.schema.table; every column with its full_data_type spelled out exactly as the catalog holds it, its ordinal position, its nullability flag, and a comment wherever somebody bothered. Hundreds of tables. Thousands of columns. Complete, accurate, current.](https://www.coremodels.io/connector/databricks/h1-need)[OutcomesThe Meeting That Used to Take Two WeeksSomebody proposes changing a column. Not a dramatic change - order_total needs a different type after a rounding bug, or status needs one more allowed value.Recipe: First governed Unity Catalog import](https://www.coremodels.io/connector/databricks/h2-outcomes)[GovernanceTrust Is a Set of Powers RefusedMost tools that want to govern a data platform begin by asking for access to it. A service principal, a warehouse role, a token with just enough scope - and from that moment the honest answer to "what can this thing do to my estate?" is "you'd have to read the code."Recipe: Delta DDL back to Databricks](https://www.coremodels.io/connector/databricks/h3-governance)[EcosystemFollow One Table Across Your StackPick a table. Say sales.orders.Recipe: Lineage-aware lakehouse governance](https://www.coremodels.io/connector/databricks/h4-ecosystem)[AgentsWhat an Agent Should Be Allowed to AssumeHand an AI agent a table name and a task, and before it writes a line it has made a dozen assumptions. That customer_id identifies a customer and is unique. That status has a small set of values and active is one. That amount is a number, in one currency, never null. That the orders it found is the orders. That today's shape is the shape it was told about.](https://www.coremodels.io/connector/databricks/h5-agents)[QuickstartZero to First Audit: Governing a Databricks Unity Catalog Estate with CoreModelsThis is a working session, not a tour. By the end of it you will have a governed model of a Unity Catalog schema inside CoreModels, and you will have run your first drift audit against it - without installing anything in your workspace and without handing us a single credential. Everything CoreModels learns about your lakehouse arrives as JSON files you extract yourself from the Databricks SQL editor.Recipe: Blank Databricks Unity Catalog project · First governed Unity Catalog import](https://www.coremodels.io/connector/databricks/t1-quickstart)[APIEvery Endpoint of the CoreModels Databricks Integration, With Real PayloadsReference articles usually show the happy path and gesture at the rest. This one is the full inventory: every HTTP route the CoreModels Databricks Unity Catalog connector answers on, the role each one enforces, the request and response bodies as they actually are, and - where a verb lives on one surface but not the other - an explicit statement of that fact rather than a diagram that implies otherwise.](https://www.coremodels.io/connector/databricks/t2-api)[MCPAsk Your Agent Whether the Lakehouse Drifted: Unity Catalog Governance over MCP"Has our Unity Catalog estate drifted from what we agreed it means?" is a question an AI agent can now answer with evidence instead of vibes. The same governance verbs that back the CoreModels HTTP API - status, audit, import, generate - are exposed as tools on our MCP server, so an agent can inspect a governed Databricks estate, audit a fresh extract against it, and draft the fix, all inside one conversation. This article walks that loop exactly as an agent drives it, with the real tool names and arguments, including the artifactUrls path for extracts too large to paste into a chat.](https://www.coremodels.io/connector/databricks/t3-mcp)[AutomationFail the Build, Not the Dashboard: A CI Drift Gate for Databricks Unity CatalogSomewhere in your lakehouse, a notebook is about to rebuild a table with a widened column type, and nothing will fail until a dashboard does - days later, in front of the wrong audience. The cheapest place to catch that is a pull request. This article turns the CoreModels schema audit into a merge-blocking CI gate for a Unity Catalog estate, then builds out the rest of the operational loop most drift setups forget: the status badge, the rolling history, the one-call re-audit for when the governed model itself changes, and the scheduled heartbeat that keeps watch between releases.Recipe: CI Drift Gate for Unity Catalog](https://www.coremodels.io/connector/databricks/t4-automation)[Deep diveAnatomy of an Import: How a Unity Catalog Estate Becomes a Governed GraphTake a single row of a Unity Catalog extract:Recipe: Delta DDL back to Databricks · Lineage-aware lakehouse governance](https://www.coremodels.io/connector/databricks/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Import your dbt project | CoreModels" description: "Your dbt project already holds the definitions, copied into every accepted_values list that tests a column. Bring a manifest; we connect the copies into one vocabulary you govern and your agent can read." canonical: "https://coremodels.io/connector/dbt" last_updated: "2026-09-15" --- ImportEarly access (guided) 7 recipes · 15 guides # dbt Your dbt project already holds the definitions, copied into every accepted_values list that tests a column. Bring a manifest; we connect the copies into one vocabulary you govern and your agent can read. The finance lead edits the definition. You open the PR. Import your manifest, no credentials. Give the columns that matter a definition, an owner and a permitted-value list — then point your agent at it, or publish the result back as property files your repo can review. [Import your dbt project](https://go.coremodels.io/app/new/dbt/agent-grounding)[dbt site](https://www.getdbt.com/) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Recipes ## Recipes Recipes for dbt GA ### [Stop your agent guessing what status means](https://www.coremodels.io/connector/dbt/recipe/agent-grounding) An LLM writing SQL against your warehouse has three bad options: guess from the column name, read the SQL, or ask a human. Give it a fourth. - Import the manifest; each accepted_values list becomes a governed vocabulary. - Fill three fields (meaningNote, commonMistake, doNotUseFor) on the columns agents get wrong. About 20 is enough to test the loop. - Connect your assistant to the read-only MCP endpoint (it reads your governed definitions, not your warehouse) and replay a question it used to get wrong. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/agent-grounding)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/agent-grounding) GA ### [One enum, every model](https://www.coremodels.io/connector/dbt/recipe/governed-vocabulary) Two files test the same column with different accepted_values. Both pass. Find the one that drifted. - See every vocabulary referenced by more than one model, and the one that drifted. - Name it, describe it, give it an owner. Once. - Publishing the list back into every model is Early access: Generate returns the property files, we walk the first publish with you, and you open the PR. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/governed-vocabulary)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/governed-vocabulary) GA ### [Who decides what this column means?](https://www.coremodels.io/connector/dbt/recipe/ownership-register) In dbt Labs' 2026 State of Analytics Engineering survey (n=363), 41% of teams still name ambiguous data ownership as an obstacle. dbt can tell you who owns a model, not who owns a definition five models share. - Every column and vocabulary gains an owner, a steward team, a review cadence and a decision forum. - Filter to 'no owner'. That list is the real work. - Start with the vocabularies, that is where the arguments live. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/ownership-register)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/ownership-register) Early access ### [The PR your dbt CI passes](https://www.coremodels.io/connector/dbt/recipe/ci-contract-gate) Delete an accepted_values test and CI goes green — because the test is gone. Nothing compares the PR to what you agreed. - Import the manifest you consider correct today (main) as the baseline. - Audit a PR's manifest against it: removed value sets, widened enums, silent retypes, vanished datasets, as named findings. - Start on errors only. A gate that fails on day one for untriaged warnings is switched off in a week. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/ci-contract-gate)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/ci-contract-gate) Early access ### [Publish governed meaning into dbt](https://www.coremodels.io/connector/dbt/recipe/publication-contract) Govern a column's meaning once, and let dbt carry it to the warehouse column comment. - Govern the meaning in the grid; generate one property file per model, colocated beside its .sql. - The bound term rides in the column description (the field persist_docs pushes to the warehouse comment) and in meta. - Every run hands you a loss report. No meaning change means no diff. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/publication-contract)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/publication-contract) Early access ### [What breaks if I rename this?](https://www.coremodels.io/connector/dbt/recipe/change-impact) dbt lineage tells you which models depend on this one. It cannot tell you who outside dbt is relying on this column. - Ask any column or vocabulary what depends on it: governed usage, every imported source that carries it, and by what path. - You ask about one column or one vocabulary, not a whole model. The answer follows the governed meaning; it does not trace which downstream column it became. - Available over the API today; the in-product panel follows. [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/change-impact)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/change-impact) ### [Jaffle Shop, worked: what orders.status means](https://www.coremodels.io/connector/dbt/recipe/jaffle-shop-status) dbt Labs' sample project, with its five-value status column annotated so an agent looks it up instead of guessing. Every field is on the page. - Run dbt parse on jaffle-shop-classic and import target/manifest.json; each accepted_values list, orders.status included, becomes a governed vocabulary. - Fill meaningNote, commonMistake and doNotUseFor on the columns an agent gets wrong. The annotated set is below. - Point your assistant at the read-only endpoint and ask: what was completed revenue last month? [Read the recipe →](https://www.coremodels.io/connector/dbt/recipe/jaffle-shop-status)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/jaffle-shop-status) ## What you bring ```text dbt parse # writes target/manifest.json — send that. No warehouse credentials. ``` ## What lands in the graph Models, columns, tests, and every accepted_values list as a named vocabulary. Ownership, stewardship and agent-guidance columns are added as grids. ## What you can do today GA - Import the manifest - Edit definitions, owners, permitted values in grids - Fill meaningNote, commonMistake, doNotUseFor - Connect an agent to the read-only endpoint - Export JSON Schema / JSON-LD / ShEx Early access: in the product, we set it up with you - Generate one property file per model, colocated beside the .sql - Audit a PR's manifest against main and get named findings - ODCS contract export Not yet - Column-level lineage - Scaffold sources.yml Never, by design - Write to your repo - Open a PR for you - Connect to your warehouse ## Honest limits - accepted_values is flat. If a concept is hierarchical, the hierarchy won't survive the trip back into dbt. The loss report says so before you find out. - Lineage is model-level: which model a column belongs to and which governed models depend on it — not which downstream column it became. - Generation never writes your repo and never overwrites a file it doesn't own. It names the block to remove. - Plan limits count nodes in your CoreModels model, not dbt models: Builder ($49/month) up to 100,000, Team ($990/month) up to 1,000,000. A 300-model dbt project at ~8 columns each is ~2,400 nodes before vocabularies — well inside Builder. If you hit a cap, tell us and we will talk it through. [Start the agent-grounding recipe](https://go.coremodels.io/app/new/dbt/agent-grounding)[Run this with us](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. A recipe's own story lives on its recipe page. ### Strategy Why the problem exists, and what changes once it is fixed. [GuideSeven Problems, One CauseIf you run dbt at scale, you have probably hit several of these. They arrive as unrelated annoyances, get filed under different headings, and get fixed — when they get fixed — by different people using different tools.](https://www.coremodels.io/connector/dbt/00-start-here)[ProblemEleven Copies of One EnumGrep a mature dbt project for accepted_values and count the hits on your order status field. In a mature project, the number is rarely one. The list appears in the staging model that first cleans the column, in two intermediate models, in the fact table, in three marts built for three teams, and in another four models a second squad wrote when it needed the same field and copied the nearest example it could find.Recipe: One enum, every model](https://www.coremodels.io/connector/dbt/h1-need)[OutcomesThe Ticket Nobody FilesThe enum problem is the one everybody recognizes, and it is not the whole of what changes. Once meaning is governed once and published back into dbt, a set of small recurring chores stop happening — and one of them has been costing time every month without ever being on a roadmap.Recipe: Publish governed meaning into dbt](https://www.coremodels.io/connector/dbt/h2-outcomes)[GovernanceSix Refusals: What CoreModels Will Not Do to Your dbt ProjectA dbt project is the most consequential text a data team owns. The definitions in it decide what gets built, what gets tested, and what every downstream consumer believes. CoreModels asks to publish into that text — governed descriptions, types, vocabularies, and bound ontology terms, emitted as dbt model property files with enforced contracts. Anything asking for that position should be judged less by what it can do than by what it will not do.](https://www.coremodels.io/connector/dbt/h3-governance)[Ecosystemdbt Owns the Transformation. Nobody Owns the Definition.Pick one column — status in your orders mart — and count the tools that hold an opinion about it. dbt tests it and, if the model is contracted, refuses to build when its type changes. A catalog lists it, draws its lineage, and lets someone attach a note. An observability tool watches its distribution and raises an alert when yesterday looks unlike last week. A semantic layer exposes it as a dimension. Outside the warehouse, an API team ships a field meant to mean the same thing, and a streaming team keeps an enum on a topic meant to mean it again.](https://www.coremodels.io/connector/dbt/h4-ecosystem)[AgentsThe Fourth Option for a Column Named statusThis is no longer a hypothetical audience. dbt Labs' 2026 State of Analytics Engineering (n=363) reports 72% of teams prioritizing AI-assisted coding and 71% concerned about incorrect data reaching stakeholders — the same teams, describing both halves of the problem below.Recipe: Stop your agent guessing what status means](https://www.coremodels.io/connector/dbt/h5-agents)[Use caseThe Consumers dbt Can't SeeYour mart has a contract. It is enforced, it is checked on every build, and it is genuinely good.](https://www.coremodels.io/connector/dbt/h8-contract-of-record) ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [QuickstartManifest In, Contracts Out: A dbt Round Trip in Five StepsMost integrations treat dbt as somewhere to read from. This one also publishes back: governed meaning leaves CoreModels as dbt model property files with enforced contracts, one file per model, colocated beside that model's own .sql. This walkthrough runs the whole loop — artifacts out of dbt, meaning governed on top of them, contracts back into the repo, dbt build green. Nothing here needs a warehouse credential or a dbt platform connection: artifacts in, artifacts out. CoreModels never writes to your repo and never opens a pull request. Generate returns files; your own PR flow lands them.Recipe: Publish governed meaning into dbt](https://www.coremodels.io/connector/dbt/t1-quickstart)[APIFour Verbs and a Fan-Out: The dbt Integration over HTTPThe dbt connector declares Import, Audit, and Generate, and four routes carry the loop that matters: push artifacts in, check them against governed meaning, publish contracts back out, and ask what the last import knew. This is the route-by-route reference — role gating, request bodies field by field, exact response shapes. Throughout, https://coremodels.example.com stands in for your deployment, $TOKEN for your bearer token, and $PROJECT_ID for the 32-character hex id of the governing project. The vendor key is dbt. One property runs through all four: no credentials — artifacts in, artifacts out. CoreModels never connects to your warehouse, never runs dbt, never reads a dbt platform API, and never writes into your repository; Generate hands back files, and your own PR flow lands them.](https://www.coremodels.io/connector/dbt/t2-api)[MCPFour Tools and a Ledger: dbt Contracts from an Agent's Seat"Generate the contracts for stg_orders and stg_customers, and tell me if anything won't apply cleanly." That sentence is an afternoon of dbt property-file maintenance, and an agent connected to CoreModels over MCP can answer it with real tool calls instead of plausible-looking YAML. Four vendor integration tools give the agent the same governance surface a human gets over HTTP: the same role checks, the same read-only guarantees, and the same honest ledger of what could not be represented.](https://www.coremodels.io/connector/dbt/t3-mcp)[AutomationTwo Loops and an Empty Diff: dbt Contract Automation in CITry this on a branch first, because it reframes what the gate is for. Take a model with an accepted_values test, delete the test, and open a pull request.Recipe: The PR your dbt CI passes · What breaks if I rename this?](https://www.coremodels.io/connector/dbt/t4-automation)[Deep diveEvery Line Has a Source: Inside the dbt Contract GeneratorCoreModels publishes governed meaning into a dbt project. You call Generate and get back dbt model property files with enforced contracts — one per model, colocated with the model's own .sql — which your own pull request flow lands in the repo. CoreModels never writes to your repo, never opens the PR, never runs dbt, and never connects to a warehouse; it returns files. Which means the files have to be checkable. Every line the generator emits traces back to a fact recorded in the governed model, and where a fact is missing it omits the line and says why rather than guessing. This is the mechanism in the order it runs, so an engineer reading the output can verify it against the rules instead of trusting it.](https://www.coremodels.io/connector/dbt/t5-deep-dive)[GuideGrounding an Agent in Your dbt Project: What It Reads, and What ChangesAn agent pointed at your warehouse can already write SQL. The question is what it knows about the columns it writes against, and the honest answer is: the names, the types, and whatever free text happens to be in a description. Everything else it infers.Recipe: Stop your agent guessing what status means](https://www.coremodels.io/connector/dbt/t6-agent-grounding)[GuideFinding the accepted_values List That DriftedTwo files in your project test the same column against different value lists. Both tests pass, so nothing has ever told you. This guide finds them, and turns the list into something that can only be defined once.Recipe: One enum, every model](https://www.coremodels.io/connector/dbt/t7-vocabularies)[GuideBuilding an Ownership Register That Survives Contact With a Real TeamOwnership registers fail in a predictable way: someone fills a spreadsheet in a week of good intentions, three people leave over the next year, and the file becomes an archaeological record of who used to work here. This guide builds one that does not do that.Recipe: Who decides what this column means?](https://www.coremodels.io/connector/dbt/t8-ownership) Podcasts ## Listen in Short briefings on how CoreModels works with dbt. EpisodeSep 2, 2026 · 1:21 ### The Definitions Nobody Owns Find a column with an allowed-values test, then another model testing the same column, and compare the lists. In most projects they do not match — and nothing has ever told you. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-01-the-definitions-nobody-owns.m4a) EpisodeSep 2, 2026 · 1:38 ### Both Tests Pass Two files can test the same column with different accepted_values lists and both pass. Each list is internally valid. dbt has no object that spans them, so the drift is invisible. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-02-both-tests-pass.m4a) EpisodeSep 2, 2026 · 1:45 ### The Ticket Nobody Files Someone querying your warehouse at eleven at night finds a column called status. If they are lucky the comment says "status". They guess — and they never file a ticket. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-03-the-ticket-nobody-files.m4a) EpisodeSep 2, 2026 · 1:35 ### What the Machine Knows An agent writing SQL against your warehouse has column names, types, and whatever free text is in the description. Everything else is inference — unless the column can answer for itself. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-04-what-the-machine-knows.m4a) EpisodeSep 2, 2026 · 1:31 ### The Rename Nobody Makes Everyone agrees a column should be renamed. It has been that way for eight months — not because the rename is hard, but because nobody can tell you what it breaks. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-05-the-rename-nobody-makes.m4a) EpisodeSep 2, 2026 · 1:34 ### Who Decides Someone wants to add a value to a status column. They ask in the team channel. Two people reply, one of them hedging. That is not an ownership model. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-06-who-decides.m4a) EpisodeSep 2, 2026 · 1:50 ### The Comparison Nobody Runs Delete an accepted_values test, open a pull request, and everything passes. Every check in the pipeline compares the branch to the last commit — not to what the team agreed the column means. [Download episode](https://www.coremodels.io/connectors/podcasts/dbt/short-07-the-comparison-nobody-runs.m4a) Videos ## Watch Shorts on how CoreModels works with dbt. [Playlist on YouTube](https://www.youtube.com/playlist?list=PLA6FZ5G05Fts) ShortSep 2, 2026 · 1:25 ### The Definitions Nobody Owns A deep-dive technical discussion on why modern data stacks fail to maintain business definitions. We walk through a two-minute diagnostic experiment you can run on your codebase to expose where critical business rules have drifted across duplicated, unlinked files. We examine why traditional PR templates and external catalogs fail because they lack downstream dependents, and we explore how representing business definitions as first-class, named objects can structurally solve this. Finally, we discuss how configuring dbt's native persist_docs comment conduit physically pushes these governed meanings directly into database column comments to reach your downstream analysts in their native SQL autocomplete. ShortSep 2, 2026 · 1:42 ### Both Tests Pass Two senior engineers analyze the "green-build illusion"—why local test suites can remain entirely green even when duplicate permitted-value lists have quietly drifted apart. Because dbt treats enums as isolated, independent string arrays, it lacks a native mechanism to compare them against one another. We discuss the severe operational cost of slightly-wrong data (such as a missed return status code) quietly eroding stakeholder trust on executive dashboards. Finally, we map out how to transition from fragmented string arrays to named, structured vocabularies, and share a practical workflow for sorting your vocabularies by reference count to identify high-leverage business terms. ShortSep 2, 2026 · 1:49 ### The Ticket Nobody Files We examine an invisible, daily breakdown in data communication: the analyst querying raw warehouse tables late at night. Lacking access to your dbt repository, they are forced to guess what ambiguous database columns signify, propagating silent inaccuracies without ever filing a ticket. We discuss why traditional documentation repositories fail to reach these users, and show how configuring dbt's persist_docs setting turns database column comments into a direct conduit. By pushing governed definitions straight into the physical warehouse comments, you meet external analysts exactly where they work, integrating business definitions directly into their SQL autocomplete. ShortSep 2, 2026 · 1:39 ### What the Machine Knows AI coding agents and text-to-SQL systems excel at parsing names and data types, yet they consistently write incorrect queries because they lack access to underlying human intent. We explore the structural difference between SQL computation and semantic logic, analyzing the risks of silent, plausible errors (such as an LLM failing to distinguish between nuanced order return stages). We outline the "fourth option" for LLM integration: providing AI tools with a read-only, human-curated semantic model. Finally, we discuss why writing explicit descriptions of "common mistakes" for your 20 highest-leverage columns yields far better AI-generated SQL than paragraphs of dry documentation. ShortSep 2, 2026 · 1:35 ### The Rename Nobody Makes Why do development teams routinely avoid simple column renames? We break down the unbounded cost of discovering where a schema change propagates. Traditional model-level dependency graphs map internal lineage but completely miss external consumers (reverse-ETL pipelines, BI tools, direct database queries, and external APIs) and semantic owners. We discuss how tracking the conceptual relationship path of a vocabulary through a governed model transforms an endless manual search into a finite, 20-minute checklist, giving engineers the structural confidence to clean up their codebases. ShortSep 2, 2026 · 1:38 ### Who Decides Technical code ownership typically links individuals to physical files, but business definitions frequently span multiple models. This mismatch forces developers to make isolated business decisions they are not qualified to handle. We discuss how to structure a centralized metadata register based on persistent decision forums (which survive individual employee turnover) and explicit review cadences rather than fragile individual assignments. Finally, we analyze a proactive day-one operational strategy: blanket-assigning "wrong" owners to spark corrections and turn a vague cultural issue into a transparent, prioritized backlog of work. ShortSep 2, 2026 · 1:54 ### The Comparison Nobody Runs Modern software development pipelines suffer from a systemic vulnerability: deleted constraints and tests go completely unnoticed in pull requests. Because standard branch-versus-main diffs evaluate only what currently exists, a branch that removes critical tests still passes CI green. We analyze how implementing a "fourth comparison"—evaluating compiled branch projects against a baseline governed model—enforces structural accountability automatically rather than relying on fragile human memory. We close with a practical implementation strategy: triaging and recording deliberate deferrals of existing drift to avoid creating noisy red builds on day one. CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Microsoft Fabric | CoreModels" description: "Catch the warehouse type change that never pages anyone." canonical: "https://coremodels.io/connector/fabric" last_updated: "2026-09-15" --- Early access # Connect Microsoft Fabric Catch the warehouse type change that never pages anyone. [Connect Microsoft Fabric](https://go.coremodels.io/app/new/fabric/generic)[Microsoft Fabric site](https://www.microsoft.com/microsoft-fabric) Recipes ## Recipes Recipes for Microsoft Fabric ### Blank Fabric project A preconfigured home for governing your Fabric Warehouse or SQL Server estate. [Related use →](https://www.coremodels.io/connector/fabric/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/fabric/generic) ### CI Drift Gate for Fabric Fail the schema-change PR when the warehouse drifts from the governed model. [Related use →](https://www.coremodels.io/connector/fabric/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/fabric/ci-drift-gate) ### First Governed Import for Fabric Turn two T-SQL queries into a governed warehouse model. [Related use →](https://www.coremodels.io/connector/fabric/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/fabric/first-governed-import) ### Generate T-SQL DDL from the Governed Model Close the loop: stand up a new environment from governed meaning, not copied DDL. [Related use →](https://www.coremodels.io/connector/fabric/h2-outcomes)[Start this recipe](https://go.coremodels.io/app/new/fabric/generate-back) ### SQL Server Estate Governance Govern a plain SQL Server estate - same connector, same T-SQL extract. [Related use →](https://www.coremodels.io/connector/fabric/h1-need)[Start this recipe](https://go.coremodels.io/app/new/fabric/sqlserver-estate-governance) Connector summary ## What the recipes deliver Import Fabric / SQL analytics metadata and CoreModels records tables, columns, and types as a governed estate. A rebuild that turns `Amount` from decimal to float becomes a named drift finding - not a monthly recon that is a few cents off. ## How CoreModels works with Microsoft Fabric Microsoft Fabric unifies lake and warehouse surfaces. It does not unify a contract for column meaning. SQL Server-style estates inside Fabric inherit the same gap: DDL describes storage, not the business rule the dashboard assumed. CoreModels imports that estate, including SQL Server governance recipes for the parts that still look like SQL Server. Generate-back emits DDL aligned with governed types. The CI drift gate fails the rebuild that changed precision without changing the definition. Use this when Fabric is the production warehouse and you need the semantic layer, the lake tables, and the SQL endpoint to stop silently disagreeing. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemNothing Broke. That's the Problem.The expensive warehouse incidents never announce themselves. A monthly reconciliation comes out a few cents off per row. Every pipeline ran green. Every dashboard rendered. Nobody was paged. Three weeks earlier, a table was rebuilt and an Amount column went from decimal(18,2) to float - and the database did exactly what a database is supposed to do: it stored the values, coerced the types, and answered every query without complaint.Recipe: SQL Server Estate Governance](https://www.coremodels.io/connector/fabric/h1-need)[OutcomesFive Questions a Governed Warehouse Answers Without a MeetingEvery team that owns a Fabric Warehouse or a SQL Server estate fields the same handful of questions. They arrive in stand-ups, in review threads, in messages from someone who needs an answer before lunch. Individually they look small. Collectively they are where warehouse ownership goes: a day tracing a type, an afternoon explaining a join, a standing meeting whose only purpose is to reconstruct what everyone used to know.Recipe: CI Drift Gate for Fabric · First Governed Import for Fabric · Generate T-SQL DDL from the Governed Model · SQL Server Estate Governance](https://www.coremodels.io/connector/fabric/h2-outcomes)[GovernanceA Catalog That Agrees With Everything Can Warn You About NothingHere is a design flaw hiding inside a lot of metadata tooling. Point it at your Fabric Warehouse and it crawls the schema, recording what it finds. Point it again next week and it records what it finds now. The tool is always current, always accurate, and useless for the one job that matters: telling you something changed that should not have.](https://www.coremodels.io/connector/fabric/h3-governance)[EcosystemYour Warehouse Is a Junction, Not a DestinationDraw your data estate on a whiteboard and the warehouse always ends up in the middle of the picture. That placement is accurate about traffic and misleading about authority. A Fabric Warehouse is where things pass through: transformations land tables in it, ingestion tools feed it, semantic layers and reports and notebooks and agents read out of it, and downstream systems copy from it. Very little of what a warehouse table means actually originated in the warehouse.](https://www.coremodels.io/connector/fabric/h4-ecosystem)[AgentsPasting Your Schema Into the Prompt Is Not GroundingThe standard way to make an AI agent useful against a warehouse is to give it the schema: dump the DDL, or scrape INFORMATION_SCHEMA into a text blob, and paste it into the context window with "use this to answer questions about our data." It works well enough to demo, which is why it survives long enough to cause problems.](https://www.coremodels.io/connector/fabric/h5-agents)[QuickstartFrom INFORMATION_SCHEMA to a Governed Model: A Microsoft Fabric WalkthroughYour warehouse already publishes a complete, machine-readable description of itself. Every Fabric Warehouse and SQL analytics endpoint answers SELECT ... FROM INFORMATION_SCHEMA.COLUMNS with the tables, the columns, the types, the nullability. Every one of them answers INFORMATION_SCHEMA.TABLE_CONSTRAINTS with the keys. That description is the whole input CoreModels needs to build a governed model of the estate and then guard it.Recipe: Blank Fabric project · First Governed Import for Fabric · Generate T-SQL DDL from the Governed Model](https://www.coremodels.io/connector/fabric/t1-quickstart)[APIThe Fabric Integration API: Every Route, Every Role, Every PayloadCoreModels exposes vendor integrations over two HTTP surfaces, and the split is not decoration. The interactive surface under graph/integrations/... is what a person or a notebook calls with a normal CoreModels login token. The machine-to-machine surface under v1/... accepts user API keys and is what a build pipeline calls. Both require authentication; both then enforce a per-project role on top of it.](https://www.coremodels.io/connector/fabric/t2-api)[MCPGoverning a Fabric Warehouse from an Agent: the MCP Integration Tools in PracticeAn agent has a context window, not a file system. That single constraint shapes how AI-driven governance of a Microsoft Fabric warehouse actually works: the model cannot paste a forty-megabyte INFORMATION_SCHEMA extract into a tool call, cannot hold your SQL credentials, and should not be trusted to invent a schema comparison in its head. What it can do is call a small set of typed tools that run the real audit engine server-side and hand back a verdict.](https://www.coremodels.io/connector/fabric/t3-mcp)[AutomationWiring the Drift Gate: Continuous Schema Governance for Fabric and SQL ServerSchema governance that lives in a document is not governance. It is a document. The version that actually holds is the one a pipeline can fail on - a single number, checked on every change, with a trail behind it that shows whether the estate is getting better or worse.Recipe: CI Drift Gate for Fabric](https://www.coremodels.io/connector/fabric/t4-automation)[Deep diveIdentity, Types and Honest Loss: What a Fabric Import Actually WritesGovernance starts with a question that sounds trivial and is not: what is a table, once it stops being a table?Recipe: SQL Server Estate Governance](https://www.coremodels.io/connector/fabric/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect AWS Glue | CoreModels" description: "Stop treating a crawler snapshot as the meaning of your lake." canonical: "https://coremodels.io/connector/glue" last_updated: "2026-09-15" --- Early access # Connect AWS Glue Stop treating a crawler snapshot as the meaning of your lake. [Connect AWS Glue](https://go.coremodels.io/app/new/glue/generic)[AWS Glue site](https://aws.amazon.com/glue/) Recipes ## Recipes Recipes for AWS Glue ### Blank Glue project A preconfigured home for governing your Glue Data Catalog - bring your export now or later. [Related use →](https://www.coremodels.io/connector/glue/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/glue/generic) ### CI Drift Gate for Glue Catch crawler re-inference before it breaks something downstream. [Related use →](https://www.coremodels.io/connector/glue/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/glue/ci-drift-gate) ### First Governed Import for Glue Turn one AWS CLI call into a governed lake catalog. [Related use →](https://www.coremodels.io/connector/glue/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/glue/first-governed-import) ### Generate Athena DDL from the Governed Model Close the loop: governed meaning rides back out as CREATE EXTERNAL TABLE COMMENTs. [Related use →](https://www.coremodels.io/connector/glue/h2-outcomes)[Start this recipe](https://go.coremodels.io/app/new/glue/generate-back) ### Lake Catalog Governance Give your S3 lake a second, independent account of what it is supposed to look like. [Related use →](https://www.coremodels.io/connector/glue/h1-need)[Start this recipe](https://go.coremodels.io/app/new/glue/lake-catalog-governance) Connector summary ## What the recipes deliver Import the Glue Data Catalog and CoreModels records databases, tables, and columns as governed types. A crawler that retypes a bigint into a string after a few malformed files becomes a drift finding, not a join that silently returns nothing. ## How CoreModels works with AWS Glue A lake catalog is an observation. A governed model is a decision. CoreModels imports Glue metadata into the same estate model used for Snowflake and BigQuery, then audits later crawls against the decision. Lake catalog governance recipes focus on the tables dashboards actually depend on - not every partition the crawler ever touched. Generate-back and the CI gate keep the approved shape from being overwritten by a weekend job. This is how you keep Glue as a crawler and stop using it as an accidental source of truth. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Catalog Knows Your Tables. It Doesn't Know What They Mean.A crawler ran over the weekend. On Monday, a column in a table your finance dashboards depend on is no longer a bigint - a few malformed rows in a new S3 partition convinced the crawler it was looking at strings. Nothing failed. Nothing alerted. The Glue Data Catalog did exactly what it is designed to do: it recorded what the files look like now. The first person to notice is an analyst three days later, staring at a join that silently returns nothing.Recipe: Lake Catalog Governance](https://www.coremodels.io/connector/glue/h1-need)[OutcomesAfter the Import: What a Governed Glue Catalog Changes Day to DayThe honest test of any governance tool is not the demo - it is what an ordinary Tuesday looks like six weeks after you adopted it. So instead of walking through features, let us walk through a week with a Glue Data Catalog that has a governed CoreModels project behind it, and contrast each moment with how the same moment used to go.Recipe: CI Drift Gate for Glue · First Governed Import for Glue · Generate Athena DDL from the Governed Model · Lake Catalog Governance](https://www.coremodels.io/connector/glue/h2-outcomes)[GovernanceRead-Only by Design: How We Earn Trust With Your Glue Catalog"What does it touch?" is the first question a platform team asks about any tool that wants to look at their data lake, and it is the right question. Our answer for the AWS Glue integration is unusually short: nothing in your AWS account, ever. CoreModels never holds AWS credentials and never opens a connection to AWS. You run aws glue get-tables yourself, with your own credentials, inside your own perimeter, and upload the resulting JSON. A live-sync mode is a capability we have deliberately deferred rather than quietly shipped, precisely because "we'll be careful with your keys" is a weaker promise than "we never have them."](https://www.coremodels.io/connector/glue/h3-governance)[EcosystemGlue Is the Metastore. It Shouldn't Have to Be the Meaning.Few pieces of infrastructure are load-bearing for as many systems as the AWS Glue Data Catalog. It began as a managed, Hive-compatible metastore and became the connective tissue of the AWS analytics stack: crawlers and Glue ETL jobs populate it, Athena resolves every query through it, EMR and Redshift Spectrum read it, Lake Formation layers permissions over it. If your data lives in S3 and you query it with SQL, the catalog is almost certainly in the path.](https://www.coremodels.io/connector/glue/h4-ecosystem)[AgentsAgents Shouldn't Guess at the Data LakeGive an AI agent access to Athena and ask it a business question - "how many participants enrolled last quarter" - and you can watch it improvise. It lists tables and picks the one whose name sounds right. It infers that status = 'active' probably means enrolled, because what else would it mean? It writes a query that scans every partition because nothing told it the table was partitioned by month. The SQL is fluent, the answer arrives with confidence, and every load-bearing assumption in it was a guess.](https://www.coremodels.io/connector/glue/h5-agents)[QuickstartTen Minutes to a Governed Glue CatalogOpen a terminal. Everything in this tutorial is one AWS CLI command and two HTTP calls, and at the end of it your AWS Glue Data Catalog has a governed twin in CoreModels plus a first drift audit you can read line by line. Nothing gets installed in your AWS account, no IAM role is granted to us, and no credential of yours travels anywhere: you run the CLI, you upload the JSON it printed.Recipe: Blank Glue project · First Governed Import for Glue · Generate Athena DDL from the Governed Model](https://www.coremodels.io/connector/glue/t1-quickstart)[APIThe AWS Glue Integration API, Route by RouteCoreModels models vendor governance as a small, fixed set of verbs and applies them uniformly to every connector. For AWS Glue Data Catalog - vendor key glue - that is eight core routes on the interactive surface and two on the machine-to-machine surface. (A newer sync-plan surface - sync/propose, plan fetch, and the sync ledger - sits beside these and is not covered here.) This is the reference: the exact paths, the role each one enforces, the request bodies as the API defines them, and the responses you actually get back.](https://www.coremodels.io/connector/glue/t2-api)[MCPHanding the Glue Catalog to an Agent: CoreModels over MCPAn agent that can answer "did our lake drift?" needs three things: a way to reach the governed model, a way to hand it a fresh catalog export, and a guarantee that asking the question cannot change the answer. The CoreModels MCP server provides all three. The same vendor-integration engine behind the HTTP routes is exposed as MCP tools, with the read verbs at Viewer role and the write verbs behind an admin endpoint and real project membership.](https://www.coremodels.io/connector/glue/t3-mcp)[AutomationAutomating Glue Drift: The Gate, the Trail, and the HeartbeatNothing in your repository changes when a crawler retypes a column. That is the awkward fact about lake governance: the estate you need to watch does not live in git, so the usual "run it on pull requests" reflex leaves the interesting drift entirely unobserved. A Glue drift gate has to be driven by a clock, not by a commit - and once it is, three more mechanisms fall out of it almost for free: a rolling trail, a status badge, and a server-side heartbeat that watches the other direction of drift.Recipe: CI Drift Gate for Glue](https://www.coremodels.io/connector/glue/t4-automation)[Deep diveWhat Happens to a Glue Table on Its Way into the GraphTake one entry out of an aws glue get-tables response - a table called events in database lake, a few columns, one partition key, a classification parameter, an S3 location - and follow it into CoreModels. By the end it is a governed Type with Elements, a vendor identity, a metadata mixin, an entry in an estate snapshot, and a set of audit rules watching it. This is that journey, plus the honest edges: what is approximated, what is deliberately not invented, and which behaviors will surprise you.Recipe: Lake Catalog Governance](https://www.coremodels.io/connector/glue/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect JSON-LD | CoreModels" description: "Make the vocabulary you already trust executable downstream." canonical: "https://coremodels.io/connector/jsonld" last_updated: "2026-09-15" --- FormatGA # Connect JSON-LD Make the vocabulary you already trust executable downstream. [Import a JSON-LD file](https://go.coremodels.io/app/new/jsonld)[JSON-LD site](https://json-ld.org/) Recipes No recipes yet for JSON-LD. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import a JSON-LD vocabulary or context and CoreModels records classes, properties, and globally unique identifiers as governed types. Downstream JSON Schema, SQL, and streams can be generated from that vocabulary instead of hand-copied from it. ## How CoreModels works with JSON-LD JSON-LD is a description of meaning: `@graph` classes and properties, `@context` expansions, stable IRIs. Pipelines need schemas they can validate and tables they can load. The usual bridge is a person with a deadline. CoreModels decodes JSON-LD into the neutral model and encodes out to the formats those pipelines actually run. The lossiness ledger shows which constraints traveled and which could not. Re-import the vocabulary and audit generated artifacts against it so the next curator edit is not stranded in a file nothing reads. Use this when the vocabulary is already the best description of the business - and you are tired of every system keeping its own stale copy. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemYou Already Have the Vocabulary. Why Can't Anything Use It?Somewhere in most organizations that take meaning seriously, there is one document nobody argues with. It might be a partner's published vocabulary, a domain model built by a standards-literate team, or a profile of schema.org. It is written in JSON-LD: classes and properties in an @graph, each carrying a globally unique identifier, with a @context declaring exactly which namespace every short name expands into. It is often the most carefully reasoned description of the business anyone in the building owns.](https://www.coremodels.io/connector/jsonld/h1-need)[OutcomesAfter the Import: The Requests That Stop Being ProjectsThe clearest sign that a vocabulary has been properly adopted is not a diagram. It is a category of request that stops requiring a meeting.](https://www.coremodels.io/connector/jsonld/h2-outcomes)[GovernanceWho Is Allowed to Change What Your Model Means?Every organization has an answer, and in most of them the honest one is: whoever ran the last import. A tool ingested a document, wrote what it found, and a governed concept shifted meaning because a parser made a decision at three in the morning.](https://www.coremodels.io/connector/jsonld/h3-governance)[EcosystemJSON-LD Is Everywhere Except in Your PipelineYou have already shipped JSON-LD, whether or not you think of it that way. It sits in the head of your marketing pages as structured data. It is how schema.org publishes its own vocabulary. It is the interchange shape for a great many knowledge graphs, research catalogs and public reference datasets, because it lets a document be plain JSON to an application developer and RDF to a triplestore at the same time.](https://www.coremodels.io/connector/jsonld/h4-ecosystem)[AgentsA Field Name Is a RumorGive a capable model two schemas and ask it to align them. It will produce a clean mapping table in seconds: name to full_name, status to state, created to one of the four fields called date. Most rows will be right - which is what makes the output dangerous. A mapping that is mostly right ships, and the rest becomes a data-quality incident with excellent grammar.](https://www.coremodels.io/connector/jsonld/h5-agents)[QuickstartZero to First Transform: Running a JSON-LD Vocabulary Through CoreModelsBy the end of this page you will have made exactly one HTTP call and produced two artifacts: a JSON Schema generated from an RDF vocabulary, and a lossiness ledger that states - in writing - what the conversion could not carry across. Learning to read both is the entire skill. Everything else in the CoreModels transform surface is a variation on this loop.](https://www.coremodels.io/connector/jsonld/t1-quickstart)[APIFour Verbs and a Vocabulary: The JSON-LD HTTP Surface, With Real BodiesEverything you can do with an RDF vocabulary on the CoreModels HTTP API fits in four routes. One writes a vocabulary into a governed project, one publishes a project back out as a vocabulary, one converts statelessly through the mapping engine, and one replays a stored conversion. This article walks all four with request and response bodies we actually ran, then states the direction limits plainly - including the one that has no ledger entry to warn you about it.](https://www.coremodels.io/connector/jsonld/t2-api)[MCPThree Questions an Agent Must Answer After Converting a SchemaWhen an agent converts a vocabulary into something else, it should be able to answer three questions afterwards: what did it produce, what did it lose, and can it do that again identically? Most conversion tooling answers the first. The transform_schema tool on the CoreModels MCP server answers all three in a single call - the produced schema, an explicit lossiness ledger, and the executed plan as a replayable artifact. This article runs a JSON-LD vocabulary through it end to end, with the exact arguments and the exact response.](https://www.coremodels.io/connector/jsonld/t3-mcp)[AutomationBoring on Purpose: JSON-LD Conversion Pipelines That Produce the Same Bytes Every TimeA generated artifact is only trustworthy if it is boring. If regenerating last week's JSON Schema from the same vocabulary reshuffles keys, renames anonymous constructs, or quietly drops a constraint, then the diff in your pull request is noise and nobody reads it. This article is our recipe for the opposite: JSON-LD conversions that are byte-stable, gated by a reviewed plan, and loud when meaning is lost.](https://www.coremodels.io/connector/jsonld/t4-automation)[Deep diveThe Coder That Never Complains: A Full Accounting of JSON-LD Fidelity in CoreModelsHere is the fact that should make you suspicious: in either direction, the CoreModels JSON-LD coder emits no lossiness records at all. Not "few" - none. Most coders in the engine keep a list of things they apologize for; this one's ledger is empty. That is either an honest structural property or a place where losses hide, so this article is the accounting: what maps to what, what rides in the extras channel, what the @id contract guarantees, where fidelity breaks, and what the tests pin down.](https://www.coremodels.io/connector/jsonld/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect JSON Schema | CoreModels" description: "Stop asking a validator four questions it was only built to answer one of." canonical: "https://coremodels.io/connector/jsonschema" last_updated: "2026-09-15" --- FormatGA # Connect JSON Schema Stop asking a validator four questions it was only built to answer one of. [Import a JSON Schema file](https://go.coremodels.io/app/new/jsonschema/agent-schema-access)[JSON Schema site](https://json-schema.org/) Recipes ## Recipes Recipes for JSON Schema ### Agent schema access over MCP Give your agents the governed schema - profiles, export and validation as tools. [Related use →](https://www.coremodels.io/connector/jsonschema/h5-agents)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/agent-schema-access) ### Blank JSON Schema project A schema-shaped workspace: Objects, Properties and Enums from the first click. [Related use →](https://www.coremodels.io/connector/jsonschema/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/generic) ### First schema import - living example Land inside an imported schema: objects on the grid, enums as taxonomies, rules in the Rule Builder. [Related use →](https://www.coremodels.io/connector/jsonschema/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/first-schema-import) ### GitHub sync round trip Schema-as-code with review gates in both directions. [Related use →](https://www.coremodels.io/connector/jsonschema/h3-governance)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/github-sync-round-trip) ### Import profile walkthrough Own the mapping: a named profile that decides what every key becomes. [Related use →](https://www.coremodels.io/connector/jsonschema/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/import-profile-walkthrough) ### Validation gateway - your model is the validator Validate real payloads against the governed model itself, never a stale copy. [Related use →](https://www.coremodels.io/connector/jsonschema/h2-outcomes)[Start this recipe](https://go.coremodels.io/app/new/jsonschema/validation-gateway) Connector summary ## What the recipes deliver Import a JSON Schema through a CoreModels profile and objects, properties, enums, `$ref` composition, and rules land on a governed graph. Validation stays in JSON Schema. ## How CoreModels works with JSON Schema JSON Schema earned its adoption because it is easy to write and trivial to validate against. That success is why it gets overloaded. Reviews ask identity questions the file cannot prove. Enums fork. `x-` keys accumulate. Profiles differ between teams. CoreModels import profiles make that overload explicit: objects become types, properties become elements, enums become taxonomies, `oneOf` lands in the rule builder, and unknown keywords can become mixins instead of being dropped. Recipes cover the first import, validation gateway, GitHub round trip, agent schema access, and a living sample you can walk through. Keep JSON Schema as the interchange and the validator. Let CoreModels be the place meaning is reviewed, mapped, and regenerated. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemYour JSON Schema Answers One Question. You Keep Asking It Four.The review comment that starts the trouble is always polite. "Quick question - is this customer_id the same one the warehouse calls customer_key?" The pull request adds two properties to a JSON Schema file. The author is fairly sure the answer is yes. Nobody can prove it from what is on the screen, because what is on the screen is a validator, and validators do not carry that kind of knowledge. The reviewer approves. The question stays open, and the next person to ask it will be an on-call engineer at an inconvenient hour.](https://www.coremodels.io/connector/jsonschema/h1-need)[OutcomesThe Week a Schema Change Stopped Being a ProjectAdd one property. That is the entire request: sales needs preferredChannel on the customer record, three allowed values, by Friday.Recipe: First schema import - living example · Validation gateway - your model is the validator](https://www.coremodels.io/connector/jsonschema/h2-outcomes)[GovernanceThe Second Import Is Where Trust Is WonAnyone can survive the first import. You feed a JSON Schema into a tool, something appears on the other side, and it looks broadly right. The interesting moment is the second - six weeks later, when the schema has changed, other people depend on the model, and a quiet alteration would propagate into a warehouse table, a partner contract, and a validation rule before anybody noticed.Recipe: GitHub sync round trip](https://www.coremodels.io/connector/jsonschema/h3-governance)[EcosystemCount the JSON Schemas You Used Today Without NoticingBefore lunch you probably touched five of them. The request body in an API definition is JSON Schema. The configuration file that failed CI with a helpful message was validated against JSON Schema. If your team runs a schema registry, some of the subjects in it are JSON Schema rather than Avro. If you asked a model for structured output, the shape you asked for was JSON Schema. And if you used an AI assistant with tools, every one of those tool contracts - the argument names, the types, the required list - was JSON Schema too.](https://www.coremodels.io/connector/jsonschema/h4-ecosystem)[AgentsThe Wrong Schema an Agent Writes Looks Exactly Like the Right OneHere is the failure mode that costs teams real time. You ask an assistant to draft a JSON Schema for the customer object it is about to integrate against, and it produces something clean: sensible property names, a tidy required array, an enum on the status field, format: "date-time" where a timestamp belongs. It looks like something your team would have written. It goes into a pull request and gets approved.Recipe: Agent schema access over MCP](https://www.coremodels.io/connector/jsonschema/h5-agents)[QuickstartOne Call, Three Answers: Your First JSON Schema TransformEvery transform call in CoreModels returns three things, and the third one is the reason we built it this way. You get the converted schema. You get the plan that produced it. And you get a ledger of everything the conversion could not carry across exactly - written in English, with a path pointing at the construct it happened to.Recipe: Blank JSON Schema project · First schema import - living example](https://www.coremodels.io/connector/jsonschema/t1-quickstart)[APIFour Routes and a Round Trip: JSON Schema Over HTTPA couple of format keys in the CoreModels transform surface are honest about being one-way. odm decodes only, because entity documentation is authored, not generated. synapse encodes only, and says so out loud when you try the other direction: "'synapse' is encode-only: a Synapse schema is plain draft-07 JSON Schema - decode it with the 'jsonschema' format."](https://www.coremodels.io/connector/jsonschema/t2-api)[MCPGive an Agent a JSON Schema and a Target: transform_schema Over MCPAn agent working on your repository will find a .schema.json file long before it finds your conversion documentation. What happens next depends entirely on the tools it can reach. Without one, it writes a converter, or worse, writes the target schema from scratch and presents its guesses with the same confidence as facts.Recipe: Agent schema access over MCP](https://www.coremodels.io/connector/jsonschema/t3-mcp)[AutomationSame Plan, Same Bytes: Automating JSON Schema ConversionA generator you cannot re-run and get identical output from is not a build step. It is a rumor with a timestamp. That is the practical objection to putting schema conversion in a pipeline: if today's run can differ from yesterday's for reasons nobody logged, then the generated Avro, the generated DDL, and the generated proto files are all provisional, and reviewing them is theater.Recipe: GitHub sync round trip](https://www.coremodels.io/connector/jsonschema/t4-automation)[Deep diveThe Fidelity Contract: JSON Schema to IR and Back, Construct by ConstructEvery format coder in CoreModels has to answer the same awkward question: what do you do with the parts of a document you do not model? There are three bad answers - drop them, guess at them, or refuse the document - and one good one, which is to carry them untouched and be explicit about the handful of cases where carrying them is not enough.Recipe: Import profile walkthrough](https://www.coremodels.io/connector/jsonschema/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect LinkML | CoreModels" description: "Let the pipeline read the model that is already right." canonical: "https://coremodels.io/connector/linkml" last_updated: "2026-09-15" --- Format # Connect LinkML Let the pipeline read the model that is already right. [Import a LinkML file](https://go.coremodels.io/app/new/linkml)[LinkML site](https://linkml.io/) Recipes No recipes yet for LinkML. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import a LinkML schema and CoreModels records classes, slots, enumerations, and `meaning` URIs as governed types. Generated JSON Schema, SQL, Avro, and Synapse artifacts can be audited against the model curators actually edit. ## How CoreModels works with LinkML LinkML is designed as a source of truth for biomedical and scientific models. Generation exists - and teams still copy. Every copy starts drifting the day it is made. CoreModels treats the LinkML file as an importable estate. Enumerations with meanings become taxonomies tied to URIs. Slots become elements with types and constraints. Conversion recipes (including LinkML to Synapse) carry a ledger of what the target format cannot hold. Re-import after a curator change and the CI gate fails the pipeline artifacts that did not hear about the new permissible value. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemYour LinkML Model Is Right. Your Pipeline Never Read It.The ticket that lands on a Monday morning rarely says "semantic drift." It says: rows rejected, unexpected value in sex column. Someone traces it back. Six weeks earlier a curator added a permissible value to an enum in the team's LinkML model, complete with a meaning URI pointing at a specific ontology term. The model was correct that day and has been correct every day since. The warehouse constraint, the JSON Schema the API validates against, and the Avro subject in the registry were each written by hand from an older reading of that file, and none of them heard about the change.](https://www.coremodels.io/connector/linkml/h1-need)[OutcomesOne Model, Every Downstream Format: What Governed LinkML Actually Buys YouThe clearest sign that a team has adopted this is what has gone missing from their repository. The four hand-maintained schema files that used to shadow the LinkML model - a DDL script, a JSON Schema, an Avro subject definition, a catalog entry - are no longer there. Not stale, not deprecated, not marked "regenerate me." Gone, because they are outputs now.](https://www.coremodels.io/connector/linkml/h2-outcomes)[GovernanceWho Approved That Meaning? Governing a LinkML Model You Can DefendSooner or later somebody senior asks a question that sounds simple and is not: how do you know the column in the warehouse means what the model says it means, and who decided that?](https://www.coremodels.io/connector/linkml/h3-governance)[EcosystemLinkML Doesn't Need Us to Generate JSON SchemaStart with the awkward fact; it is the honest way in. LinkML already ships a generator toolchain. If your entire need is "turn this model into a validation artifact," the project's own tooling does that, maintained by the people who write the specification, and you should keep using it. A product that opens by claiming otherwise is selling something.](https://www.coremodels.io/connector/linkml/h4-ecosystem)[AgentsThe Expensive Kind of Wrong: Agents, LinkML, and Guessed SemanticsThe costly failure of an AI agent working on schemas is not the one that errors out. It is the output that is perfectly well-formed and quietly invented - valid YAML, sensible field names, a plausible type for every slot, and three or four decisions nobody made. It passes review because it looks like the work, and fails in production.](https://www.coremodels.io/connector/linkml/h5-agents)[QuickstartLinkML to Postgres in One Call: A CoreModels QuickstartTen minutes, one YAML file, one HTTP call. By the end of this you will have converted a LinkML schema into Postgres DDL through CoreModels, read the machine-readable ledger of everything the conversion could not carry exactly, and sent the same schema back out as LinkML unchanged.](https://www.coremodels.io/connector/linkml/t1-quickstart)[APIThe LinkML HTTP Surface: Import, Export, Map, ReplayThere are ten routes on the CoreModels transform API. Five of them matter if LinkML is your source or your target, and the first thing to settle is which one you actually want - because the difference between them is not the format, it is whether anything gets written and who decides what passes through.](https://www.coremodels.io/connector/linkml/t2-api)[MCPGive an Agent a LinkML Schema: transform_schema over MCP> Analyst: Here's our product catalog in LinkML. The warehouse team needs a Postgres table for it. What do we lose?](https://www.coremodels.io/connector/linkml/t3-mcp)[AutomationPlans, Not Scripts: Repeatable LinkML Conversion PipelinesA conversion you cannot reproduce is not a pipeline; it is a favor someone did once. The interesting question for automation is not "can this tool turn LinkML into Postgres DDL" - it is "will the run in six months, on a build agent, with a token nobody remembers issuing, produce the same bytes and tell me if it did not."](https://www.coremodels.io/connector/linkml/t4-automation)[Deep diveInside the LinkML Coder: Every Construct, Every LossStart with one line of YAML:](https://www.coremodels.io/connector/linkml/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Neo4j | CoreModels" description: "Write down the graph schema MERGE has been inferring for you." canonical: "https://coremodels.io/connector/neo4j" last_updated: "2026-09-15" --- Early access # Connect Neo4j Write down the graph schema MERGE has been inferring for you. [Connect Neo4j](https://go.coremodels.io/app/new/neo4j/generic)[Neo4j site](https://neo4j.com/) Recipes ## Recipes Recipes for Neo4j ### Blank Neo4j project A preconfigured home for governing your Neo4j graph - bring artifacts now or later. [Related use →](https://www.coremodels.io/connector/neo4j/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/neo4j/generic) ### CI Drift Gate for Neo4j Fail the build when your graph drifts from the governed model. [Related use →](https://www.coremodels.io/connector/neo4j/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/neo4j/ci-drift-gate) ### First Governed Import for Neo4j Turn apoc.meta.schema() into a governed model in one upload. [Related use →](https://www.coremodels.io/connector/neo4j/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/neo4j/first-governed-import) ### Generate Neo4j Constraints from the Governed Model Close the loop: make Neo4j enforce the governed shape. [Related use →](https://www.coremodels.io/connector/neo4j/h3-governance)[Start this recipe](https://go.coremodels.io/app/new/neo4j/generate-back) ### GraphRAG Grounding for Agents Stop agents guessing your graph schema - give them the governed model over MCP. [Related use →](https://www.coremodels.io/connector/neo4j/h5-agents)[Start this recipe](https://go.coremodels.io/app/new/neo4j/graphrag-grounding) Connector summary ## What the recipes deliver Import Neo4j constraints, indexes, and labels and CoreModels records the property graph as a governed model - nodes, relationships, keys, and the uniqueness rules MERGE assumed. GraphRAG grounding recipes then point agents at meaning, not at whatever happened to be loaded. ## How CoreModels works with Neo4j Property graphs accumulate implicit schemas: labels, relationship types, property keys, uniqueness that exists only if someone created a constraint. Documentation is a diagram from last year. CoreModels imports what the database will actually enforce and what the model files claim, then lets you govern the rest. Generate-back can emit constraints aligned with the definition. GraphRAG grounding uses that definition so retrieval is not guessing node shape. Use this when the graph is a product surface - search, recommendations, agents - and silent duplicates are more expensive than a missing unique constraint looks. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Schema You Never Wrote DownA duplicate-node incident is one of the quietest failures in software. Nothing throws. No log line turns red. A MERGE (p:Person {email: $email}) runs a few hundred thousand times a day and, for eleven months, does exactly what everyone expects. Then a second ingestion path is added - this one merges on name, because that is what the upstream file happened to carry - and the graph starts growing two Person nodes where there used to be one. Traversals still return results. Dashboards still render. The number of people in the company just slowly stops being true.Recipe: GraphRAG Grounding for Agents](https://www.coremodels.io/connector/neo4j/h1-need)[OutcomesFour Things That Exist AfterwardsAdoption stories usually get told as a list of features. This one is easier to tell as an inventory: after a team wires CoreModels to their Neo4j instance, four artifacts exist that did not exist before, and almost everything that changes about the week is downstream of those four.Recipe: CI Drift Gate for Neo4j · First Governed Import for Neo4j](https://www.coremodels.io/connector/neo4j/h2-outcomes)[GovernanceRead the Roles, Not the BrochureYou can predict how a tool will behave inside your systems by reading which of its operations require which permission. Roles are enforced by code paths; brochures are not.Recipe: Generate Neo4j Constraints from the Governed Model](https://www.coremodels.io/connector/neo4j/h3-governance)[EcosystemCount the Homes of One EntityPick a single entity in your organization - Customer, Patient, Instrument, whatever your domain calls the thing everything else hangs off - and count where it physically lives. In a serious estate the count is rarely below four. It is a label in Neo4j. It is a table in a warehouse. It is a subject in a schema registry. It is a model in a transformation project, a form in a capture system, a class in an application's JSON Schema.](https://www.coremodels.io/connector/neo4j/h4-ecosystem)[AgentsSix Guesses Before the First HopAsk an agent a question about your graph - "which companies do our top account contacts work for?" - and watch what it has to decide before it can write a single line of Cypher.Recipe: GraphRAG Grounding for Agents](https://www.coremodels.io/connector/neo4j/h5-agents)[QuickstartYour First Neo4j Schema Audit: A Complete Worked ExampleTake a small graph - three labels, a handful of properties, three relationship types. By the end of this article that graph has a governed model in CoreModels and a recorded baseline audit that tells you, in machine-readable form, exactly what is under governance and where the graph is structurally weak. Total effort: two Cypher statements and two HTTP calls.Recipe: Blank Neo4j project · First Governed Import for Neo4j · Generate Neo4j Constraints from the Governed Model](https://www.coremodels.io/connector/neo4j/t1-quickstart)[APIThe Neo4j Integration API, Route by RouteTen routes, two surfaces, one rule about who is allowed to write. That is the core HTTP contract for governing a Neo4j estate with CoreModels, and this article documents it exhaustively - payloads, roles, response shapes, and the failure modes you will actually hit.](https://www.coremodels.io/connector/neo4j/t2-api)[MCPFour Tools, One Knowledge Graph: Neo4j Governance from the Agent SideAn AI agent connected to CoreModels over MCP sees a small, deliberately shaped set of vendor-integration tools. Three of them cannot write anything at all; the fourth requires Admin membership on the project and a different endpoint. That shape is the point of this article: an agent can drive the entire Neo4j governance loop - discover, audit, report, generate the fix - while the only mutating step in the loop stays behind an explicit privilege boundary.Recipe: GraphRAG Grounding for Agents](https://www.coremodels.io/connector/neo4j/t3-mcp)[AutomationAutomating Neo4j Drift Control: The Gate, the Trail, the Badge, the HeartbeatMost CI integrations start with an artifact the build already produces. Neo4j does not produce one - there is no compile step for a property graph, no manifest, no migration file that reviewers can read. So the first job in automating Neo4j governance is not writing the gate. It is deciding where meta_schema.json comes from in your pipeline.Recipe: CI Drift Gate for Neo4j](https://www.coremodels.io/connector/neo4j/t4-automation)[Deep diveProjecting a Property Graph onto a Governed Model: Inside the Neo4j ConnectorCoreModels has one estate model and every vendor parses into it: datasets (table-shaped things) with fields and normalized checks, plus lineage edges and projections. A dbt project, a warehouse schema, and a schema registry all land in the same shape.](https://www.coremodels.io/connector/neo4j/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect ODCS data contracts | CoreModels" description: "Make the contract a derived artifact of governed meaning, not a YAML twin of the table." canonical: "https://coremodels.io/connector/odcs" last_updated: "2026-09-15" --- FormatEarly access # Connect ODCS data contracts Make the contract a derived artifact of governed meaning, not a YAML twin of the table. [Import a ODCS file](https://go.coremodels.io/app/new/odcs)[ODCS site](https://www.datacontract.com/) Recipes No recipes yet for ODCS. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import an ODCS document or generate one from a governed estate. CoreModels treats the contract as encode/decode of the same model audits already enforce - so `rcvr_id` cannot be retyped in the warehouse while the contract still says varchar(18). ## How CoreModels works with ODCS ODCS settled the format question for data contracts. Enforcement is still the open problem. Hand-maintained contract YAML decays at the same rate as the `schema.yml` files it was supposed to improve on. CoreModels decodes ODCS into the governed model and encodes the governed model back to ODCS. The dbt contract-of-record recipe is the same idea from the producer side: import marts, audit them, publish ODCS for everyone who never runs dbt. A contract nobody governs is a wish. A contract inside the audit loop is a definition with a history. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Cheapest Way to Break a Data Contract Is to Retype ItHere is one property from an ordinary data contract, written in the Open Data Contract Standard:](https://www.coremodels.io/connector/odcs/h1-need)[OutcomesThe Meeting That Stops HappeningThe clearest measure of a governance tool is not a feature list. It is a meeting that falls off the calendar.](https://www.coremodels.io/connector/odcs/h2-outcomes)[GovernanceSeven Things Our ODCS Support Refuses to DoWe could describe how CoreModels handles data contracts as a list of capabilities. It is more useful to describe it as a list of refusals, because in governance the interesting question is never what a tool can do. It is what the tool will not do to your document when nobody is watching.](https://www.coremodels.io/connector/odcs/h3-governance)[EcosystemODCS Is Not Competing With Your Schema FormatA question we get early in most conversations: "If we adopt ODCS, do we stop using JSON Schema?"](https://www.coremodels.io/connector/odcs/h4-ecosystem)[AgentsThe Fine Print Is Where Agents FailEvery data contract has a headline and a fine print. The headline is the list of columns and their types; any competent reader gets that right. The fine print is the rest: that this primary key is explicitly required: false; that this column is classified restricted and has an encrypted counterpart; that the quality check on the amount column demands a null count of exactly zero at error severity.](https://www.coremodels.io/connector/odcs/h5-agents)[QuickstartOne Contract, Three Schemas: An ODCS QuickstartA data contract is a promise with a schema inside it. The ODCS documents your platform team publishes - Open Data Contract Standard, the Bitol project's v3 line - carry tables and columns, but also servers, quality checks, SLAs, ownership: everything the promise needs and most target formats cannot hold. This quickstart takes one real contract through a single CoreModels call three times - to JSON Schema, to SQL, and back to ODCS - and shows you how to read what each conversion kept, what it set aside, and where the set-aside parts went.](https://www.coremodels.io/connector/odcs/t1-quickstart)[APIODCS Over HTTP: The Transform Routes for Data ContractsDirection first, because we publish it per format and it decides what you can build. The format key odcs appears in both of CoreModels' transform lists - decode (jsonschema | shex | avro | jsonld | sql | osi | osi-json | owl | linkml | protobuf | odcs | odm) and encode (jsonschema | shex | avro | jsonld | sql | osi | osi-json | owl | linkml | protobuf | odcs | synapse). ODCS round-trips. Its neighbors do not all manage that: odm decodes only (ODM entities are authored documentation, and we do not generate prose), and synapse encodes only (its output is plain draft-07 JSON Schema - re-import it as jsonschema). What odcs means here is a Bitol Open Data Contract Standard v3 document - apiVersion: v3.1.0, kind: DataContract - as YAML or JSON.](https://www.coremodels.io/connector/odcs/t2-api)[MCP"Turn Our Data Contract Into an Avro Schema": ODCS Through transform_schema"The platform team publishes the orders contract - can you make the Avro schema for the streaming team?" That sentence, said to an agent with no tools, produces plausible-looking .avsc with invented decisions baked in. Said to an agent connected to CoreModels over MCP, it becomes a call to transform_schema: a deterministic engine does the conversion, and the agent gets back the schema, the executed plan, and a machine-readable account of what the trip cost. This article is the complete loop for ODCS - connection, the exact tool contract, two real conversions, and the contract-specific habits that separate a good agent from a confident one.](https://www.coremodels.io/connector/odcs/t3-mcp)[AutomationThe Contract Pipeline Is a Plan File: Automating ODCS With ReplayAutomation is where schema tooling usually stops being honest. A conversion that a human runs once gets its output eyeballed; the same conversion in a nightly job gets trusted. So the two properties that matter most for automating data contracts are not features, they are guarantees: CoreModels transforms are deterministic - the same contract in produces byte-identical output every run, which makes diffs a real review surface - and every mapping executes from a plan that comes back in the response as JSON you can commit, review, and replay. This article builds an ODCS pipeline on those guarantees: a published subset of an internal contract, regenerated on every change, with drift caught by the engine instead of by a consumer.](https://www.coremodels.io/connector/odcs/t4-automation)[Deep diveAnatomy of the ODCS Coder: What Maps, What Rides, What's DeclaredWhere does servers: go?](https://www.coremodels.io/connector/odcs/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect MACH Open Data Model | CoreModels" description: "Stop shipping a recollection of the standard as if it were the standard." canonical: "https://coremodels.io/connector/odm" last_updated: "2026-09-15" --- Format # Connect MACH Open Data Model Stop shipping a recollection of the standard as if it were the standard. [Import a MACH ODM file](https://go.coremodels.io/app/new/odm)[MACH ODM site](https://docs.machalliance.org/) Recipes No recipes yet for MACH ODM. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import MACH Open Data Model entity documents and CoreModels records the published types, attributes, and relationships as a governed estate. Downstream JSON Schema copies can be audited against the source instead of a comment that says “adapted from.” ## How CoreModels works with MACH ODM ODM entity documents are meant to be shared. Implementation teams type them into JSON Schema under deadline. Versions diverge. Required flags flip. Nobody can say which published revision the running API implements. CoreModels imports the published definition as the baseline. Generated or existing schemas are then findings, not folklore. Because ODM is decode-oriented in the converter, you govern from the entity docs rather than pretending generated copies are authoritative. Use this when “we follow MACH” needs to be a check, not a README claim. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemTranscription Is Where Conformance Goes to DieOpen almost any codebase that claims to follow an open data standard and, sooner or later, you find the file. It sits in a schemas/ folder, named something like customer.schema.json, and near the top there is a comment: adapted from the MACH ODM entity definition. No version. No date. No link back to the source. Somebody, once, working against a deadline, read a published entity document and typed out what they believed it said.](https://www.coremodels.io/connector/odm/h1-need)[OutcomesA Revision Lands: The Open Data Model on Working TermsStandards adoption is usually described in terms of intent: we align with the Open Data Model, our partners can integrate faster. Those sentences are cheap. The useful question is narrower and more revealing: when a revision to an entity document is published on an ordinary weekday morning, what does your team actually do?](https://www.coremodels.io/connector/odm/h2-outcomes)[GovernanceTwo Verbs and a Dry Run: Governing a Standard You Do Not OwnOur ODM surface has exactly two verbs, and the distance between them is the entire governance argument.](https://www.coremodels.io/connector/odm/h3-governance)[EcosystemThe Composable Stack's Missing NounAssemble a modern commerce or content platform the MACH way - microservices-based, API-first, cloud-native, headless - and you get the promised benefits almost immediately. Best-of-breed everywhere. Vendors swappable in principle. No monolith to renegotiate every five years.](https://www.coremodels.io/connector/odm/h4-ecosystem)[AgentsTwo Ways to Answer a Question About the StandardSomeone drops a question into a channel: does the Open Data Model require an external identifier on the customer entity, or is it optional? An AI assistant watching the channel answers in four seconds, in complete sentences, with a confident field list.](https://www.coremodels.io/connector/odm/h5-agents)[QuickstartYour First MACH ODM Transform: Markdown In, JSON Schema OutThe MACH Alliance publishes its Open Data Model (ODM) as entity documentation: Markdown files with prose, a field table, embedded YAML schema definitions, and sample objects. That is a great format for humans and a frustrating one for machines - you cannot validate a payload against a Markdown page.](https://www.coremodels.io/connector/odm/t1-quickstart)[APIMACH ODM over HTTP: One Converter, Two Importers, and an Honest "No Export"Every schema format on the CoreModels transform surface declares its direction, and we hold ourselves to those declarations in public. The odm format - MACH Alliance Open Data Model entity documents - is decode-only: ODM entities are authored documentation, not a generated artifact, so there is no encode back to prose. Rather than paper over that, the HTTP surface is built around it. This article walks the complete set of routes that touch ODM, with real request and response bodies, the role each route requires, and exactly what happens when you try the direction that does not exist.](https://www.coremodels.io/connector/odm/t2-api)[MCPConverting MACH ODM Entities with an Agent: transform_schema over MCPPicture the request as it actually arrives: someone pastes a MACH Alliance Open Data Model entity document into a chat and asks their agent, "stand up a Postgres table for this." The document is Markdown - an H1, some prose, YAML blocks inside a schema section. Between that paste and a CREATE TABLE statement sits exactly one tool call.](https://www.coremodels.io/connector/odm/t3-mcp)[AutomationODM at Scale: Batch Conversion, Deterministic Pipelines, and Replayable PlansOne entity document is a demo. A standards repository is dozens of them - identity, product, inventory, pricing - revised by pull request, consumed by teams who need formal schemas, not Markdown. The moment MACH Open Data Model documents become an input to your build, three engineering questions appear: can the conversion run unattended, will the same input always produce the same output, and what happens when one file in the batch is broken?](https://www.coremodels.io/connector/odm/t4-automation)[Deep diveInside the MACH ODM Coder: What Maps, What Rides Along, What Gets ReportedA MACH Alliance Open Data Model entity document is five things wearing one Markdown file: an H1 that names the entity, an ## Entity purpose section of prose, an ## Object table with normative practice levels, a ## YAML Schema Definition section holding the actual schema, and a ## Sample Object. The CoreModels odm coder reads all five - and this article is the precise account of where each one lands, what travels as annotation rather than structure, which situations produce lossiness records, and why this format is the one place in our lineup where round-trip is deliberately not the goal.](https://www.coremodels.io/connector/odm/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Open Semantic Interchange | CoreModels" description: "Put two revenue numbers next to the same definition." canonical: "https://coremodels.io/connector/osi" last_updated: "2026-09-15" --- Early access # Connect Open Semantic Interchange Put two revenue numbers next to the same definition. [Connect Open Semantic Interchange](https://go.coremodels.io/app/new/osi)[Open Semantic Interchange site](https://www.snowflake.com/) Recipes No recipes yet for Open Semantic Interchange. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import an Open Semantic Interchange model and CoreModels records metrics, dimensions, and definitions as governed meaning. Finance and the warehouse can finally open the same artifact, diff it, and agree whether returns are netted. ## How CoreModels works with Open Semantic Interchange Open Semantic Interchange exists so semantic models can move between platforms without becoming folklore. That only helps if the interchange document is governed - versioned, imported, audited - rather than pasted into another tool’s proprietary layer. CoreModels decodes OSI into the same model that dbt semantic manifests and warehouse contracts already use. Metrics become reusable definitions. Dimensions become shared elements. Drift is a finding when a BI extract no longer matches the interchange file. The meeting that used to spend forty minutes on archaeology becomes a review of one governed document. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemTwo Numbers, One WordSomeone puts a slide on the screen: revenue for the quarter, from the finance dashboard. Someone else has the same metric open in a notebook, sourced from the warehouse, and the figure differs by a little under two percent. Both are right, in the sense that each number is exactly what its definition says it is. One nets out returns; the other does not.](https://www.coremodels.io/connector/osi/h1-need)[OutcomesA Tuesday With a Governed Semantic ModelThe clearest way to describe an after-state is to walk through an ordinary day in it. Nothing dramatic happens on this Tuesday; that is the point. Here is the day, with the before-state noted each time, for a team whose Apache Ossie semantic model is a projection of a governed graph rather than a file inside one tool.](https://www.coremodels.io/connector/osi/h2-outcomes)[GovernanceA Definition Is a Privileged ChangeThere is a sentence in our own API documentation that decides how the whole surface behaves: "success: true does not mean 'nothing changed.' It means 'it ran.' Always read lossiness."](https://www.coremodels.io/connector/osi/h3-governance)[EcosystemThe Missing ArtifactTake the modern data stack layer by layer and ask one question of each: can I have that as a file?](https://www.coremodels.io/connector/osi/h4-ecosystem)[AgentsWhat an Agent Decides Before It AnswersAsk an AI agent connected to a bare warehouse what revenue was last week, and watch the decisions it makes before writing a line of SQL.](https://www.coremodels.io/connector/osi/h5-agents)[QuickstartTen Minutes to Your First Apache Ossie TransformA semantic model lands in your repository: a YAML file with datasets, fields, a primary key, and a couple of time dimensions. It is the analytics team's description of what the warehouse means. Now somebody needs it as a table definition, or as JSON Schema for a validator, or as the JSON serialization dbt ingests. This walkthrough takes you from that file to a converted schema with one HTTP call - and, just as importantly, to a machine-readable ledger of everything the conversion did and did not preserve.](https://www.coremodels.io/connector/osi/t1-quickstart)[APIThe Ossie HTTP Surface: Import, Export, Map, ReplayFour verbs cover everything you will do with an Apache Ossie semantic model through the CoreModels API, and picking the right one is mostly a question of where the schema lives. Is it a file you have? Import it, or map it statelessly. Is it a governed model in a CoreModels project? Export it. Do you need the same conversion again next month, byte for byte? Replay a stored plan.](https://www.coremodels.io/connector/osi/t2-api)[MCP"Convert Our Semantic Model for dbt" - Ossie Through the transform_schema ToolHere is the request, as an analyst actually phrases it: "Take the billing semantic model in our repo, give me the JSON form our dbt project ingests, and tell me what didn't survive the conversion."](https://www.coremodels.io/connector/osi/t3-mcp)[AutomationOssie Conversions That Belong in CI: Plans as Artifacts, Ledgers as GatesRun an Ossie conversion twice and diff the two outputs. If the bytes differ, the conversion cannot live in a pipeline - you would be re-reviewing generated files every build. CoreModels (by ARAMAI) gives you the other answer, and it comes from three deliberate design choices: the encoder is hand-written with fixed key order, the mapping plan is returned as an artifact you can store, and replaying a stored plan runs the same validation gate as the call that produced it.](https://www.coremodels.io/connector/osi/t4-automation)[Deep diveEvery Key, Every Record: How the Ossie Coder Maps to the IRAn Apache Ossie semantic model and a typed intermediate representation disagree about the world in one fundamental way: an Ossie field has no type. It is a name, an optional expression, an optional description, and optional dimension metadata. The IR that CoreModels (by ARAMAI) moves schemas through is typed, and so is every neighboring format - SQL, Avro, JSON Schema, LinkML.](https://www.coremodels.io/connector/osi/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect OWL ontologies | CoreModels" description: "Keep the ontology and the application schema from becoming two portraits of Person." canonical: "https://coremodels.io/connector/owl" last_updated: "2026-09-15" --- Format # Connect OWL ontologies Keep the ontology and the application schema from becoming two portraits of Person. [Import a OWL file](https://go.coremodels.io/app/new/owl)[OWL site](https://www.w3.org/OWL/) Recipes No recipes yet for OWL. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import an OWL ontology and CoreModels records classes, datatype properties, and relationships as a governed model you can map to JSON Schema, SQL, and Avro. The operational schema stops being a one-time export from Protégé. ## How CoreModels works with OWL OWL is the right language for description logic. It is the wrong runtime for APIs and warehouses. Teams export once, then the running schema evolves in git while the ontology evolves in Protégé. CoreModels imports OWL as types and properties, then lets you generate and audit the schemas applications actually compile. Equivalences and subclass axioms inform mapping; the lossiness ledger shows what OWL expressivity the target format cannot hold. The goal is not to make engineers open Turtle. It is to make the next field added to the API a governed change against the same Person the ontology already named. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemTwo Truths About "Person": Why Ontologies and Application Schemas Drift ApartSomewhere in your organization there are two documents that both claim to define a person. One is an OWL ontology, lovingly curated in Protégé by someone who understands description logic: Person is a class, name is a datatype property, there are equivalences to schema.org and careful subclass axioms. The other is the schema your applications actually run on - a JSON Schema, a set of CREATE TABLE statements, an Avro record - written by engineers who have never opened a Turtle file and never will.](https://www.coremodels.io/connector/owl/h1-need)[OutcomesThe Day the Ontology Became a Build ArtifactTuesday, 9:40 a.m. A message arrives from the knowledge-graph team: "We're loading the reference data into GraphDB this sprint. Can you send us an ontology for the content model?" Six months ago that message would have started a two-week side project. Today the modeler it lands on opens the CoreModels project that already governs the content model, makes one export call with format: "owl", and posts the resulting Turtle file back before her coffee is cold. It loads into GraphDB without edits. It loads into Protégé without edits. The reasoner accepts the cardinality axioms as axioms.](https://www.coremodels.io/connector/owl/h2-outcomes)[GovernanceThe Confession at the Top of the File: Governance Through the OWL Round TripOpen an ontology exported from CoreModels and, before any prefix declaration, you may find something unusual: a block of comment lines beginning # lossiness:. Each one names a kind of change, the exact path in the model where it happened, and a plain-English explanation of what the export could not carry. Comments are valid Turtle, so the file still loads cleanly into GraphDB or Protégé - but anyone who opens it reads the confession first.](https://www.coremodels.io/connector/owl/h3-governance)[EcosystemA Field Guide to the Stack Beneath OWL - and Why We Keep Our Turtle VanillaOWL is not one standard; it is the top floor of a building. At the foundation sits RDF, the data model in which everything is a triple - subject, predicate, object - and every named thing is an IRI. Above it, RDFS adds the basic schema vocabulary: classes, properties, domains, ranges, subclass relations. OWL adds the expressive machinery on top - equivalences, restrictions, unions, the constructs a reasoner can actually reason over. Beside the tower stands SKOS, the W3C vocabulary for thesauri and controlled vocabularies: concepts, schemes, broader/narrower hierarchy, preferred labels. And Turtle is none of these - it is simply the friendliest syntax for writing any of them down, the serialization humans actually read.](https://www.coremodels.io/connector/owl/h4-ecosystem)[AgentsAxioms Beat Sample Data: What OWL Support Means for AI AgentsAsk an AI agent to integrate with a system it has never seen, and watch what it does: it requests a few sample records and starts inferring. Three JSON documents in, it has decided that email is always present (it appeared in all three), that tags is a scalar (each sample happened to have one), and that status takes two values (it saw two). Every one of those conclusions is a guess dressed as knowledge, and every one can be wrong in ways that surface weeks later as a production incident.](https://www.coremodels.io/connector/owl/h5-agents)[QuickstartTurtle In, JSON Schema Out: Your First OWL TransformThere is a .ttl file somewhere in your repository. Someone modeled the domain properly once - classes, subclass axioms, cardinality restrictions, a SKOS scheme for the controlled list - and then everyone else carried on hand-writing JSON Schema and DDL, because nothing bridged the two.](https://www.coremodels.io/connector/owl/t1-quickstart)[APIOWL Over HTTP: Export, Import, Map, ReplayTwo questions decide whether a format is really supported: can the system read it, and can the system write it? For the owl format key in CoreModels the answer is yes to both, and this article is the proof - four routes, real request bodies, real responses, and the direction rules stated without hedging.](https://www.coremodels.io/connector/owl/t2-api)[MCPOntology Alignment You Can Delegate: transform_schema and OWL Over MCPA partner sends you their vocabulary as a Turtle file. You need your catalog expressed in their terms so the two sides can exchange data, and you need a record of which of your concepts had no counterpart on their side. That used to be an afternoon in an ontology editor plus a spreadsheet nobody trusts.](https://www.coremodels.io/connector/owl/t3-mcp)[AutomationInfer Once, Gate Always, Replay Forever: OWL in a Build PipelineCommit an exported ontology, re-run the export tomorrow, and look at the diff. If it shows reordered prefixes and reshuffled blocks, the export is not a build artifact - it is a rumor, and no reviewer will read it twice. If it shows exactly the statements your model changed, you have something CI can gate on.](https://www.coremodels.io/connector/owl/t4-automation)[Deep diveWhat the OWL Coder Knows: The IR Map, the Extras, the LedgerAsk a schema converter what it does with owl:Restriction and you learn most of what you need to know about it. Many treat OWL as a serialization problem - emit classes and properties, drop the axioms - so "required" and "single-valued" evaporate at the border. CoreModels treats it as a semantics problem: required and cardinality ride as owl:Restriction subclass axioms, OWL's own carrier, in both directions. That decision propagates through everything below.](https://www.coremodels.io/connector/owl/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Protocol Buffers | CoreModels" description: "Carry reserved field numbers with the meaning, not only with the .proto file." canonical: "https://coremodels.io/connector/protobuf" last_updated: "2026-09-15" --- Format # Connect Protocol Buffers Carry reserved field numbers with the meaning, not only with the .proto file. [Import a Protocol Buffers file](https://go.coremodels.io/app/new/protobuf)[Protocol Buffers site](https://protobuf.dev/) Recipes No recipes yet for Protocol Buffers. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import Protobuf descriptors and CoreModels records messages, fields, numbers, types, and reserved ranges as governed meaning. Retiring a field cannot vanish from history the moment someone copies the schema into another format. ## How CoreModels works with Protocol Buffers Field numbers are the contract. Names are commentary. Teams still treat .proto as documentation and regenerate other schemas by hand, dropping reserved ranges along the way. CoreModels decodes Protobuf into the neutral model, including numbers and reservations. The proto-to-Avro conversion recipe exists because that is a common place for numbers to become names and for history to die. Generate-back and audits keep the next “free” number from being a landmine. Use this when multiple languages and pipelines compile against the same messages - and compatibility incidents show up as quietly wrong values, not as compile errors. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Field Number Nobody Wrote DownA team retires a field. It has been dead for a year, nothing reads it, and the pull request that removes it is three lines long and gets approved in under a minute. Months later somebody adds a new field and takes the next number that looks free - the same one. Both changes were correct on their own. Together they mean an older client and a newer one now disagree about what a stretch of bytes says, and the disagreement surfaces as a value that is quietly wrong somewhere nobody is watching.](https://www.coremodels.io/connector/protobuf/h1-need)[OutcomesWhat Your Service Team Stops Being AskedEvery team that owns a .proto file also owns an unpaid second job: being the interpreter for it. The requests arrive individually, each one reasonable, each one costing an afternoon. Can we get the order model as tables? The partner needs this as JSON Schema by Thursday. Which of these fields are actually required? Can you add a discount field without breaking the mobile clients?](https://www.coremodels.io/connector/protobuf/h2-outcomes)[GovernancePut the Generated .proto in a Pull RequestThat is the test. Not a feature list, not a pipeline diagram - a reviewer, a diff, and a wire contract other people's clients depend on. If a governance layer cannot survive that moment, everything upstream of it is decoration.](https://www.coremodels.io/connector/protobuf/h3-governance)[EcosystemGood Neighbors: proto3 Among the Formats It Has to Live WithProtocol Buffers was designed for a conversation between two running programs. Everything distinctive about it follows from that: the compactness, the field numbers, the fanatical attention to what happens when one side upgrades before the other. It is a contract about bytes in flight, and it is very good at being one.](https://www.coremodels.io/connector/protobuf/h4-ecosystem)[AgentsFluent, Confident, and Wrong: Grounding Agents in Real proto3Ask a capable model to write the .proto for your order service and you will get a file that compiles. Idiomatic names, an enum with a zero-valued UNSPECIFIED member because that is the convention, a google.protobuf.Timestamp for the placed-at field, numbers counting up from one. It will look like something a good engineer wrote on a good day.](https://www.coremodels.io/connector/protobuf/h5-agents)[QuickstartTen Minutes With proto3: Your First CoreModels TransformYou have a .proto file. It is the truth for a service, and now somebody outside that service needs the same shape - as JSON Schema for a validation step, as a data contract for a review, as a table for analytics. The usual answer is to retype it. This article replaces the retyping with one HTTP call, and then spends most of its length on the part that matters more: reading what the conversion cost you.](https://www.coremodels.io/connector/protobuf/t1-quickstart)[APIThe Transform API for proto3: Four Routes, Both DirectionsMost schema converters are one-way. You can get out of the format or into it, rarely both, and the documentation usually leaves you to discover which by trying. So let us answer the direction question for Protocol Buffers first and in one sentence: proto3 decodes and encodes. The key protobuf (alias proto) appears in both the decode list and the encode list, so it is valid as a source and as a target on every route below.](https://www.coremodels.io/connector/protobuf/t2-api)[MCPHanding proto3 to an Agent: transform_schema over MCP"Take our telemetry .proto and give me the Postgres table for it - and tell me what we lose."](https://www.coremodels.io/connector/protobuf/t3-mcp)[AutomationDeterministic proto3 Pipelines: The Plan Is the ArtifactA conversion you run once is a favor. A conversion you run on every commit is infrastructure, and infrastructure needs two properties that one-off tooling never has to prove: the second run must produce the same bytes as the first, and when the input changes in a way the conversion cannot honor, the pipeline must stop rather than quietly produce something different.](https://www.coremodels.io/connector/protobuf/t4-automation)[Deep diveInside the proto3 Coder: The IR Mapping, the Extras, and Every Lossiness RecordProto3 has fifteen scalar types. A neutral intermediate representation that also hosts JSON Schema, SQL, Avro, LinkML, OWL, and half a dozen other formats cannot afford fifteen distinct numeric primitives, and any tool that claims otherwise is hiding something. The arithmetic settles the question up front: some proto3 facts map structurally, some ride alongside as preserved detail, and some are declared as loss. This is the complete account, in that order.](https://www.coremodels.io/connector/protobuf/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect REDCap | CoreModels" description: "Diff the codebook so a study change is a review, not a memory." canonical: "https://coremodels.io/connector/redcap" last_updated: "2026-09-15" --- Early access # Connect REDCap Diff the codebook so a study change is a review, not a memory. [Connect REDCap](https://go.coremodels.io/app/new/redcap/generic)[REDCap site](https://projectredcap.org/) Recipes ## Recipes Recipes for REDCap ### Blank REDCap project The whole schema estate is one CSV - govern it in one upload. [Related use →](https://www.coremodels.io/connector/redcap/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/redcap/generic) ### CI Drift Gate for REDCap The dictionary changed on a Tuesday - catch it before the export breaks. [Related use →](https://www.coremodels.io/connector/redcap/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/redcap/ci-drift-gate) ### Data-dictionary round trip Dictionary in, governed model, upload-ready dictionary back out. [Related use →](https://www.coremodels.io/connector/redcap/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/redcap/dictionary-round-trip) ### First governed REDCap import Zero to first audit with one CSV. [Related use →](https://www.coremodels.io/connector/redcap/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/redcap/first-governed-import) Connector summary ## What the recipes deliver Import a REDCap data dictionary and CoreModels records instruments, fields, validations, and choices as a governed codebook. Round-trip generation and CI gates answer whether systolic blood pressure was always integer-validated - from the model, not from a meeting. ## How CoreModels works with REDCap REDCap dictionaries are the schema of the study: field types, min/max, branching, choice lists. They are edited by coordinators, exported as CSV, and rarely treated like production schemas. CoreModels imports that dictionary as types, elements, and taxonomies. The dictionary round-trip recipe regenerates a dictionary from governed meaning so exports do not fork. The CI drift gate fails a change that loosens validation after the pilot without a reviewed definition change. This is how clinical research gets the same drift discipline data platforms already expect. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemNobody Diffs the CodebookSomewhere in the second year of a study, a monitoring meeting stalls on a question that should be trivial: was the systolic blood pressure field always integer-validated, or did that change after the pilot?](https://www.coremodels.io/connector/redcap/h1-need)[OutcomesSix Questions Your REDCap Project Can Suddenly AnswerAsk a team what changed about their REDCap work after putting a project under governance, and the honest answer is: nothing. They still design instruments in REDCap. They still enroll participants, still branch, still export. Nobody handed over an API token, and nothing outside the team ever writes to the instance.Recipe: First governed REDCap import](https://www.coremodels.io/connector/redcap/h2-outcomes)[GovernanceThe Powers We Deliberately Did Not TakeA tool that governs a research study's schema could be given a great deal of authority. It could hold an API token and read the project directly. It could reconcile your model to the latest upload automatically. It could push corrected instruments back into REDCap. Each of those would demo well.](https://www.coremodels.io/connector/redcap/h3-governance)[EcosystemThe Dictionary Travels Further Than the DataA REDCap data dictionary gets around. It is emailed to a collaborating site so they can stand up the same instruments. It is attached to a protocol so a reviewer can see what is being collected. It is handed to a statistician who needs the codebook, to an engineer who needs to build a load, to the next study that wants to reuse a validated instrument. The participant data stays behind an access committee. The dictionary circulates freely, because it carries meaning rather than records.Recipe: Data-dictionary round trip](https://www.coremodels.io/connector/redcap/h4-ecosystem)[AgentsThe Agent Cannot Tell Which Column Is the KeyGive a capable AI assistant two REDCap exports and ask it to join them. Watch what it has to do.](https://www.coremodels.io/connector/redcap/h5-agents)[QuickstartREDCap to CoreModels: Zero to First Audit with One CSVMost schema estates take real work to extract: information-schema queries, catalog exports, manifest builds. A REDCap project is the pleasant exception - the entire schema estate is one stable file, the data dictionary CSV, and you almost certainly already know how to download it. That makes the distance from "nothing governed" to "first drift audit" unusually short. This tutorial walks the whole distance: export the dictionary, import it into a governed CoreModels project, run your first audit, and read what comes back. No REDCap credentials are ever shared with CoreModels at any point.Recipe: Blank REDCap project · First governed REDCap import](https://www.coremodels.io/connector/redcap/t1-quickstart)[APIEvery REDCap Route in CoreModels: the Full HTTP ReferenceThe CoreModels REDCap connector declares all three capabilities - Import, Audit, Generate - which means every integration verb on our HTTP surface is live for it. This article is the complete route-by-route reference: what each endpoint takes, what it returns, which role it requires, and which of the two HTTP surfaces it lives on. If you're writing a script, a service, or an internal tool against the REDCap integration, this is the page to keep open.](https://www.coremodels.io/connector/redcap/t2-api)[MCPGive Your Agent the Dictionary: REDCap Governance over MCPWhen the caller is an AI agent rather than a shell script, the interesting question stops being "what's the route?" and becomes "what is the agent allowed to know, and what is it allowed to do?" CoreModels answers that with an MCP server whose vendor-integration tools mirror our HTTP surface exactly - same audit engine, same additive import, same read-only posture - but packaged as typed tools an agent can discover, reason about, and chain. This article walks the four tools that matter for REDCap, with the real arguments, and shows the pattern we recommend for agents that govern clinical research schemas: discover, audit, and only then (with a human's admin endpoint) import.](https://www.coremodels.io/connector/redcap/t3-mcp)[AutomationThe Dictionary Changed on a Tuesday: CI Drift Gates for REDCapREDCap's greatest operational strength is also its governance problem: a data manager with the right permissions can change a production instrument in minutes. A validation type quietly switches from integer to plain text, a choice list gains a code, a required flag disappears - and every downstream extract, harmonization script, and statistical pipeline inherits the change without a review. The fix isn't to slow REDCap down. It's to make the data dictionary a versioned, gated artifact like any other piece of production configuration. This article builds that gate with CoreModels: a CI audit that fails on drift, a status badge, a rolling history, one-call re-audits, and the scheduled heartbeat that catches drift nobody pushed.Recipe: CI Drift Gate for REDCap](https://www.coremodels.io/connector/redcap/t4-automation)[Deep diveInside the REDCap Connector: How a Data Dictionary Becomes a Governed GraphTo trust a governance tool you should be able to predict what it does with your data - row by row, column by column. This deep dive opens the hood on the CoreModels REDCap connector: how the data dictionary CSV is parsed, how each REDCap concept lands in the governed graph, which facts ride vendor metadata rather than governed meaning, what triggers each audit rule, and precisely where the mapping is lossy.Recipe: Data-dictionary round trip](https://www.coremodels.io/connector/redcap/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Salesforce | CoreModels" description: "Govern the org whose schema can change in forty seconds from Setup." canonical: "https://coremodels.io/connector/salesforce" last_updated: "2026-09-15" --- Early access # Connect Salesforce Govern the org whose schema can change in forty seconds from Setup. [Connect Salesforce](https://go.coremodels.io/app/new/salesforce/generic)[Salesforce site](https://www.salesforce.com/) Recipes ## Recipes Recipes for Salesforce ### Blank Salesforce project Govern your Salesforce org from one describe export - CoreModels never touches the org. [Related use →](https://www.coremodels.io/connector/salesforce/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/salesforce/generic) ### CI Drift Gate for Salesforce Fail the build before the org forgets what it means. [Related use →](https://www.coremodels.io/connector/salesforce/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/salesforce/ci-drift-gate) ### First governed Salesforce import Zero to first audit: your org as a governed model from one describe export. [Related use →](https://www.coremodels.io/connector/salesforce/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/salesforce/first-governed-import) ### Object scaffolds back to Salesforce Governed model in, Metadata-API CustomObject XML out - deployed only by you. [Related use →](https://www.coremodels.io/connector/salesforce/t5-deep-dive)[Start this recipe](https://go.coremodels.io/app/new/salesforce/generate-back) ### Salesforce object-model governance It takes forty seconds to change what a field means. Make the meaning governed. [Related use →](https://www.coremodels.io/connector/salesforce/h1-need)[Start this recipe](https://go.coremodels.io/app/new/salesforce/object-model-governance) Connector summary ## What the recipes deliver Import Salesforce object describe metadata and CoreModels records objects, fields, picklists, and relationships as a governed model. A picklist edit in Object Manager becomes drift against meaning downstream jobs already depend on. ## How CoreModels works with Salesforce A Salesforce org is a production database whose schema is edited through a settings page. Describe APIs already expose the truth of that schema. Teams still copy fields into warehouses and CDPs by hand, then discover picklist changes when a load fails or, worse, when it does not. CoreModels imports the object model, including picklists as taxonomies. Object-model governance recipes focus on the objects that actually leave the org. Generate-back and the CI gate give integrations a reviewed baseline the next Setup click cannot silently invalidate. The platform stays easy for admins. Downstream meaning stops being an accident of the last save. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemIt Takes About Forty Seconds to Change What a Salesforce Field MeansSetup. Object Manager. Pick a field. Edit the picklist. Save.Recipe: Salesforce object-model governance](https://www.coremodels.io/connector/salesforce/h1-need)[OutcomesA Week With a Governed Salesforce Org"Has anything in the org drifted from what we agreed?"Recipe: First governed Salesforce import](https://www.coremodels.io/connector/salesforce/h2-outcomes)[GovernanceGoverning a Salesforce Org You Never Let Us TouchA governance tool pointed at your CRM is asking for a lot of trust. Your Salesforce org holds the pipeline, the customer list, and the revenue numbers; any tool that wants to "govern" it should have to say, precisely, what it will and will not do. So before we describe what the CoreModels Salesforce integration does, here is what it refuses to do - because the trust story is the product.Recipe: Object scaffolds back to Salesforce](https://www.coremodels.io/connector/salesforce/h3-governance)[EcosystemAccount Is Not a Salesforce Object - It's a Business Concept With a Salesforce CopyTrace one entity through a typical stack. Account starts life as an sObject in a Salesforce org. A sync pipeline copies it into the warehouse, where it becomes a table. A transformation layer reshapes it into curated models. An event stream carries account changes to other services under a registered schema. Four systems, four technical dialects - and one business meaning that no single system owns.Recipe: Salesforce object-model governance](https://www.coremodels.io/connector/salesforce/h4-ecosystem)[AgentsWhen an AI Agent Meets Your Salesforce Org, It Guesses - Unless You Give It the ModelAsk an AI agent to write an integration against your Salesforce org - a validation script, a sync mapping, a report definition - and watch what it does with Status__c. It will guess. It has seen ten thousand orgs' worth of training data, so the guess will be fluent: plausible picklist values, a plausible type, a plausible relationship to Account. Fluent, plausible, and wrong, because your org is not the average org. It is fifteen years of customization, custom objects, repurposed standard fields, and picklists whose real values live in a settings page the agent has never seen.](https://www.coremodels.io/connector/salesforce/h5-agents)[QuickstartGoverning a Salesforce Org in an Afternoon: From describe.json to Your First Drift AuditSomewhere in your org, last quarter, somebody edited a picklist. Nobody remembers who, the field history doesn't say why, and the report that broke three weeks later never mentioned it at all. Salesforce makes schema change wonderfully easy - and makes remembering what the schema is supposed to mean entirely your problem.Recipe: Blank Salesforce project · First governed Salesforce import](https://www.coremodels.io/connector/salesforce/t1-quickstart)[APISeven Verbs and Two Surfaces: The Complete Salesforce Integration APIBefore writing a single call, it pays to see the whole map. The Salesforce integration in CoreModels (vendor key salesforce) is small enough to hold in your head: the seven core per-vendor verbs on the interactive HTTP surface, two on the machine-to-machine surface, one artifact, and two roles. The connector declares all three capabilities - Import, Audit, Generate - so every verb below is live for Salesforce; nothing in this reference is aspirational.](https://www.coremodels.io/connector/salesforce/t2-api)[MCP"Did the Org Drift?" - Running Salesforce Governance Through an AI AgentWatch an agent handle a governance request end to end. A data engineer types: "Here's this week's describe export - check whether the Salesforce org still matches the governed model, and summarize anything that changed." The agent calls one tool, reads back structured findings plus a ready-made markdown report, and answers with specifics: which object, which field, which severity. No dashboard visit, no memorized route, no guessing.](https://www.coremodels.io/connector/salesforce/t3-mcp)[AutomationThe Build Goes Red Before the Org Goes Wrong: A Salesforce Drift Gate in CISchema governance that lives in a wiki dies in a wiki. The only governance that survives contact with a delivery team is the kind wired into the pipeline - a check that runs on every change, fails loudly when meaning breaks, and costs nothing to keep passing. This article wires that check up for Salesforce with CoreModels: a CI job that audits a fresh describe export against the governed model, a one-line pass/fail contract, a status badge, a rolling evidence trail, and the two mechanisms that cover what CI cannot see.Recipe: CI Drift Gate for Salesforce](https://www.coremodels.io/connector/salesforce/t4-automation)[Deep diveAnatomy of a Governed Org: How Salesforce Metadata Maps into the CoreModels GraphA drift audit is only as trustworthy as the mapping underneath it. If an import flattens your org into undifferentiated strings, the audit can only ever tell you undifferentiated things. So this article opens the hood on the CoreModels Salesforce connector: what each describe property becomes in the governed graph, which platform semantics survive the crossing, which are approximated - and how every approximation is declared rather than hidden.Recipe: Object scaffolds back to Salesforce](https://www.coremodels.io/connector/salesforce/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect ShEx | CoreModels" description: "Keep the four assertions in every shape constraint from dying in a hand copy." canonical: "https://coremodels.io/connector/shex" last_updated: "2026-09-15" --- FormatGA # Connect ShEx Keep the four assertions in every shape constraint from dying in a hand copy. [Import a ShEx file](https://go.coremodels.io/app/new/shex)[ShEx site](https://shex.io/) Recipes No recipes yet for ShEx. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import Shape Expressions and CoreModels records predicates, value constraints, cardinalities, and nested shapes as governed structure. Generating JSON Schema or SQL from ShEx no longer throws away IRIs, exact cardinalities, or datatype vocabularies by accident. ## How CoreModels works with ShEx ShEx is denser than it looks. Teams translating shapes into application schemas flatten IRIs into strings and `{1,1}` into “required” with no record of the loss. CoreModels decodes ShEx into the neutral model and encodes out with a ledger. Re-import the authoritative shapes and audit the generated schemas so a cardinality change in ShExC is a CI finding, not a silent API change. Use this when RDF shapes are the contract and JSON/SQL are the runtime - and you need both to stay honest about what they cannot express. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemFour Facts in a Line: What Hand-Copied Shapes Throw AwayRead one triple constraint out of a ShExC file: a predicate, a value constraint, a cardinality marker, a semicolon. It looks like a field declaration. It is denser than that.](https://www.coremodels.io/connector/shex/h1-need)[OutcomesTuesday, 09:40: A Week in Which Shapes Are Just Another ExportThe clearest way to describe an after-state is to timestamp it. Here is a week in a team that has stopped maintaining a second copy of its model - where a partner's shapes are an input, the warehouse DDL is an output, and the return submission is a diff. Nothing here is heroic. That is the point.](https://www.coremodels.io/connector/shex/h2-outcomes)[Governance"Success" Means It Ran: The Trust Contract Around a ShEx ConversionThere is a sentence in our own transform documentation that we treat as a design constraint rather than a caveat: a successful response does not mean nothing changed - it means it ran.](https://www.coremodels.io/connector/shex/h3-governance)[EcosystemTwo Questions That Sound Alike: Where ShEx Sits, and Why We Take No Side"What does this term mean?" and "what must a conforming record contain?" sound like one question. They are two, answered by different artifacts, and confusing them is why so many schema discussions go in circles.](https://www.coremodels.io/connector/shex/h4-ecosystem)[AgentsAsk Where the Answer Came From: ShEx as an Agent's Source of TruthAsk an AI agent what values the status field can hold, and it will answer. The interesting question is not whether the answer is right. It is where the answer came from.](https://www.coremodels.io/connector/shex/h5-agents)[QuickstartShEx in Ten Lines: Your First CoreModels TransformThe shortest useful thing you can do with CoreModels and ShEx takes one HTTP call, writes nothing to your project, and hands back three things: the converted schema, a replayable plan, and an honest ledger of everything the conversion could not carry across. This walkthrough runs that call twice - once into JSON Schema, once into Postgres DDL - and shows you how to read all three parts of the answer.](https://www.coremodels.io/connector/shex/t1-quickstart)[APIThe ShEx HTTP Surface: Import, Export, Map, and ReplayFive HTTP endpoints carry ShEx through CoreModels, and they are the same five that carry every other schema format we support - nothing about ShEx is a special case on the wire. What changes is one string: the format key shex. This article is the contract reference for that surface: exact routes, request and response bodies, roles, options, and the honest statement of what each direction can and cannot do.](https://www.coremodels.io/connector/shex/t2-api)[MCPAgent-Driven ShEx Conversion with the transform_schema MCP Tool"The ontology team published ShEx shapes for the product catalog. Give me the JSON Schema our validation service needs, and tell me exactly what didn't survive the trip."](https://www.coremodels.io/connector/shex/t3-mcp)[AutomationShEx in the Pipeline: Deterministic Transforms, Replayable Plans, Batch ConversionA schema conversion you cannot reproduce is a liability with a timestamp on it. If your ShEx shapes are converted to JSON Schema by hand, or by a script whose behavior depends on who runs it and when, then the day the outputs disagree you have no way to say which conversion was right. We built the CoreModels transform surface so that conversion can live in a pipeline like any other build step: deterministic outputs, a reviewable plan artifact you can commit next to your shapes, and a change report you can gate a build on. This article shows the working patterns for ShEx (format key shex).](https://www.coremodels.io/connector/shex/t4-automation)[Deep diveInside the ShEx Coder: The IR Map, the Extras Ledger, and What Round-TripsMost schema formats name things locally: a SQL column is full_name, an Avro field is full_name, and any connection to the wider world has to be bolted on with annotations. ShEx arrives different. Its predicates and shape names are IRIs - schema:name is https://schema.org/name - which means a ShEx document carries its cross-standard identity in its bones. Our ShEx coder in CoreModels, by ARAMAI, is built around that fact, and this article is the full technical account of it: exactly what maps into our intermediate representation (IR), what rides in the preserved-extras ledger, every lossiness record the coder can emit, and precisely what survives a round trip.](https://www.coremodels.io/connector/shex/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Snowflake | CoreModels" description: "Your Snowflake schema is not a contract. Generate one from the governed model." canonical: "https://coremodels.io/connector/snowflake" last_updated: "2026-09-15" --- Early access # Connect Snowflake Your Snowflake schema is not a contract. Generate one from the governed model. [Connect Snowflake](https://go.coremodels.io/app/new/snowflake/generic)[Snowflake site](https://www.snowflake.com/) Recipes ## Recipes Recipes for Snowflake ### Blank Snowflake project Govern your Snowflake estate from three Snowsight queries - no credentials, ever. [Related use →](https://www.coremodels.io/connector/snowflake/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/snowflake/generic) ### CI Drift Gate for Snowflake Fail the build when the warehouse drifts from the governed model. [Related use →](https://www.coremodels.io/connector/snowflake/t4-automation)[Start this recipe](https://go.coremodels.io/app/new/snowflake/ci-drift-gate) ### First governed Snowflake import From Snowsight to first audit with one query result. [Related use →](https://www.coremodels.io/connector/snowflake/t1-quickstart)[Start this recipe](https://go.coremodels.io/app/new/snowflake/first-governed-import) ### Warehouse contracts for Snowflake Your Snowflake schema is not a contract. Generate one from the governed model. [Related use →](https://www.coremodels.io/connector/snowflake/h1-need)[Start this recipe](https://go.coremodels.io/app/new/snowflake/warehouse-contracts) Connector summary ## What the recipes deliver Import Snowflake metadata and CoreModels records databases, schemas, tables, columns, and keys as a governed estate. Warehouse-contract recipes then generate DDL - types, nullability, comments, allowed values - from the meaning audits already enforce. ## How CoreModels works with Snowflake Snowflake gives you a precise picture of what exists. Contracts, enumerations, and “this column may not become varchar” live in people’s heads and in dbt YAML that may not even cover sources. CoreModels imports the estate, including keys where they exist, and treats later snapshots as drift candidates. The warehouse-contracts recipe emits `CREATE OR REPLACE` DDL with native types, NOT NULL from checks, informational keys, and comments that carry governed allowed values. Pair with dbt source-truth-gate when the warehouse is the upstream the transformation project cannot see. The CI drift gate is how a retype becomes a failed pull request instead of an eleven-day mystery. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemYour Snowflake Schema Is Not a ContractPicture a failure every data team has met. The revenue dashboard didn't crash. That would have been kinder. Instead it kept rendering, quietly wrong, for eleven days - because a column that had always carried a two-decimal number was rebuilt upstream as text, and everything downstream coerced, rounded, or dropped what it couldn't parse. No alert fired. No reviewer saw it coming. The warehouse did exactly what it was told, because a warehouse's job is to store structure, not to defend meaning.Recipe: Warehouse contracts for Snowflake](https://www.coremodels.io/connector/snowflake/h1-need)[OutcomesA Week in the Life of a Governed Snowflake EstateForget the sales pitch for a moment. Here is what an ordinary week looks like for a data engineer whose Snowflake estate is governed with CoreModels - nothing heroic, just the same work with the guesswork removed.Recipe: First governed Snowflake import](https://www.coremodels.io/connector/snowflake/h2-outcomes)[GovernanceRead-Only by Design: The Trust Model Behind CoreModels for SnowflakeGovernance tools lose trust in predictable ways: they demand credentials to your most valuable system, they "helpfully" rewrite things nobody asked them to touch, they paper over what they couldn't represent, and one day they act on your infrastructure without a human in the loop. We designed the CoreModels Snowflake integration against that failure list, promise by promise. This article is the trust story, stated plainly enough to be falsifiable.](https://www.coremodels.io/connector/snowflake/h3-governance)[EcosystemOne Table, Five Tools: Where Snowflake Sits in a Governed EstatePick one table in your warehouse - say ANALYTICS.PUBLIC.ORDERS - and list everything that has an opinion about it. An ingestion tool like Airbyte landed its raw ancestor. A dbt model transformed and materialized it, and dbt's manifest describes it in dbt's vocabulary. Airflow schedules the job that refreshes it. A Kafka topic with an Avro schema in a Confluent registry mirrors half its fields to another team. Snowflake's own INFORMATION_SCHEMA describes its physical shape. Five tools, five metadata dialects, five partial and slowly diverging descriptions of one thing.](https://www.coremodels.io/connector/snowflake/h4-ecosystem)[AgentsStop Letting Your AI Agent Guess What Your Snowflake Columns MeanAsk a capable AI agent to "join orders to customers" in a warehouse it has never seen, and watch what it actually does: it reads column names and guesses. CUSTOMER_ID probably matches ID on the customers table. STATUS probably takes values like 'active'. That JSON blob in PAYLOAD probably has a user_id inside. The SQL it writes will be syntactically flawless and semantically hopeful - and hopeful SQL in an analytics pipeline is how confident wrong answers get made at scale.](https://www.coremodels.io/connector/snowflake/h5-agents)[QuickstartFrom Snowsight to First Audit: Governing a Snowflake Schema with CoreModelsYou have a Snowflake schema and about thirty minutes. By the end of this tutorial you will have a governed model of that schema in CoreModels - tables as Types, columns as Elements with their native types preserved, declared keys as checks and references, object dependencies as lineage - and you will have run your first drift audit against it and read the result.Recipe: Blank Snowflake project · First governed Snowflake import](https://www.coremodels.io/connector/snowflake/t1-quickstart)[APIEvery Endpoint: The CoreModels HTTP Surface for SnowflakeThis is the reference walk through everything you can do with the Snowflake integration over plain HTTP - every route, its role requirement, its request body, and what comes back. The Snowflake connector declares all three capabilities - Import, Audit, and Generate - so every verb below is live for it.](https://www.coremodels.io/connector/snowflake/t2-api)[MCPAn Agent Runs Your Snowflake Governance: The MCP Workflow"Is our Snowflake estate still in sync with the governed model? If not, show me exactly what drifted, and draft the DDL to fix it." That is a sentence you can now say to an AI agent, and every step it takes to answer - discovery, audit, report, generation - runs through the CoreModels MCP server as first-class tool calls. This article walks the whole flow: how an agent connects, which integration tools it gets, the exact arguments each takes, and how large metadata extracts travel via the artifactUrls path.](https://www.coremodels.io/connector/snowflake/t3-mcp)[AutomationWiring a Snowflake Drift Gate: CI, the Badge, and the Rolling TrailSchema drift has two directions, and most teams only guard one. The warehouse can move away from the agreed model - a column retyped in a Friday migration, a table quietly dropped. But the model can also move away from the warehouse - someone tightens an allowed-value list in governance and nobody re-checks the estate. This article wires up automation for both directions against a Snowflake estate governed in CoreModels: a CI gate on the machine-to-machine API, a status badge, the rolling audit history, one-call re-audits, and the scheduled heartbeat that keeps the loop honest between changes.Recipe: CI Drift Gate for Snowflake](https://www.coremodels.io/connector/snowflake/t4-automation)[Deep diveAnatomy of an Import: How a Snowflake Estate Becomes a Governed GraphTake one column - ORDER_TOTAL NUMBER(38,2) in ANALYTICS.PUBLIC.ORDERS - and follow it from an INFORMATION_SCHEMA row to a governed graph node. That single trace touches everything interesting about the Snowflake connector in CoreModels: how identity is minted, how native types map (and where they approximate), what rides the vendor-metadata mixin, how keys and dependencies become checks and lineage, which audit rules are Snowflake's own, and where the connector honestly declines to guess. This article is that trace, written for people who want to know exactly what the import does before pointing it at production metadata.Recipe: Warehouse contracts for Snowflake](https://www.coremodels.io/connector/snowflake/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect SQL DDL | CoreModels" description: "Give the column nobody can explain a rule the database can actually carry." canonical: "https://coremodels.io/connector/sql" last_updated: "2026-09-15" --- Format # Connect SQL DDL Give the column nobody can explain a rule the database can actually carry. [Import a SQL file](https://go.coremodels.io/app/new/sql)[SQL site](https://www.iso.org/standard/76583.html) Recipes No recipes yet for SQL. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import SQL DDL and CoreModels records tables, columns, types, nullability, and keys as a governed model. Enumerations and meaning that `VARCHAR(32)` cannot say become taxonomies and documentation you can generate back into comments and constraints. ## How CoreModels works with SQL DDL is honest about storage and silent about sense. Teams paper over that with check constraints they forget, lookup tables they do not join, and documents nobody diffs against production. CoreModels treats SQL as a first-class import and export. Conversion recipes (including JSON Schema to SQL) make the target dialect explicit and the loss visible. Governed allowed values can ride in comments or in generated checks depending on what the engine will enforce. Use this when the database is the last remaining source of truth - and you need it to stop being the last remaining source of confusion. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Column Nobody Can ExplainA partner feed starts rejecting rows at two in the morning. The cause is one column: status. Someone runs a SELECT DISTINCT against production and gets six values back. The application's enumeration has five. The integration document the partner was handed lists four. The column is declared VARCHAR(32), so all six values are perfectly legal - the database was never told otherwise.](https://www.coremodels.io/connector/sql/h1-need)[OutcomesFour Requests, One Schema, Nothing RetypedHere is a realistic week for whoever owns the customer schema in a mid-sized data platform.](https://www.coremodels.io/connector/sql/h2-outcomes)[GovernanceWho Signs Off on a Generated CREATE TABLE?A pull request lands. It contains a DDL file generated from a governed model, destined for a database real customers depend on. A reviewer has to decide whether to approve it.](https://www.coremodels.io/connector/sql/h3-governance)[EcosystemSQL Is Everywhere, Which Is Exactly Why It Cannot Be the CenterRead enough data specifications and you notice how often they quote SQL inside themselves.](https://www.coremodels.io/connector/sql/h4-ecosystem)[AgentsAn Agent Can Write Perfect DDL for the Wrong DatabaseLanguage models are unusually good at writing SQL DDL. They have read an enormous amount of it, the grammar is regular, and the output looks right immediately.](https://www.coremodels.io/connector/sql/h5-agents)[QuickstartYour First DDL Transform Should Write Nothing: a SQL QuickstartThe most accurate description of your data is almost certainly a CREATE TABLE statement sitting in a migrations folder. It is reviewed, versioned, and executable - and it is legible to exactly one kind of consumer. Getting it out of that folder and into a data contract, a JSON Schema, or another vendor's dialect is usually where the accuracy stops.](https://www.coremodels.io/connector/sql/t1-quickstart)[APIFour Routes, One Envelope: SQL DDL on the CoreModels Transform API| Route | Role | What it touches | |---|---|---| | POST /graph/transform/schema/import/{projectId} | Admin | writes the DDL's model into the project | | POST /graph/transform/schema/export/{projectId} | Viewer | reads the project, returns CREATE TABLE text | | POST /graph/transform/schema/map/{projectId} | Viewer (ai: Editor) | nothing - stateless, source in, target out | | POST /graph/transform/plan/execute/{projectId} | Viewer | nothing - replays a stored plan |](https://www.coremodels.io/connector/sql/t2-api)[MCPTeaching an Agent to Read DDL: the transform_schema MCP ToolA partner attaches subscriber_dump.sql to a ticket. Backticks, an ENUM, a DATETIME, and one column named by a DBA who shouts. Your canonical model is a JSON Schema in a repo. Somebody has to reconcile the two, and historically that somebody spent an afternoon in a diff viewer.](https://www.coremodels.io/connector/sql/t3-mcp)[AutomationCommit the Plan, Not the Guess: SQL Conversion Pipelines That RepeatDatabase teams solved schema-as-code years ago. DDL lives in git, migrations get reviewed, nobody types ALTER TABLE into production by hand. Then the schema has to leave the database - become a JSON Schema for the API team, a contract for the platform team, DDL for a second warehouse - and the discipline evaporates into a conversion script that one person ran once on a laptop.](https://www.coremodels.io/connector/sql/t4-automation)[Deep diveNo Annotation Slot: How the SQL DDL Coder Carries Meaning, and Where It StopsEvery other format on the CoreModels transform surface has somewhere to put meaning. JSON Schema has x- keywords. Avro has custom attributes. LinkML has slot_uri and meaning. OWL is meaning. SQL DDL has a name, a type, and a handful of constraints - and no annotation slot at all.](https://www.coremodels.io/connector/sql/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Connect Azure Synapse | CoreModels" description: "Record the constraints that die on the way to a registered schema." canonical: "https://coremodels.io/connector/synapse" last_updated: "2026-09-15" --- Early access # Connect Azure Synapse Record the constraints that die on the way to a registered schema. [Connect Azure Synapse](https://go.coremodels.io/app/new/synapse)[Azure Synapse site](https://azure.microsoft.com/services/synapse-analytics/) Recipes No recipes yet for Azure Synapse. The articles below still describe the problem this connector is built to close. Connector summary ## What the recipes deliver Import Synapse table metadata or generate Synapse-shaped JSON Schema from a richer model. CoreModels keeps the lossiness ledger so a `multiple of 10, greater than zero` rule cannot collapse to `integer` without anyone noticing. ## How CoreModels works with Azure Synapse The Synapse profile in CoreModels exists for the silence, not for the conversion. Conversion is easy. Silence is expensive. Encode-only JSON Schema for Synapse is draft-07 by design. The schematic migration recipe and LinkML-to-Synapse conversion make that subset explicit. Re-audit the governed model against what Synapse will actually validate so platform limits become reviewed findings, not vanished rules. If you are moving meaning into Synapse, start from the richer model and keep the ledger. If you are already in Synapse, import what is there and stop pretending the registered schema was the whole definition. Guides ## Problems this connector fixes Articles that explain the gap, then point at the recipe that closes it. All Engineering Strategy [ProblemThe Constraint That Stopped FiringA value that should have been rejected is sitting in a table. The governed model is explicit about that field: multiples of ten, strictly greater than zero. The schema the platform actually validates against says integer. Nobody deleted the rule on purpose. It was lost in translation months earlier, when a person hand-converted the model into the shape a Synapse registered schema can carry - and nothing, anywhere, recorded that it had been lost.](https://www.coremodels.io/connector/synapse/h1-need)[OutcomesThree Artifacts by Five O'Clock, None of Them TypedBy the end of the afternoon there are three things on the branch that did not exist at lunchtime: a registered-schema document ready to hand to Synapse, a blank curation grid, and a column dictionary listing every value set with its terms. Nobody typed any of them. They were projected from one governed model, in two calls, by a person whose actual work that afternoon was deciding whether the change deserved a minor or a patch bump.](https://www.coremodels.io/connector/synapse/h2-outcomes)[GovernanceThe Difference Between a Guess and a RecordThere are two ways to handle the places where a platform's public documentation goes quiet. You can guess - pick the behavior that seems likely, emit it, and hope the wire agrees with you. Or you can record - pick the conservative representation, write down exactly what you could not confirm, and hand that note to the person making the decision.](https://www.coremodels.io/connector/synapse/h3-governance)[EcosystemWhere a Schema Goes After You Export ItFollow the artifact. A JSON Schema document leaves your modeling environment, gets registered with a schema service under an organization and a version, gets bound to entities on a data platform, and from then on every annotation set on those entities is validated against it. In parallel, a tabular manifest derived from the same definitions lands in front of contributors, who fill it in row by row; their uploads succeed or fail against the schema the platform holds. That is the life of a schema in the Synapse world - and understanding that world is the best way to understand where CoreModels does and does not sit in it.](https://www.coremodels.io/connector/synapse/h4-ecosystem)[AgentsAn Agent That Can Say "Unconfirmed"Ask an AI assistant whether Synapse will enforce the date-time format on a string field, and you will get an answer. It will be fluent, it will cite draft-07's treatment of format as an annotation, it may even be correct - but you cannot tell, because the model would have produced an equally fluent answer either way. The honest response to that question is "unconfirmed," and unqualified fluency is the one register in which a language model struggles to say it.](https://www.coremodels.io/connector/synapse/h5-agents)[Use caseYour Data Model Outlives Its ToolchainFor most of a decade, a data coordinating center in the Synapse world did not exactly have a data model - it had a schematic data model. The CSV the curation team maintained was written for schematic to compile. The JSON-LD graph it produced was shaped for schematic to traverse. The validation rules were expressed in schematic's vocabulary, the contributor manifests came out of schematic's generator, and the Data Curator App put a face on all of it. The model and the toolchain were one artifact, and that was fine - right up until April 2026, when the toolchain's repository was archived with a deprecation notice naming the end of the year.](https://www.coremodels.io/connector/synapse/h6-schematic-migration)[QuickstartFrom JSON Schema to a Registration-Ready Synapse Schema in One CallYou have a JSON Schema. Synapse - Sage Bionetworks' data platform - will not accept all of it. Registered Synapse schemas are draft-07, and not even all of draft-07: the platform's JsonSchema REST object models a specific keyword subset, and anything outside it simply is not part of a registered schema. This quickstart takes a small, real schema across that boundary in one HTTP call to CoreModels (by ARAMAI), then reads the machine-readable ledger of exactly what the boundary cost.](https://www.coremodels.io/connector/synapse/t1-quickstart)[APIThe Synapse Export, Route by Route: A CoreModels API ReferenceEvery format in the CoreModels transform surface belongs to two lists - the formats we decode and the formats we encode - and synapse appears in exactly one of them. The decode list is jsonschema | shex | avro | jsonld | sql | osi | osi-json | owl | linkml | protobuf | odcs | odm; the encode list swaps odm out and synapse in. This page is the working reference for that one direction: which routes produce a Synapse-ready schema, what each accepts, which one controls the registered-schema $id, and how to bring a Synapse schema back in anyway.](https://www.coremodels.io/connector/synapse/t2-api)[MCPSynapse Schemas from an Agent: transform_schema over MCP, End to EndConnect an MCP client - Claude Desktop, an IDE agent, your own orchestration - to a CoreModels deployment at https://coremodels.example.com/mcp (OAuth-protected), and two tools give it the entire Synapse workflow: transform_schema produces the registration-ready draft-07 schema, and generate_synapse_manifests produces the tabular curation companions. This article is the end-to-end session, with exact arguments and exact results, so an agent - or the person supervising one - knows precisely what each call does and does not do.](https://www.coremodels.io/connector/synapse/t3-mcp)[AutomationAutomating Synapse Schema Releases: Determinism, Plan Replay, and Version DisciplineRun the same Synapse export twice against the same model and you get the same bytes. That single property - deterministic encoding - is what turns the CoreModels synapse profile from a converter into release machinery: outputs you can commit and diff, plans you can store and replay, and a version rule you can enforce mechanically instead of remembering. This article builds that pipeline piece by piece, with the honest constraints stated where they bite.](https://www.coremodels.io/connector/synapse/t4-automation)[Deep diveInside the synapse Coder: The Whitelist, the Ledger, and the Edge CasesThe entire CoreModels synapse profile can be stated in one sentence: encode the neutral model as JSON Schema, then keep only what the Synapse JsonSchema REST object has a field for - and write down every single thing that rule removes. This deep dive unpacks that sentence into the parts an integrator eventually needs: the IR-to-output mapping, the exact keyword whitelist and how strips are classified, the extras channel that carries verbatim keywords through the neutral model, the complete inventory of lossiness records the encoder can emit, and the edge cases our test suite pins - including the ones where we deliberately refuse to guess.](https://www.coremodels.io/connector/synapse/t5-deep-dive) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Stop your agent guessing what status means | dbt recipe | CoreModels" description: "An LLM writing SQL against your warehouse has three bad options: guess from the column name, read the SQL, or ask a human. Give it a fourth." canonical: "https://coremodels.io/recipe/agent-grounding" last_updated: "2026-09-15" --- ImportGA # Stop your agent guessing what status means An LLM writing SQL against your warehouse has three bad options: guess from the column name, read the SQL, or ask a human. Give it a fourth. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/agent-grounding) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/agent-grounding.json](https://www.coremodels.io/recipe/agent-grounding.json) · [/recipe/agent-grounding.md](https://www.coremodels.io/recipe/agent-grounding.md) Every text-to-SQL tool and coding agent pointed at your warehouse is inferring meaning from column names and whatever free text happens to be in a description. It cannot know that status has exactly five permitted values, that return_pending is a kind of return rather than a peer of it, that customer_id means the same thing here as cust_id does two models over, or that this column is the one bound to a public term the rest of the industry uses. So it guesses confidently, and a confident wrong answer about meaning is worse than no answer. This workspace makes the governed definitions readable by machines: an agent connects over MCP and can ask what a column means, which values are permitted and what each one is, what the column is bound to externally, and what else carries the same concept — and it gets the governed answer a human curated, not an inference. dbt's own agent surfaces expose dbt's contents; this exposes the meaning behind them. ## What you do 1. Import the manifest; each accepted_values list becomes a governed vocabulary. 2. Fill three fields (meaningNote, commonMistake, doNotUseFor) on the columns agents get wrong. About 20 is enough to test the loop. 3. Connect your assistant to the read-only MCP endpoint (it reads your governed definitions, not your warehouse) and replay a question it used to get wrong. ## Guides for this recipe ### Strategy Why the problem exists, and what changes once it is fixed. [AgentsThe Fourth Option for a Column Named statusThis is no longer a hypothetical audience. dbt Labs' 2026 State of Analytics Engineering (n=363) reports 72% of teams prioritizing AI-assisted coding and 71% concerned about incorrect data reaching stakeholders — the same teams, describing both halves of the problem below.](https://www.coremodels.io/connector/dbt/h5-agents) ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [GuideGrounding an Agent in Your dbt Project: What It Reads, and What ChangesAn agent pointed at your warehouse can already write SQL. The question is what it knows about the columns it writes against, and the honest answer is: the names, the types, and whatever free text happens to be in a description. Everything else it infers.](https://www.coremodels.io/connector/dbt/t6-agent-grounding) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/agent-grounding) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "One enum, every model | dbt recipe | CoreModels" description: "Two files test the same column with different accepted_values. Both pass. Find the one that drifted." canonical: "https://coremodels.io/recipe/governed-vocabulary" last_updated: "2026-09-15" --- ImportGA # One enum, every model Two files test the same column with different accepted_values. Both pass. Find the one that drifted. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/governed-vocabulary) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/governed-vocabulary.json](https://www.coremodels.io/recipe/governed-vocabulary.json) · [/recipe/governed-vocabulary.md](https://www.coremodels.io/recipe/governed-vocabulary.md) Open two dbt YAML files that test the same column and compare the accepted_values lists. If one is missing a value somebody added six months ago, nothing in dbt will ever report it — each test is internally valid, so both pass. The lists are strings, copied per model, with no definition behind them and nothing that notices when they disagree. This recipe finds them: import the manifest and every accepted_values list becomes a governed vocabulary you can see side by side — which models reference it, and which one drifted. Name it, describe it, add the value that was missed, give it an owner. That much works today. Publishing the corrected list back into every model that uses the field is the next step, and we run that with you while the self-serve path is finished. Your workspace opens with the vocabulary grid and ownership columns already configured. ## What you do 1. See every vocabulary referenced by more than one model, and the one that drifted. 2. Name it, describe it, give it an owner. Once. 3. Publishing the list back into every model is Early access: Generate returns the property files, we walk the first publish with you, and you open the PR. ## Guides for this recipe ### Strategy Why the problem exists, and what changes once it is fixed. [ProblemEleven Copies of One EnumGrep a mature dbt project for accepted_values and count the hits on your order status field. In a mature project, the number is rarely one. The list appears in the staging model that first cleans the column, in two intermediate models, in the fact table, in three marts built for three teams, and in another four models a second squad wrote when it needed the same field and copied the nearest example it could find.](https://www.coremodels.io/connector/dbt/h1-need) ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [GuideFinding the accepted_values List That DriftedTwo files in your project test the same column against different value lists. Both tests pass, so nothing has ever told you. This guide finds them, and turns the list into something that can only be defined once.](https://www.coremodels.io/connector/dbt/t7-vocabularies) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/governed-vocabulary) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Who decides what this column means? | dbt recipe | CoreModels" description: "In dbt Labs' 2026 State of Analytics Engineering survey (n=363), 41% of teams still name ambiguous data ownership as an obstacle. dbt can tell you who owns a model, not who owns a definition five models share." canonical: "https://coremodels.io/recipe/ownership-register" last_updated: "2026-09-15" --- ImportGA # Who decides what this column means? In dbt Labs' 2026 State of Analytics Engineering survey (n=363), 41% of teams still name ambiguous data ownership as an obstacle. dbt can tell you who owns a model, not who owns a definition five models share. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/ownership-register) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/ownership-register.json](https://www.coremodels.io/recipe/ownership-register.json) · [/recipe/ownership-register.md](https://www.coremodels.io/recipe/ownership-register.md) dbt's own 2026 State of Analytics Engineering put ambiguous data ownership among the top pains teams report, alongside trust and quality — and it is the one with the least tooling. dbt groups and model owners tell you who maintains the SQL. They do not tell you who decides what customer_status is allowed to contain, who to ask before adding a value, or who should have been consulted when someone changed it last quarter. So the answer is usually 'ask in #analytics and see who replies'. This workspace makes ownership a property of the meaning rather than of the file: every column and every vocabulary can carry an owner, a steward team and a review cadence, sitting as columns in a grid you can sort and filter. The most useful view is the one that shows what has no owner at all — that list is your actual to-do, and it is the prerequisite for every review, notification and escalation workflow you might build later. ## What you do 1. Every column and vocabulary gains an owner, a steward team, a review cadence and a decision forum. 2. Filter to 'no owner'. That list is the real work. 3. Start with the vocabularies, that is where the arguments live. ## The story behind this recipe ### Ask in #analytics and See Who Replies Somebody wants to add a value to a status column. They are not being careless — they have checked that the value is real, and they have found the model. What they cannot find is the person who gets to say yes. [Read the full story →](https://www.coremodels.io/connector/dbt/h7-ownership) ## Guides for this recipe ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [GuideBuilding an Ownership Register That Survives Contact With a Real TeamOwnership registers fail in a predictable way: someone fills a spreadsheet in a week of good intentions, three people leave over the next year, and the file becomes an archaeological record of who used to work here. This guide builds one that does not do that.](https://www.coremodels.io/connector/dbt/t8-ownership) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/ownership-register) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "The PR your dbt CI passes | dbt recipe | CoreModels" description: "Delete an accepted_values test and CI goes green — because the test is gone. Nothing compares the PR to what you agreed." canonical: "https://coremodels.io/recipe/ci-contract-gate" last_updated: "2026-09-15" --- ImportEarly access # The PR your dbt CI passes Delete an accepted_values test and CI goes green — because the test is gone. Nothing compares the PR to what you agreed. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/ci-contract-gate) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/ci-contract-gate.json](https://www.coremodels.io/recipe/ci-contract-gate.json) · [/recipe/ci-contract-gate.md](https://www.coremodels.io/recipe/ci-contract-gate.md) Try it on a branch: remove an accepted_values test from a model and open a PR. Every check passes. dbt tests what is in the branch, so a removed test is simply a test that no longer runs, and branch-versus-main tooling compares the PR to the previous commit — which also no longer has it once merged. The thing nobody compares against is what the team actually agreed the column means. This gate does that: on every PR, the compiled manifest is checked against the governed model, and a removed permitted-value set, a widened enum, a type that quietly changed or a dataset that vanished each come back as a named finding with a stable code. Set it to fail on errors and the PR that would have slipped through stops. The report comes back as markdown you can post as the PR comment, every run feeds a history trail, and the badge shows the current state — because unknown and passing are different claims. ## What you do 1. Import the manifest you consider correct today (main) as the baseline. 2. Audit a PR's manifest against it: removed value sets, widened enums, silent retypes, vanished datasets, as named findings. 3. Start on errors only. A gate that fails on day one for untriaged warnings is switched off in a week. ## The story behind this recipe ### Every Check You Run Compares the PR to the Last Commit Here is a two-minute experiment worth doing on a branch before you read further. [Read the full story →](https://www.coremodels.io/connector/dbt/h9-ci-gate) ## Guides for this recipe ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [AutomationTwo Loops and an Empty Diff: dbt Contract Automation in CITry this on a branch first, because it reframes what the gate is for. Take a model with an accepted_values test, delete the test, and open a pull request.](https://www.coremodels.io/connector/dbt/t4-automation) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/ci-contract-gate) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Publish governed meaning into dbt | dbt recipe | CoreModels" description: "Govern a column's meaning once, and let dbt carry it to the warehouse column comment." canonical: "https://coremodels.io/recipe/publication-contract" last_updated: "2026-09-15" --- ImportEarly access # Publish governed meaning into dbt Govern a column's meaning once, and let dbt carry it to the warehouse column comment. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/publication-contract) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/publication-contract.json](https://www.coremodels.io/recipe/publication-contract.json) · [/recipe/publication-contract.md](https://www.coremodels.io/recipe/publication-contract.md) dbt emits one artifact class — tables in one warehouse — and gives governed meaning nowhere to live: description is free text, meta is unvalidated, and accepted_values is a string list duplicated into every model that touches the field. This recipe closes that loop. Import the artifacts dbt already produces, govern meaning on top (descriptions, a named vocabulary behind an enum, an ontology term a human binds), then generate the contracts back as one property file per model, colocated beside each model's own .sql. One governed vocabulary generates accepted_values in every model that uses that field; a bound ontology term rides out both structurally (meta.coremodels.maps_to) and in the column description, which persist_docs carries into the warehouse column comment. Generation is deterministic, so a re-run with no meaning change is an empty diff. CoreModels returns files — your own PR flow lands them. ## What you do 1. Govern the meaning in the grid; generate one property file per model, colocated beside its .sql. 2. The bound term rides in the column description (the field persist_docs pushes to the warehouse comment) and in meta. 3. Every run hands you a loss report. No meaning change means no diff. ## Guides for this recipe ### Strategy Why the problem exists, and what changes once it is fixed. [OutcomesThe Ticket Nobody FilesThe enum problem is the one everybody recognizes, and it is not the whole of what changes. Once meaning is governed once and published back into dbt, a set of small recurring chores stop happening — and one of them has been costing time every month without ever being on a roadmap.](https://www.coremodels.io/connector/dbt/h2-outcomes) ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [QuickstartManifest In, Contracts Out: A dbt Round Trip in Five StepsMost integrations treat dbt as somewhere to read from. This one also publishes back: governed meaning leaves CoreModels as dbt model property files with enforced contracts, one file per model, colocated beside that model's own .sql. This walkthrough runs the whole loop — artifacts out of dbt, meaning governed on top of them, contracts back into the repo, dbt build green. Nothing here needs a warehouse credential or a dbt platform connection: artifacts in, artifacts out. CoreModels never writes to your repo and never opens a pull request. Generate returns files; your own PR flow lands them.](https://www.coremodels.io/connector/dbt/t1-quickstart) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/publication-contract) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "What breaks if I rename this? | dbt recipe | CoreModels" description: "dbt lineage tells you which models depend on this one. It cannot tell you who outside dbt is relying on this column." canonical: "https://coremodels.io/recipe/change-impact" last_updated: "2026-09-15" --- ImportEarly access # What breaks if I rename this? dbt lineage tells you which models depend on this one. It cannot tell you who outside dbt is relying on this column. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/change-impact) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/change-impact.json](https://www.coremodels.io/recipe/change-impact.json) · [/recipe/change-impact.md](https://www.coremodels.io/recipe/change-impact.md) Everyone has hesitated over a column rename. dbt gives you model-level lineage inside the project — dbt ls --select model+ — and that is genuinely useful, but it answers a narrower question than the one you are actually asking. It does not know that this column's values come from a vocabulary four other models also use, that its meaning is bound to a public term, that a reverse-ETL job and a partner contract both carry it, or who to ask before you touch it. So the honest answer is usually a Slack message and a hopeful deploy. This workspace answers it properly: ask any column, vocabulary or model what depends on it, and get back the governed usage, every imported source carrying it and by what path, the external identifiers it is bound to, and the serializations it travels into. Ask before you change, not after the incident review. ## What you do 1. Ask any column or vocabulary what depends on it: governed usage, every imported source that carries it, and by what path. 2. You ask about one column or one vocabulary, not a whole model. The answer follows the governed meaning; it does not trace which downstream column it became. 3. Available over the API today; the in-product panel follows. ## The story behind this recipe ### The Rename You Didn't Make There is a column in your project called status, and you have wanted to rename it for about eight months. It should be order_status — everyone agrees. You have not done it. [Read the full story →](https://www.coremodels.io/connector/dbt/h6-change-impact) ## Guides for this recipe ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [AutomationTwo Loops and an Empty Diff: dbt Contract Automation in CITry this on a branch first, because it reframes what the gate is for. Take a model with an accepted_values test, delete the test, and open a pull request.](https://www.coremodels.io/connector/dbt/t4-automation) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/change-impact) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md) --- --- title: "Jaffle Shop, worked: what orders.status means | dbt recipe | CoreModels" description: "dbt Labs' sample project, with its five-value status column annotated so an agent looks it up instead of guessing. Every field is on the page." canonical: "https://coremodels.io/recipe/jaffle-shop-status" last_updated: "2026-09-15" --- Import # Jaffle Shop, worked: what orders.status means dbt Labs' sample project, with its five-value status column annotated so an agent looks it up instead of guessing. Every field is on the page. [Start with this recipe →](https://go.coremodels.io/app/new/dbt/jaffle-shop-status) Just manifest.json. No warehouse credential, no dbt Cloud token, no writes to your repo. Opens the CoreModels app at this recipe. Sign in with Google or Microsoft. For agents, no sign-in: [/recipe/jaffle-shop-status.json](https://www.coremodels.io/recipe/jaffle-shop-status.json) · [/recipe/jaffle-shop-status.md](https://www.coremodels.io/recipe/jaffle-shop-status.md) A worked instance of the agent-grounding recipe on jaffle-shop-classic, the dbt Labs sample project most analytics engineers run first. Its docs tell a human what the five orders.status values mean. They do not tell an agent that paid and cancelled do not exist, that shipped is not revenue, or that stg_payments has no status column at all. This recipe fills exactly that layer (meaningNote, commonMistake, doNotUseFor, permitted values and an owner), then shows the SQL an agent writes before and after it can read them. Import the same manifest into your own workspace and fill the same fields. ## What you do 1. Run dbt parse on jaffle-shop-classic and import target/manifest.json; each accepted_values list, orders.status included, becomes a governed vocabulary. 2. Fill meaningNote, commonMistake and doNotUseFor on the columns an agent gets wrong. The annotated set is below. 3. Point your assistant at the read-only endpoint and ask: what was completed revenue last month? ## The worked example: Jaffle Shop · orders.status Built on [jaffle-shop-classic](https://github.com/dbt-labs/jaffle-shop-classic), dbt Labs' sample project (Apache-2.0). Four models: - customers (mart): One row per customer, with derived facts from that customer's orders and payments. - orders (mart): One row per order, with payment amounts by method. Carries status. - stg_orders (staging): Cleaned orders from the raw_orders seed. Carries the same status column and the same accepted_values test. - stg_payments (staging): Cleaned payments from the raw_payments seed: payment_method and amount. No status column. ## The question What was completed revenue last month? A text-to-SQL assistant that cannot look the column up guesses a status list, and the guess is usually some mix of shipped, completed and paid. Before: the agent guesses ```text select sum(amount) as revenue from orders where order_date >= date_trunc('month', current_date - interval '1 month') and order_date < date_trunc('month', current_date) and status in ('shipped', 'completed', 'paid'); ``` - paid is not a permitted value. It matches no rows, so the query runs cleanly and nobody learns the guess was wrong. - shipped is not revenue: the customer has not received the goods. - The currency is unstated. The column is AUD. After: the agent looks it up ```text select sum(amount) as completed_revenue_aud from orders where order_date >= date_trunc('month', current_date - interval '1 month') and order_date < date_trunc('month', current_date) and status = 'completed'; ``` orders.status has five permitted values and no paid. Its doNotUseFor says revenue means filtering status = 'completed'. orders.amount says the unit is AUD. ## orders.status, fully annotated | Value | Meaning | | --- | --- | | placed | The order has been placed but has not yet left the warehouse. | | shipped | The order has been shipped to the customer and is currently in transit. | | completed | The order has been received by the customer. | | return_pending | The customer has indicated that they would like to return the order, but it has not yet been received at the warehouse. | | returned | The order has been returned by the customer and received at the warehouse. | definition Fulfillment state of a single order. Five values, mutually exclusive. The values and their descriptions come from the orders_status docs block in jaffle-shop-classic. permittedValues placed · shipped · completed · return_pending · returned meaningNote This is the fulfillment state of one order, not a customer lifecycle flag and not a payment result. Only completed means the customer received the goods. placed and shipped are open. return_pending and returned come after the fact: they are not kinds of open and not kinds of successful. There is no cancelled, pending, paid, active or failed value in this column. commonMistake Inventing values the column does not have (pending, cancelled, active, paid, success). Treating shipped plus completed as successful orders. Reading status as a property of the customer rather than the order. Looking for a status on payments: stg_payments has none in this project. doNotUseFor Revenue on its own (filter amount where status = 'completed'). Active-customer counts. Payment success or failure. Inventory on hand. Any query that IN-lists values you did not look up here. agentGuidance Before writing SQL against orders.status, read permittedValues. If the question says revenue, completed or sold, filter status = 'completed'. If it says open or in flight, use placed or shipped. If it says returns, use return_pending or returned. Never invent a sixth value. owner Jordan Hale (Finance lead · example person) steward Maya Chen (Analytics engineer · example person) source models/schema.yml · accepted_values · docs block orders_status ## The other columns an agent gets wrong ### stg_orders.status definition The staging copy of the same field. Same vocabulary as orders.status. permittedValues placed · shipped · completed · return_pending · returned meaningNote Identical permitted values to orders.status. Prefer the mart column in analyst questions unless the question is about the staging model itself. commonMistake Declaring a different accepted_values list here than on orders.status. Both tests can pass. That is how two definitions of one column survive in a dbt project. doNotUseFor A second, private meaning of status. If staging and mart disagree, that is drift, not a new definition. owner Maya Chen (Analytics engineer · example person) source models/staging/schema.yml · accepted_values ### orders.amount definition Total amount of the order in Australian dollars: the sum of the credit_card, coupon, bank_transfer and gift_card payment amounts. unit AUD meaningNote Present on every order whatever its status. It is not revenue. Completed revenue is sum(amount) where status = 'completed'. The raw_payments seed stores cents; by the time it reaches this column it is dollars. commonMistake sum(amount) across all statuses, labelled revenue. Assuming USD. Adding raw_payments.amount (cents) to it. Treating coupon_amount as a discount rather than a payment method. doNotUseFor Completed revenue without a status filter. USD reporting. Margin: there is no cost column in this project. owner Jordan Hale (Finance lead · example person) source models/schema.yml ### customers.customer_lifetime_value definition Lifetime sum of payments for this customer's orders, all statuses. customers.sql emits this column as customer_lifetime_value; models/schema.yml documents the same figure under the name total_order_amount, which the model does not produce. unit AUD meaningNote Lifetime gross payments, not completed-only value and not current-period revenue, whatever the name suggests. commonMistake Querying total_order_amount: it is documented in schema.yml but is not a column of the built table. Calling this figure what the customer paid and kept: it includes placed, shipped, return_pending and returned orders. doNotUseFor Period revenue. Completed-only customer value. Churn or active-customer definitions. owner Jordan Hale (Finance lead · example person) source models/customers.sql ### customers.number_of_orders definition Count of the orders this customer has placed, all statuses. meaningNote Includes return_pending and returned orders. A customer with one placed order and one returned order has number_of_orders = 2. commonMistake Using it as a count of completed purchases, or as a proxy for active. doNotUseFor Completed-order counts. Active-customer flags. owner Maya Chen (Analytics engineer · example person) source models/schema.yml ### customers.first_name definition Customer's first name. Marked PII in the upstream schema.yml. pii true meaningNote Personal data. The seed values are fictional, which is the only reason this example shows the column at all. commonMistake Echoing names into agent logs, eval traces or answers as if they were a dimension. doNotUseFor Joins, aggregations, or anything an agent might print. Use customer_id. owner Maya Chen (Analytics engineer · example person) source models/schema.yml ### customers.last_name definition Customer's last name. Marked PII in the upstream schema.yml. pii true meaningNote Personal data. The seed values are fictional. commonMistake Same as first_name. doNotUseFor Joins, aggregations, or anything an agent might print. Use customer_id. owner Maya Chen (Analytics engineer · example person) source models/schema.yml ### stg_payments.payment_method definition How this payment was tendered. One row per payment; an order can have several. permittedValues credit_card · coupon · bank_transfer · gift_card meaningNote coupon is a payment method in this project, not a discount. There is no payment status column in jaffle-shop-classic. commonMistake Inventing cash or paypal. Treating coupon as a markdown against amount. Looking for a payments status column: it does not exist here. doNotUseFor Order fulfillment state (that is orders.status). Discount analysis. A second status vocabulary. owner Maya Chen (Analytics engineer · example person) source models/staging/schema.yml · accepted_values ### stg_payments.amount definition Payment amount in dollars. The raw_payments seed stores cents; stg_payments.sql divides by 100. unit AUD meaningNote Already converted: this column and orders.amount are both dollars. Only the raw_payments seed is in cents. commonMistake Dividing by 100 a second time. Reading the raw_payments seed directly and summing cents as dollars. doNotUseFor Revenue on its own: join to orders and filter status = 'completed'. Mixing with raw_payments.amount without converting. owner Maya Chen (Analytics engineer · example person) source models/staging/stg_payments.sql ## Point your agent at it Import the manifest into your own workspace, fill the fields, then connect your assistant to the read-only MCP endpoint. The annotations on this page are an example to read; your agent queries your own copy. MCP client config (mcp.json) ```text { "mcpServers": { "coremodels": { "url": "https://go.coremodels.io/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Claude Code ```text claude mcp add --transport http coremodels https://go.coremodels.io/mcp ``` Setup for Cursor and other clients, as documented: [MCP Server](https://library.schematica.io/mcp-server). Then ask it: What was completed revenue last month? ## Attribution Jaffle Shop is dbt Labs' sample project jaffle-shop-classic, licensed Apache-2.0. The models, the columns, the accepted_values lists and the five status descriptions are theirs (models/schema.yml, models/docs.md). The annotations on this page (meaningNote, commonMistake, doNotUseFor, owners) are CoreModels example content, not part of the upstream project. [schema.yml](https://github.com/dbt-labs/jaffle-shop-classic/blob/main/models/schema.yml) · [docs.md](https://github.com/dbt-labs/jaffle-shop-classic/blob/main/models/docs.md) · [Apache-2.0 license](https://github.com/dbt-labs/jaffle-shop-classic/blob/main/LICENSE) Maya Chen and Jordan Hale are example people, invented for this recipe. They are not customers or staff. ## Guides for this recipe ### Strategy Why the problem exists, and what changes once it is fixed. [AgentsThe Fourth Option for a Column Named statusThis is no longer a hypothetical audience. dbt Labs' 2026 State of Analytics Engineering (n=363) reports 72% of teams prioritizing AI-assisted coding and 71% concerned about incorrect data reaching stakeholders — the same teams, describing both halves of the problem below.](https://www.coremodels.io/connector/dbt/h5-agents) ### Engineering How it works: the import, the API, the MCP tools, the CI loop. [GuideGrounding an Agent in Your dbt Project: What It Reads, and What ChangesAn agent pointed at your warehouse can already write SQL. The question is what it knows about the columns it writes against, and the honest answer is: the names, the types, and whatever free text happens to be in a description. Everything else it infers.](https://www.coremodels.io/connector/dbt/t6-agent-grounding)[MCPFour Tools and a Ledger: dbt Contracts from an Agent's Seat"Generate the contracts for stg_orders and stg_customers, and tell me if anything won't apply cleanly." That sentence is an afternoon of dbt property-file maintenance, and an agent connected to CoreModels over MCP can answer it with real tool calls instead of plausible-looking YAML. Four vendor integration tools give the agent the same governance surface a human gets over HTTP: the same role checks, the same read-only guarantees, and the same honest ledger of what could not be represented.](https://www.coremodels.io/connector/dbt/t3-mcp) [← All dbt recipes](https://www.coremodels.io/connector/dbt#recipes)[Start with this recipe →](https://go.coremodels.io/app/new/dbt/jaffle-shop-status) CoreModels Connect your schemas. Map it all. Point your agent at it. #### [CoreModels Solution Framework](https://www.coremodels.io/framework) - [The Core Model](https://www.coremodels.io/framework/core-model) - [Coherence](https://www.coremodels.io/framework/coherence) - [Why CoreModels](https://www.coremodels.io/framework/why) - [How it works](https://www.coremodels.io/framework/how-it-works) - [Capabilities](https://www.coremodels.io/framework/capabilities) - [Who it serves](https://www.coremodels.io/framework/who) - [The Schematica Suite](https://www.coremodels.io/framework/suite) #### Product - [Connectors](https://www.coremodels.io/connectors) - [Guides](https://www.coremodels.io/guides) - [Docs](https://learn.coremodels.io/) - [API reference](https://learn.coremodels.io/user-guides/integration-apis/reference) - [MCP server](https://library.schematica.io/mcp-server) - [Q&A](https://www.coremodels.io/q-a) #### Buy - [Pricing](https://www.coremodels.io/pricing) - [Founding offer](https://www.coremodels.io/pricing#founding) - [Contact sales](https://www.aramai.net/contact/eyJleHRyYURhdGEiOiJjb3JlbW9kZWxzIiwicmVxdWVzdFNvdXJjZSI6ImNvcmVtb2RlbHMifQ==) - [Partner program](https://www.coremodels.io/pricing#partner) #### Legal - [Terms](https://www.coremodels.io/legal/terms) - [Privacy](https://www.coremodels.io/legal/privacy) - [SLA](https://www.coremodels.io/legal/sla) - [DPA](https://www.coremodels.io/legal/dpa) - [Security](https://www.coremodels.io/legal/security) - [Refunds](https://www.coremodels.io/legal/refunds) #### Connect - [GitHub](https://github.com/aramai-official/) - [LinkedIn](https://www.linkedin.com/company/aramai) CoreModels is a product of [ARAMAI](https://www.aramai.net/), part of the Schematica Suite. AI builds. Humans govern. Schemas connect both. CoreModels® is a registered trademark. © 2026 Ariesnet, Inc. All rights reserved. [For agents](https://www.coremodels.io/llms.txt) ## Sitemap - [Sitemap in markdown](https://www.coremodels.io/sitemap.md)