AI Architecture

What it is

DeltaVault’s AI runs against the same governed metadata you edit: business entities, models, tables, columns, relationships, knowledge documents. It isn’t a chat widget bolted onto a catalog. When the AI proposes business domains, it has already read the domains you have, so it doesn’t propose duplicates. When it writes, the write goes through the same role checks and audit trail as a human edit. The metadata spine and the AI share one source of truth, and that changes the AI’s job: not answering questions about your data, but doing catalog work you then review.

Every AI capability in the product is a skill: a published, versioned configuration that declares its prompt, its inputs, which context it reads, which actions it may take, and how results come back. Skills are authored in an admin playground and published like software, with version snapshots and a draft/publish lifecycle. New capability is a new skill, not a new release. A free-text chat orchestrator sits on top: type what you want, and it routes your intent to the right skill by semantic search over the skill catalog, gathers the inputs, and runs it, pausing for your selections along the way.

Around that core sit the controls a platform needs before anyone trusts it: every AI write is a proposal you approve item by item, every run records exactly what context was sent (and what was dropped), spend is estimated in credits before a run starts and capped per member, and organizations that can’t send data offshore can pin inference to a geographic region or bring their own model credentials.

In the free edition

Included: Ask AI. The assistant, the skill catalog, the chat orchestrator, the proposal review flow and the per-run context manifest are all part of the free edition.

Bringing your own Anthropic key is how a free organization pays for that AI, and it is switched on per deployment. The free edition grants it, but a deployment can have the surface turned off for everyone, and where it is off no organization of any tier can add a key. If you are looking at a DeltaVault instance and the credentials card is not in Settings, that is what has happened, and enabling it is an operator step rather than anything you can change. Read this as “the free edition is built to run on your own key” rather than as a promise about the instance in front of you.

Not included: AI Operations. The AI Skills switchboard, the AI Activity run log, the AI Usage dashboard and its credit total in the top bar, and the Models and Budgets cards in Settings administer and meter the AI allowance the platform pays for. A free organization runs the assistant on its own key and has no allowance to meter, so it has none of these pages. A paying core organization has them.

Not included: AI regions, Model review, and Research. Pinning inference to a geographic region, the model review surface and the knowledge base’s web research runs are all outside the free edition. The first two are also outside every paying tier today.

A free organization runs Claude on its own key. With no key configured, an AI call fails with an error naming the remedy rather than quietly billing us. That also means none of the credit machinery above applies to it: no monthly allowance, no buffer, no top-up packs. Your provider bills you directly and DeltaVault does not sit in the middle.

The requirement covers Claude, whether served by Anthropic directly or through Amazon Bedrock. Anything DeltaVault runs on another provider stays on platform infrastructure and costs a free organization nothing: the embeddings behind vector search, knowledge retrieval and help search are the ones a free organization actually meets.

How it works

Skills: AI capability as configuration

A skill bundles a system prompt, a declared input form (free text, pickers for entities, tables, columns, connections, knowledge documents), a default effort level, context toggles, the set of actions it is allowed to perform, and a result mode. Every AI capability in the product is a skill in one registry, including behaviors that used to be prompts hardcoded in the product (the chat brain, the workshop, discovery, consolidation, governance checks, document classification, and the Model Review passes); a skill’s kind marks whether it is a user-facing skill or a built-in system skill. Platform admins author skills in the AI Playground: a skill-centric editor with a test panel that opens over it, so the edit-test-edit loop never leaves the page. Publishing snapshots the version; production runs use the published version while drafts stay private to the playground.

Because the built-in behaviors are now skills too, an administrator can read and tune the exact instructions the product runs: the System AI group in the Playground exposes each formerly-hardcoded prompt as a published skill, with the structural fields guarded so the prompt and its effort can be tuned without changing the shape the product depends on.

Skills can also cite foundation documents: a second, slower-moving tier of versioned guidance such as dimensional modeling, PII handling, medallion architecture, slowly changing dimensions, data quality and profiling, and glossary and naming standards. Cited foundations resolve at request time (latest published version), dedupe, and inject into the same system prompt as the skill, within a fixed budget. The textbook chapters and the exercises stay separate, so updating a principle updates every skill that cites it without touching the skills themselves.

The published skill catalog

