Atlas AI Co-pilot

Atlas is a warehouse-grounded AI assistant built into the dbdeux editor. It understands your schema, models, and active context to provide relevant suggestions, explanations, and code generation without leaving the IDE.

stg_orders.sql

SELECT

order_id,

customer_id,

{{ ref('dim_customers') }}

FROM {{ source('raw', 'orders') }}

✦ Atlas AIGrounded

Ask about your code...

Overview

Atlas lives in a resizable side panel next to your code editor. Click the floating AI button on the right edge (drag it to reposition) to open it. Everything you ask is grounded in your actual workspace: the active file, cursor position, connected database, and schema context.

Atlas focuses exclusively on your code and data. It answers questions about SQL, dbt models, Jinja templates, YAML configuration, and data modeling. Off-topic questions receive a polite redirect.

How Atlas Reads Your Context

When you ask a question, Atlas automatically gathers context from your editor before responding:

📄

Active File

Reads your open model

→

📍

Cursor Position

Knows where you are

→

🗄

Schema Context

Tables, columns, types

→

✦

Atlas Response

Grounded suggestion

This context grounding means Atlas gives answers specific to your code and your schema, not generic advice.

See Exactly What Atlas Is Reading

Above the chat input, a row of grounding chips shows the context in play right now. Hover any chip and it tells you, in plain language, precisely what that piece of context contributes:

Chip	What it tells you
Active model or file	The model Atlas is centered on, its column count, and its place in your lineage. If the open file is not a dbt model, the chip names the file instead and explains that Atlas is grounding on the file itself plus your project and warehouse context
Columns	The live warehouse columns Atlas can see for the current model, listed by name
Lineage	The exact upstream and downstream models Atlas is aware of
Connection	The warehouse connection Atlas is reading live schema from
Metrics	The governed metrics from your published Semantic Layer that Atlas will answer with

A refresh control next to the chips re-reads your context on demand, so if you have just added a column or switched connections you can bring Atlas up to date without restarting the conversation.

Most AI assistants ask you to trust an invisible context window. Showing the grounding, naming its contents, and letting you refresh it turns "why did it answer that?" into something you can check in a second.

Attach the Files and Folders You Want Considered

Automatic grounding covers the file you are in. When a question spans more of the project, pin the rest of it yourself. Click the @ control above the chat input to attach:

• Individual files, for example the staging model plus the mart that consumes it
• Whole folders, which brings in every text file underneath so "review my staging layer" means what you would expect it to mean

The picker lists the name first, with the folder it lives in underneath, so orders.sql reads as orders.sql rather than as the tail of a long path you have to scan character by character. Hover any row for the full path when two files share a name. The list is wide enough that real project paths are not truncated mid-folder.

Attached items appear as chips you can remove one at a time or clear in one go, and they stay attached across turns, so a follow-up question keeps the same reading material instead of forgetting it. A search box lists your project's files and folders so you do not have to remember exact paths.

Attachments are resolved when you send the message, so Atlas always reads the current state of those files, including edits you have not committed yet. Attachments are capped so a large folder cannot crowd out your actual question, and files that are too long are trimmed with a clear marker rather than silently cut.

This is the difference between an assistant that guesses at your project and one that reads the parts you know matter. You decide what is in scope, you can see it listed, and you can change it at any point in the conversation.

Starting a Clean Conversation

New session clears the current conversation and returns focus to the input so you can start typing immediately. It gives you the same visible response whether or not there was anything to clear, so there is never any doubt about whether the reset actually happened.

Capabilities

Context-Aware Assistance

• Active file awareness: Knows which file you have open and where your cursor is
• Schema grounding: Understands your connected database, schemas, and table structures
• Metric grounding: When the Semantic Layer is enabled, Atlas also reads your governed metric definitions (names, expressions, dimensions) so answers are consistent with your shared metric layer
• dbt-aware: Understands refs, sources, macros, tests, and the dbt project structure
• Focused diffs: When suggesting changes, shows only the relevant snippet, not the entire file

What Atlas Can Do

Task	Example
Explain code	"What does this model do?"
Generate SQL	"Write a query to find duplicate orders"
Debug errors	"Why is this test failing?"
Suggest improvements	"How can I optimize this join?"
Write tests	"Generate a uniqueness test for order_id"
Jinja help	"Convert this to an incremental model"
Schema questions	"What columns are in the orders table?"
Multi-file changes	"Rename this column and update everything that references it"
Define a metric	"Define a governed revenue metric on the orders model"
Review a folder	Attach models/staging/ and ask "are these models consistent with each other?"

Code Blocks

Atlas responses include syntax-highlighted, copyable code blocks. Code is tagged with the correct language (SQL, YAML, Python, Jinja) for proper formatting.

Agent Mode: Changes Across Multiple Files

Some requests, like renaming a column or refactoring a model, touch more than one file. In agent mode, Atlas plans the change across your project, reads every file it intends to edit, and then proposes a complete, reviewable changeset.

A

Rename customer_id to customer_key in dim_customers and update everything that references it.

Reading project files

○models/marts/dim_customers.sql

○models/staging/stg_orders.sql

○models/schema.yml

Proposed changes · review before applying

models/marts/dim_customers.sql+6-2Apply

models/schema.yml+9-0Apply