DeltaVault ships a published catalog of skills, organized into families that map to the work a data team actually does. Business-domain and entity discovery both starts a model and grows it: a starter set of top-level business domains with the business models nested under each, grounded in the metadata your organization already tracks; the core business concepts a selected model is missing, each with a category, a one-sentence definition, and a likely business key; and the entities and relationships a model should gain, returned as a graph the canvas draws as ghost nodes beside the model you have open. A dedicated Discover relationships and keys skill works the same model at a finer grain: launched once, it proposes business relationships missing between the model’s entities, the designated business key for entities that do not yet have one, or both together, and opens one review of the ranked proposals before anything is saved. It never unsets a business key an entity already has. On the canvas, a separate, physical-layer skill named Discover keys and relationships extends this same family: launched once, it scans the selected tables for primary keys, business keys, and foreign-key-style relationships in any combination you choose, and opens one review of the ranked proposals, with keys and relationships each on their own tab when both ran together. Business keys land on staging tables, or directly on data vault and data mart tables, and a scan that starts from a source table redirects its business-key proposal to the staging table that source feeds. Relationship proposals carry a confidence score and a written reason, and accepting one promotes it across the landing, staging, and persistent staging layers, not only within chat. Enrichment fills in the meaning, drafting entity descriptions, attribute descriptions, and a refined context summary for a model. Schema and catalog analysis works from the technical side: enriching a table’s metadata, analyzing a schema for quality issues, and tracing the downstream impact of a proposed change. Two more canvas skills extend this family too: enrich table and column metadata (now including drafted per-column descriptions, not only the table level), and classify sensitive columns, which proposes sensitivity, personal data, and regulatory classifications for each column. Map and match connects the two sides, proposing which business entity each source table represents and which attribute each column maps to; every proposal is grounded in evidence the catalog already holds, not naming similarity alone. Validation turns the AI into a reviewer: four report-only skills that read the model and change nothing. Validate the Data Vault model reviews a vault for structural faults after you accelerate or reshape it: hubs without sound business keys, links whose grain mixes units of work, satellites hung off the wrong parent, orphaned constructs, naming drift, and missing source coverage, reported as findings ordered by severity. Analyze fast-changing attributes finds satellite attributes that change far faster than the attributes they are grouped with, using measured profiling (distinct cardinality, row counts, null ratios), and recommends satellite splits grounded in those numbers; where profiling is missing, it says so rather than guessing. Check source readiness answers one question per source table before you build loads on it: is this source ready to load? The verdict rests on business keys declared and mapped and key-column nullability; it also reports unmapped column counts and classification coverage as readiness debt. Validate the data mart model checks that every fact declares its grain, that dimensions shared across facts are conformed, that every dimension declares a slowly changing dimension type, and that dimensions stay flat rather than snowflaking; it runs from Ask AI on a dimensional model’s canvas, alongside Suggest dimensions and facts, which proposes fact and dimension roles, the links between them, and missing numeric measures as reviewable actions you apply one by one. All four report; none edits the model. A small set of cross-cutting skills round it out: drafting governed glossary definitions, and an assistant for the data vault canvas. The catalog grows by publishing new skills, not by shipping new releases, so the set a given deployment exposes is exactly the set its admins have published.

Organizations extend the catalog themselves

The published skill catalog is not fixed to what DeltaVault ships. An organization administrator can add a skill of their own under Toolkit, then AI Skills: either a net-new skill built for something specific to that team, or a customization that forks a built-in skill’s published content into the organization’s own editable version. A customization shadows the built-in skill for that organization only, so the platform default keeps serving every other organization untouched. Org-authored skills go through the same publish validation and versioning as platform skills, and every run of one still draws on the organization’s own credits and answers to the same role-based access controls as any other skill run: only organization administrators can author or customize a skill, and running one still gates on the member’s own credit allowance. Wherever skills are listed, a small marker distinguishes an organization’s own skill or customization from the platform catalog, so a team always knows which version of a skill it is looking at.

Context comes from the metadata graph

A skill declares what it reads, and the runtime assembles it from live catalog state. The organization profile (industry, description, naming rules) feeds every call that wants it. On a modeling surface, the active model’s entities, attributes, and relationships inject as a current-model block. The page selection flows into the run: select an entity, a table, or a set of knowledge documents, and that selection both prefills the skill’s pickers and rides along as ambient context. A skill that recommends business domains is shown the domain and model tree that already exists, on the same branch state its writes will land on. That’s why re-running it doesn’t duplicate what’s there.

The map and match skills hold their proposals to the same standard: grounded in what the graph records, not naming similarity alone. When they propose which business entity a source table represents and which attribute each column maps to, table matching weighs names, column shape, row count, and how sibling tables of the same schema were already mapped, and column matching adds measured profiling statistics and the classifications candidate attributes already carry. The skills cite foundation documents as well, bringing the published guidance on business modeling and naming standards into the same prompt, and each rationale names the signals it used: you see why a match was proposed before you accept it.

When a skill creates or enriches a row, it also proposes a compact AI context for that row. The operator reviews the proposal in the accept step, alongside the rest of what the skill is about to write. Every later context-aware run against that row, or against its descendants, inherits the accepted context automatically: a column inherits from its table, a table inherits from its project and its upstream lineage, an entity inherits from its model and its domain. Accepted suggestions compound instead of being re-supplied on every run.

Knowledge documents, and honest allocation

Users upload reference material (glossaries, source documentation, business requirements, domain knowledge) and DeltaVault embeds it for retrieval. At upload time you can pick the type yourself or choose “Let AI decide”: the AI classifies the document, and a genuinely mixed file becomes a split proposal you review before anything enters retrieval. When you choose “Let AI decide” you can also set the Effort for that one classification run, which starts on Quick because classification is light work. Requirements and glossaries are treated as must-honor types, because dropping a requirement silently is worse than dropping a paragraph of background.

Overlapping documents can be consolidated: select two or more and the AI merges exactly those into one canonical version, with a full review before anything is saved and the original sources archived so they stay recoverable. The Consolidate dialog lets you set the Effort for that one merge, starting from your own resolved Effort. On the review screen you can refine the merged result before accepting: “Edit with AI” opens a dialog where you describe the change you want, the AI rewrites the body, and you review the change before applying it.

Documents are not only uploaded and retrieved; they are also edited in place with the same review discipline as the rest of the product. Open a document in its editor and the AI works on the text itself: Refine, Tighten, Expand, Humanize, or follow a custom instruction, applied to a selected passage or the whole document. The suggestion arrives as an inline diff the author accepts or rejects change by change, and nothing is written until they save. The AI rewrite is a proposal, not a side effect, and it never touches the business model. A separate governance check closes the loop back to the model: it cross-references a document against the organization’s business entities and category lanes, then opens a read-only review of which entities and lanes the document covers, what stays unclassified, and where the gaps are, each gap with a deep link to where the author would act. It reports and links; it does not edit the model.

When you select documents for a run, an allocator measures them against the model’s context window and your remaining budget. Documents that fit go in full: completeness guaranteed, with prompt caching so reuse is cheap. Documents that don’t fit degrade to scoped retrieval, visibly. Nothing is ever silently truncated: the per-run context manifest reports each document as full, retrieved, or dropped, with a flag on anything dropped. Tasks too large for one call decompose into a plan of sub-tasks that run durably in sequence, with the whole plan’s cost estimated in credits and gated against your allowance before the first call fires. If a sub-task fails, the result is labeled partial with an explicit gap list.

Chat that routes to skills

The Ask AI panel takes free text. An orchestrator embeds your message, retrieves the closest published skills from a vector index over the catalog, and picks one. Routing stays sharp whether the library holds a handful of skills or two hundred, because the model only ever sees the top candidates. Publishing a skill makes it chat-discoverable by default; opting out is a per-skill switch. Input is not limited to the keyboard: voice dictation is available across the AI input surfaces (the Edit AI Context editor, the Ask AI chat, and the modeling workshop), transcribed in the browser through the Web Speech API so nothing is recorded or sent.

Before you send a message, you can attach context to that turn: the current selection, a snapshot of whatever is selected on the page at that moment, and any number of knowledge documents. Each attachment shows as a chip so you can review it before sending, and what you attach travels into that turn as context alongside your message.

Multi-step flows pause for humans. Ask for domain recommendations and the proposals come back as selectable cards in the thread; the run parks while you pick, then continues with your picks as input: propose models for the three domains you kept, pause again, apply. Spatial proposals (a business model worth seeing as a diagram) hand off to the modeling canvas as a ghost overlay you accept or reject there. No tokens burn while a run waits on you.