Atlas proposes edits and grounds them in your lineage. Nothing is written until you apply each file.

How it works:

1. Plan and read: Atlas finds the relevant files (models, their schema.yml, macros, and downstream refs) using your dbt lineage, and reads each one before proposing anything
2. Propose a changeset: Atlas returns the full new content for each file it wants to change, grouped into one reviewable set, along with a short summary of what changed and what to double-check
3. Review and apply: You review each proposed file and apply the ones you want, right in the chat panel

Two guardrails make this safe to use on real projects:

• Nothing is applied automatically. Atlas never writes to your files on its own. Every edit is a proposal until you apply it
• Grounded in your lineage. If a column or model is referenced downstream, Atlas includes those files in the changeset or explicitly warns you that they need follow-up, so a rename does not silently break dependents

New Files Are Created for You

A proposed change often needs a file that does not exist yet: a new staging model, or the schema.yml that documents it. Applying the changeset creates those files, and any folders they need, on the branch you are working on. Files that already exist are updated in place.

The review step does not change. You still see the full proposal first and nothing is written until you choose Apply, so the only difference is that you no longer have to create an empty file by hand before Atlas can fill it in.

Quick Actions

Atlas offers context-aware quick actions so common tasks are one click instead of a hand-written prompt. Based on your active model and grounding context, you may see actions such as:

• Explain the current model, or trace its lineage
• Generate tests grounded in the model's real columns, types, and lineage, written in modern dbt syntax (see below)
• Document columns for models that are missing descriptions
• Review changes on your current branch
• Fix an error: paste an error message and Atlas explains the root cause and gives you a minimal fix
• Define metric: describe a business metric in plain language and Atlas drafts its governed definition, consistent with your metric layer

Quick actions also appear as handoffs from other surfaces. For example, a documentation gap in the Atlas Catalog coverage scorecard can open the model file and start a grounded documentation request in one click.

Modern dbt Syntax

AI assistants trained on years of public examples happily hand you dbt YAML that dbt has since deprecated, and you only find out when your build starts printing warnings. Atlas is held to your dbt version instead:

• Tests are written with data_tests: rather than the legacy tests: key
• Parameterized tests (accepted_values, relationships, dbt_utils tests, and the rest) nest their parameters under arguments:, with only configuration keys such as name, severity, and where left at the test level. On projects running an older dbt version, Atlas keeps the inline form that version expects
• Settings go in config: blocks instead of deprecated top-level properties

The result is generated YAML you can commit as-is, rather than code that works today and warns tomorrow.

AI Model

Atlas is ready to use out of the box with no configuration needed. It runs on a managed AI model selected for the best balance of speed and quality, so there is nothing to set up or configure. Just open the panel and start asking questions.

Clean Chat Interface

The Atlas panel uses a streamlined chat interface focused on your conversation. The input area and message list fill the panel with no unnecessary controls. This keeps the focus on your questions and answers.

Performance

Atlas is optimized for fast, responsive interactions:

• First turn: Atlas gathers context from your active file, project, and schema. This may take a moment on the first question
• Follow-up turns: Subsequent questions in the same session stream immediately with minimal latency
• File switching: Changing the active file refreshes context automatically so answers stay relevant

Session Management

Atlas maintains conversation sessions so you can return to previous discussions:

• New session: Start a fresh conversation with the + button
• Session history: Browse and reopen previous sessions via the history icon
• Session titles: Auto-generated from the first message for easy identification
• Persistent context: Each session remembers its full conversation history

AI Usage and Budgets

Atlas usage is tracked at the organization level. Admins can set monthly spending limits and view usage breakdowns by user and feature in Organization Settings.

When a budget limit is reached, Atlas lets you know and pauses AI responses until the next cycle or until an admin adjusts the limit.

Privacy and Security

• No training: Your code and queries are not used to train any AI models
• Secure inference: AI requests are processed securely and never stored beyond the active session
• Organization-scoped: Each organization has independent usage tracking and budgets
• Content safety: Atlas includes built-in content filtering for safe, professional responses

Keyboard Shortcuts

Shortcut	Action
Click the AI button	Toggle Atlas panel
Enter	Send message
Shift + Enter	New line in message

How It Compares

Capability	Atlas AI	GitHub Copilot	Standalone AI tools
Schema grounding	Reads your actual warehouse tables, columns, and types	No warehouse awareness	No warehouse awareness
dbt awareness	Understands refs, sources, macros, tests, and project structure	Generic code completion	Generic - no dbt context
Active file context	Knows your open file, cursor position, and surrounding code	File-level context	Copy-paste only
Metric grounding	Uses your governed metric definitions for consistent answers	Not available	Not available
Context transparency	Every piece of context is a visible chip you can hover to inspect, and refresh on demand	Hidden context window	Hidden context window
Context control	Pin specific files or whole folders to the conversation, visible as removable chips	Manual copy-paste per question	Manual copy-paste per question
Setup	Ready to use out of the box, no configuration	API key + extension install	API key + browser tab
Code generation	Generates dbt-specific SQL, YAML, Jinja, and tests	General code suggestions	General code generation
Multi-file changes	Proposes a reviewable changeset grounded in lineage; nothing applied automatically	Single-file suggestions	Copy-paste, no project awareness
Privacy	Code never used for training, scoped to your org	Opt-out required	Varies by provider