On a project or workspace canvas, chat can also propose database views from a plain-language request. The assistant resolves table names against the catalog (never inventing them), asks a clarifying question when the organization’s methodology includes a Data Vault layer and the request reads like descriptive attributes of a business concept (shape it like a satellite of the matching hub, with its business key and a server-computed hash key), and parks the result as a proposal card. Accepting opens the view designer pre-populated; the AI writes nothing, and the view is only created when the user saves it in the designer.

Ask AI can also propose a whole dimension or fact view from an organization’s Data Vault model. Asked for a dimension or fact by business concept, the assistant grounds itself in the vault model: it anchors on the matching hub (or, for a fact, the connecting link), and includes that anchor’s satellites, traversing a link to bring in a second hub and its satellites for a multi-hub dimension. The recommended name follows the organization’s dimension-view or fact-view naming pattern, the layer prefills to Data Mart, and the point-in-time hash-key joins between the anchor and its satellites are derived automatically rather than requested from the model. Accepting still opens the view designer with the anchor, satellites, and joins already placed; column selection stays the user’s step.

On the workspace canvas, chat also answers analysis questions about the tables in front of you. The assistant grounds itself in the workspace’s tables grouped by data layer, with columns, key designations, and the reference edges the canvas already renders, so it can recommend relationships per layer, state the join columns and its reasoning, and separate what already exists from what it proposes. Layer scoping comes from plain phrasing (per layer, or naming one). Acting on a recommendation stays with the modeling workshops; the chat hands off instead of writing to the model. A separate skill in the published skill catalog, Discover keys and relationships, does write: its relationships pass proposes foreign-key-style relationships across a project or a selection on the canvas, and writes each one only when you accept it, promoted across the relational layers.

Writes are proposals, never side effects

A skill that writes runs in preview-then-apply mode: the model’s proposed actions are staged as a plan, and you review each item (edit it, approve it, reject it) before anything is applied. Applied actions run through the same write paths and role-based access control as human edits, and land in the same audit log, so “what did the AI change?” has the same answer surface as “what did Sarah change?”. The domain recommendation skill renders its proposal as a nested checkbox tree of domains and models; apply is a true upsert that matches by name, so accepted recommendations update existing rows instead of duplicating them. On the table screen, one entry point covers enriching a table’s description, business name, and entity link, plus schema-quality and impact analysis, all as reviewable skill runs. The accept step also shows each row’s proposed AI context in an editable field: the operator can trim it, rewrite it, or blank it before anything is applied, and blanking only withholds the proposal: it never overwrites context an operator already stored for that row.

Every run is recorded: the resolved prompts, the model’s output, tokens, latency, and the context manifest. Platform operators can open any production run, inspect the full request and response, and replay its exact inputs against an edited draft skill: debugging AI behavior with evidence instead of guesses. Orchestrated operations that run several skill calls in sequence, such as the modeling workshop, link every step’s run record back to the parent operation, so an operator can trace and replay each step on its own, not just the run as a whole.

The run experience

Click Run and the panel flips to a live view within one round trip: thinking, milestones, and the result stream in as the model works. The skills that force a structured proposal (business domains, business entities, relationships, entity enrichment) reason first: a short streamed reasoning pass shows a readable summary of how the model is working through your catalog, and the structured proposal follows, seeded by that reasoning, so the live view shows genuine reasoning about your metadata rather than a silent wait. The streamed reasoning collapses into a reread-able “Show AI reasoning” disclosure once the proposal lands. Failures are visible on the run itself: an exhausted budget, a credential problem, and a configuration error all show as a failed run with the reason, where the progress was streaming. If a skill that should propose actions answers in prose instead, the panel says so explicitly and shows the text, rather than presenting an empty summary. For skills that propose a variable number of items, you dial the result breadth from Minimal to Comprehensive per run, where Comprehensive returns as many grounded items as the context supports without fabricating to inflate the count. The reference-knowledge picker is scoped: organization documents plus the current project’s, grouped, never another project’s.

Session visibility

Every skill run and chat is a session, and the product surfaces them rather than letting them vanish on navigation. A running-count badge on the Ask AI button shows how many of your runs and chats are still in flight. A history view, opened from the Ask AI drawer header, lists your recent runs and chats grouped by date (Today, Yesterday, This week, Older) with a quick search; opening one re-attaches it to the drawer, a live run resumes its progress view and a finished run or chat reopens to reread or continue. Each chat is auto-named from its first exchange, so the list reads as topics instead of timestamps; a chat from before this shipped still falls back to “Untitled chat.” The history view is read-and-resume: it finds and reopens your activity rather than managing it.

Spend is visible on its own page. The AI Usage page, opened from the credit total in the top bar, charts credit spend over the last 24 hours, 7 days, or 30 days across eight activity categories, and drills from any category to its request list and then to a single request’s cost, down to the individual events that made it up and, for skill runs, the free-text you asked. Administrators can switch between their own usage and the whole organization’s. This makes AI activity both resumable and auditable instead of ephemeral.

Administrators get an organization-wide audit view: the AI Activity page in the Toolkit lists every AI skill run for the organization, including runs a member has cleared from their own panel (shown as cleared), so the record is retained and auditable even after a panel is tidied. Platform staff see the same view for the organization they are working in.

Regions, keys, and budgets

AI configuration is unified in one settings home: Settings, then Artificial Intelligence. The old separate AI credentials and AI budgets pages now open here. The entire section is administrator-lockable: when locked, only administrators can change the AI settings for the organization.

A single Effort dial sets the level every AI task runs at across the organization: Quick, Standard (the default), Deep, or Expert. Each level starts on a platform default model (Quick on Claude Haiku 4.5, Standard on Claude Sonnet 5, Deep on Claude Opus 5, and Expert on Claude Fable 5, the highest-capability tier, where extended thinking is always on); an organization can repoint any level at a different model and give that level its own extended-thinking budget, so a level no longer ties every task in the organization to one unchangeable model. The earlier per-task quality nudges are gone: Effort chooses a level, not a per-task table of exceptions. There is no personal Effort setting shadowing the organization’s: every control opens at the organization’s level. A member can still choose a different level for one run from the AI surface they are working on (the skill-run form, the Ask AI chat, the inline edit-instruction line, the Discovery, Workshop, and Model review launch forms, and the Map and match panel). On a skill-run form the picker starts pre-set to the skill’s own default effort; the choice applies to that run only and is not remembered afterwards. The order is simple: the level picked for this run, otherwise the skill’s own authored default, otherwise the organization default, otherwise Standard. A skill’s authored default outranks the organization default deliberately, because it is administrator-set configuration rather than a stale personal choice, so a heavyweight skill authored as Deep never quietly runs Quick. The organization default keeps its editor permission and administrator lock, while a single-run choice needs neither, because a higher Effort only spends that member’s own credits faster and the existing per-member credit check still gates every run.

An organization can pin AI inference to a geographic region with one setting. The Australia region routes calls through Amazon Bedrock in Sydney, using inference profiles that keep requests inside Australian geography. The guarantee is fail-closed: a regional organization’s AI either runs in its region or fails with a clear, actionable error. It never falls back silently to global infrastructure. Embeddings are the disclosed carve-out: they and the vector-search features built on them stay global, and the settings say so explicitly.

Credentials work both ways. DeltaVault can serve a region on platform credentials, or you bring your own: an Anthropic key, or Amazon Web Services credentials for a regional account. Keys are validated with a live call before saving (a typo fails in the dialog, not on your next AI run), encrypted at rest, and only ever shown as a fingerprint. Usage on your own key bills directly to your provider account and is not capped by the platform.

On platform credentials, spend is governed in one unit: credits. Every AI operation is metered in credits, where one credit is one cent of underlying provider list cost, so a discovery run and a modeling run compare on the same scale and no token counts or dollar figures surface in the product. An organization running on platform credentials has a monthly credit allowance per member allowance tier plus concurrency limits, with a live credit estimate shown before an operation runs; that estimate is effort-priced (Quick, Standard, Deep, and Expert each cost more as the model gets more capable) and, for the published skills, calibrated from real run history once there is enough of it. The organization-configured allowance is clamped under the platform ceiling when running on the platform key; that clamp does not apply when the organization supplies its own provider key. A ten percent buffer absorbs the crossing past the allowance so a run in progress is not cut off, and once the buffer is spent the next operation is blocked with a clear notice rather than a silent failure. Decomposed runs estimate the whole plan up front in credits: you are told what a run will cost and offered the chance to narrow scope, instead of discovering the cost halfway through. When more is needed, an organization administrator can buy one-time credit top-up packs through hosted checkout, or the DeltaVault team grants credits directly; top-up credits carry over past the monthly allowance reset. Spend is also visible after the fact: a usage page graphs credit spend over time and drills from a category, to its individual requests, to a single request’s recorded cost detail.

The credit machinery is platform-credential machinery, and it stops at the boundary. An organization running on its own provider key is billed by that provider directly: no DeltaVault allowance, no buffer, no monthly reset and no top-up packs, because there is nothing of ours for it to draw down. The free edition is the case where that matters most, because a free organization supplies its own key by design.

Choosing a model

The Effort dial names a level of capability, not a single unchangeable model. A platform-curated catalog tracks every model DeltaVault can run, refreshed by a daily sync against the model gateway: a newly released model appears in the catalog automatically, arriving switched off until a platform operator turns it on, so adopting a new model release needs a decision, not a deploy. Every model the platform switches on is available to an organization by default, and an organization administrator can narrow that list with one toggle per model, or leave it wide open; turning a model off removes it from every picker in that organization at once.

An organization can also repoint which model answers each Effort level for everyone it runs for, choosing per level whether to keep the platform default or a different model, with its own extended-thinking budget where the model supports one. Pinning a run to one specific model is a platform-admin affordance rather than a tenant one: the AI Playground’s test panel can override the model for a single test run, and no tenant-facing surface offers that choice. Everywhere else the model follows the organization-then-platform chain above. Effort keeps its original job regardless of which model answers: it sets how hard that model reasons.

Billing follows whichever model actually answers. Every catalog model carries a price, synced from the gateway or set directly by a platform operator, and the estimate shown before a run prices the model that pick resolves to, not a generic placeholder. A model without a price on file still runs rather than being blocked; it bills at a conservative fallback rate until a real price is added.

Conventions steer every modeling skill

Modeling conventions are organization state, not prompt folklore. The categories, naming convention, and classification schemes an organization defines under Settings, Conventions are injected as a first-class context layer into every conventions-relevant AI skill: entity and domain recommendations, relationship suggestions, enrichment, the business modeling workshop’s discovery and judge passes, relationship discovery, tweak chat, knowledge governance and glossary extraction, column classification, and classification propagation. Model review runs a dedicated category conformance dimension that judges every entity’s lane assignment against the organization’s own definitions, and Ask AI’s entity listings carry each entity’s category so conversations start from the organization’s classification, not a generic taxonomy.

The wiring is visible and governable: each skill’s Context tab in the Playground carries three per-skill conventions toggles (categories, naming convention, classifications), the test runner previews the exact rendered text the model receives, and proposals arrive born compliant: workshop discovery names every proposed entity per the organization’s naming convention, and classification suggestions are bounded to the organization’s own schemes, including custom ones.

Why it matters

The plumbing this replaces is invisible until you total it up. Without an integrated layer, using AI on your metadata means exporting context by hand (pasting schemas and requirements into a chat window, hoping you pasted enough), then copying the answer back out and reconciling it with the catalog manually: checking for duplicates, re-keying names, updating descriptions one field at a time. Nobody audits that workflow, nobody budgets it, and the context that shaped each answer evaporates when the chat tab closes.

In DeltaVault the user manages the decision, not the transfer. The AI reads the catalog state itself; you review a proposal where the data lives and approve the parts you want. The context manifest replaces “hope I pasted enough” with a record of exactly what the model saw. The audit log replaces “who changed this?” archaeology. The budget gate replaces the surprise invoice. What’s left for the human is the part that was always theirs: deciding whether the proposed domain structure is actually right for the business.

Category contrast

Catalog-first tools that added a chat panel treat AI as a query interface: the chat reads the catalog, answers, and stops. Writes either don’t exist or bypass governance entirely, and there’s no record of what context produced an answer. DeltaVault’s AI writes back, through the same gates as humans, with the context disclosed per run.

Code-first transformation frameworks put AI assistance in the editor, which helps the person typing but governs nothing: prompts live in individual workflows, every team wires its own model calls, and there’s no shared library, budget, or residency posture. DeltaVault centralizes the skill library, the spend controls, and the region pin at the organization level.

Standalone governance suites generate recommendations into a queue detached from where modeling happens; accepting one means re-doing the work in another tool. DeltaVault’s proposals apply in place, because the AI and the model share one store.