Skip to main content

Atlas v1.4: Security Scanning, Database Profiler, Agent Skills, Drift Detection, and More

· 37 min read
Ariel Mashraki
Building Atlas

Hey everyone!

We're excited to announce Atlas v1.4. This release brings security scanning to your databases: the new atlas security scan command reports the CVEs affecting your database servers and extensions, from the CLI, CI, or Kubernetes. It also introduces agent skills, a profiler for the Atlas testing framework that works on production-like data, and drift checks between deployments.

Here is what you can find in this release:

  • Security Scanning for Databases - Vulnerability detection for your database servers and extensions with atlas security scan, from CI to Kubernetes, and blast-radius checks for roles.
  • Atlas Agent Skills - Teach Claude Code, Codex, Cursor, and GitHub Copilot to plan, lint, and test schema changes with Atlas.
  • Profiler for the Testing Framework - Measure the locks, rewrites, and space of migrations, queries, and database code, over a masked Amazon RDS snapshot, CSV files, or synthetic rows. In preview.
  • Drift Detection Between Deployments - atlas migrate drift reports every object that diverged from your migrations, for one database or every tenant.
  • Schema Repositories in Your Own Storage - Store schema repositories in your own S3, GCS, or Azure Blob Storage bucket, or an OCI registry, instead of Atlas Cloud.
  • Database Driver Improvements - Snowflake governance policies, SQL Server linked servers and filegroups, PostgreSQL temporal keys, Databricks metric views, Redshift datashares, and more.
  • Atlas Binaries Are Moving to atlasbinaries.com - Starting December 2026, release.ariga.io redirects to atlasbinaries.com. Direct downloads only need the new hostname.

To download and install the latest release of the Atlas CLI, simply run the following in your terminal:

curl -sSf https://atlasgo.sh | sh

Security Scanning for Databases​

Which of your databases run a version with a published CVE? Answering that means querying every database, across staging, production, and every region, for its server and extension versions, then looking each one up in the advisories for its engine and extensions. And it is not a one-time check: new CVEs are regularly published for versions that are already running.

The new atlas security scan command answers this question in one run. It resolves the server version and the installed extensions of each database against the Atlas Security Graph, and reports every CVE that affects them, with its severity and the release that fixes it:

atlas security scan \
--url "postgres://postgres:pass@localhost:5432/app?sslmode=disable" \
--url "clickhouse://default:pass@localhost:9000" \
--url "postgres://postgres:pass@localhost:5433/reporting?sslmode=disable"
Scanning 3 databases for security issues:

-- postgres://postgres:xxxxx@localhost:5432/app?sslmode=disable (postgres 18.6):
-- Extension "vector" version "0.8.5" is vulnerable to CVE-2026-103484 (HIGH): pgvector
buffer overflow in IVFFlat index build. Upgrade extension "vector" to version 0.8.7 or
later to resolve CVE-2026-103484
-- Extension "vector" version "0.8.5" is vulnerable to CVE-2026-18022 (HIGH): pgvector
buffer overflow via integer wraparound in IVFFlat index build on 32-bit systems. Upgrade
extension "vector" to version 0.8.6 or later to resolve CVE-2026-18022

-- clickhouse://default:xxxxx@localhost:9000 (clickhouse 23.10.5.20):
-- Engine "clickhouse" version "23.10.5.20" is vulnerable to CVE-2024-22412 (ELEVATED):
ClickHouse's Role-based Access Control is bypassed when query caching is enabled. Upgrade
database engine "clickhouse" to version 23.12.6.19 or later to resolve CVE-2024-22412
-- Engine "clickhouse" version "23.10.5.20" is vulnerable to CVE-2026-116366 (CRITICAL):
Unauthenticated RCE vulnerability against ClickHouse Server. Upgrade database engine
"clickhouse" to version 26.3.62.3 or later to resolve CVE-2026-116366

-- postgres://postgres:xxxxx@localhost:5433/reporting?sslmode=disable:
-- postgres: querying system variables: dial tcp [::1]:5433: connect: connection refused

-------------------------
-- 1.061387208s
-- 1 database could not be scanned
-- 4 issues found: 1 critical, 2 high, 1 elevated

A database that could not be reached is reported with the rest and fails the command, since its state is unknown. For a recent example, see ClickHouse CVEs: Find Vulnerable Servers with Atlas.

The same vulnerability detection runs before a change merges during the lint check, together with an access check that flags roles whose blast radius covers a large share of the database.

Also new with the scan:

  • Engine-specific detection: PostgreSQL, MySQL, MariaDB, ClickHouse, and SQL Server. On PostgreSQL, the installed extensions are checked too.
  • Gating and notifications: findings fail the command only at the fail_on severity level, and a notify block posts the result to Slack.
  • On a schedule: the security/scan GitHub Action, and the AtlasSecurityScan resource of the Kubernetes Operator, whose Compliant condition works as a deployment gate.
  • Security Dashboard: every finding across your repositories and monitored databases in one list.
Security Issues page in Atlas Cloud filtered to critical issues

The Security Issues page, filtered to critical findings

Security scanning is part of Atlas Pro and requires the Security Graph in your plan. Run atlas login to get started.

To learn more, see the security scanning guide.

Atlas Agent Skills​

An agent can edit schema files the way it edits code. A migration is different: it needs the dependency order of every object, it has to pass your lint policies, and the same change must produce the same migration regardless of which model generated it.

For this reason, the Atlas agent skills do not teach agents to write migrations. The agent edits the desired state, Atlas plans the migration, and the change is linted and tested before the agent reports it done:

Install the skills from a terminal. It installs the Atlas plugin, with all its skills, for every project on this machine.

claude plugin marketplace add ariga/atlas
claude plugin install atlas@ariga

Then start the onboarding skill in Claude Code. See Claude Code with Atlas for the other ways to use the skills.

/atlas:atlas-onboard

The installation includes:

  • atlas: the core workflow, from inspect and plan to lint, test, and apply.
  • atlas-onboard: guided onboarding, from no Atlas setup to production. It never applies to production: you run the first deployment.
  • Database skills for PostgreSQL, MySQL, SQL Server, ClickHouse, Snowflake, Databricks, Redshift, Oracle, and Spanner.
  • atlas-operator for Kubernetes, and atlas-action for CI/CD.

Checking a change before reporting it done is what Anthropic calls a verification loop, and an example it notes of a check worth capturing is a migration rule: "Reject any migration that drops a column without a backfill step."

With Atlas, you don't need a prompt for this. Lint fails a migration that drops a column unless you allow it explicitly, and the skills do not let an agent skip a lint error without your approval. You can further define project-specific rules as custom lint rules, which Atlas enforces just the same.

To learn more, see the agent skills documentation, and The AI-Native SDLC Playbook Stops at the Database for why an agent should compute a migration plan and not generate one.

Profiler for the Testing Framework​

In the agentic SDLC that Anthropic lays out in its AI-native SDLC playbook, Stage 4 has the best rule: "Always give Claude a way to verify its own work, whether tests, a build, or a screenshot diff." The agent iterates until the check passes, before a human sees anything.

What is that check for a database change? A test may pass in CI, but unless it runs over production-like data, there is no way to measure the impact of the change.

As we wrote in our post about the playbook, nearly every dangerous migration run on an empty dev database seems passable. Every lock is short, and there is not much for a statement to scan or rewrite. The cost of a statement depends on the size of the table it runs on, and reading the SQL rarely shows it.

As our initial response to that recommendation, this release adds datasets and a profiler to the Atlas testing framework:

  • A dataset gives a test production-like rows: either loaded, sampled, and masked from an Amazon RDS snapshot or CSV files, or generated from the schema.
  • The --profile flag profiles every statement the tests run against that data, in migrations, queries, functions, procedures, and triggers. For each statement, it reports the locks it takes and how long it holds them, the tables it rewrites, and the disk, log, and temporary space it uses.
Preview Feature

The profiler and datasets are in preview and open to a subset of Teams and Enterprise customers. To get access, reach out through your Atlas support channel or message us on Intercom.

For example, this migration adds a column to the orders table and fills it in one statement:

migrations/20261104093012_add_orders_digest.sql
ALTER TABLE orders ADD COLUMN digest text;
UPDATE orders SET digest = md5(note);

The test migrates to the version before it, generates 2,000,000 orders, and then applies the new version over them:

migrate.test.hcl
dataset "synthetic" "orders" {
table "public.orders" {
rows = 2000000
}
}

test "migrate" "20261104093012" {
# Migrate to one version before the profiled version.
migrate {
to = "20261103101500"
}
# Generate the rows.
dataset {
use = dataset.synthetic.orders
}
# Apply the profiled version over the generated rows.
migrate {
to = "20261104093012"
}
}

Add --profile to the test command, and Atlas prints a profile after the result of each test case. The output is abridged:

atlas migrate test --dev-url "docker://postgres/18/dev" --profile .
migrate#3 20261104093012                9.84s
rows public.orders 2,000,000 updated
read public.orders 2,000,000 rows, 1 sequential scan
size public.orders 185.3MB -> 432.0MB (+246.7MB)
log 721.3MB written, 721.3MB while the statements ran
! lock public.orders: takes AccessExclusiveLock for 9.842s, 9.806s of it after the statement, blocking reads and writes (20261104093012_add_orders_digest.sql:1)

Lines that start with ! are findings: statements that would block or slow down production. Notice two things here:

  1. It points at line 1, the ALTER, and not at the UPDATE.
  2. Of the 9.842 seconds the lock is held, 9.806 come after that statement is done: PostgreSQL keeps a lock until the transaction ends, so reads and writes on orders stay blocked while the UPDATE fills 2,000,000 rows.

In a diff, these are two statements that look harmless. In the full report, each finding is followed by why it matters and a safer way to write the statement.

This is a verdict an agent can act on inside the session, the same way it acts on a failing test. The atlas skill already asks for it: for a change that reads or writes a large table, the agent seeds the test with a dataset, runs it with --profile, and fixes the statements the report flags before it reports the change done.

The same flag works with atlas schema test, where it profiles the queries, functions, procedures, and triggers the tests run:

atlas schema test --dev-url "docker://postgres/18/dev" --url "file://schema.hcl" --profile .

Profiling is currently supported on PostgreSQL, MySQL, MariaDB, and SQL Server, and will expand to more databases in upcoming releases.

Test Data: Amazon RDS Snapshots, CSV Files, or Synthetic Rows​

A profile measures the rows the test holds. A dataset block defines those rows, and a dataset command in a test case loads them. Every migration and assertion after the command runs over them.

A dataset reads an Amazon RDS snapshot or a directory of CSV files, or generates rows from the schema, as it did for the 2,000,000 orders above:

An rds_snapshot dataset loads an Amazon RDS snapshot that was exported to S3:

schema.test.hcl
dataset "rds_snapshot" "prod" {
src = "s3://backups/exports/prod-2026-10-13/appdb?region=us-east-1"
exclude = ["analytics.events*"]
}

Atlas reads the export with your AWS credentials and loads the tables in foreign-key order, keeping their primary keys, so joins and new inserts behave as they do in production. The exclude pattern skips the events log and its partitions.

A test rarely needs the whole export. A sampler loads part of each table, plus every row that part references, so no foreign key is left dangling:

  • head and tail load the first or last rows of each table.
  • random loads rows drawn at random.
  • composite picks a sampler per table.

Here, the events table gets 10,000 random rows, plans loads in full, and every other table gets its first 100 rows:

schema.test.hcl
sampler "random" "large" {
rows = 10000
}

sampler "head" "first" {
rows = 100
}

sampler "composite" "prod" {
table {
match = ["analytics.events"]
use = sampler.random.large
}
table {
match = ["billing.plans"]
all = true
}
table {
match = ["*"]
use = sampler.head.first
}
}

The snapshot holds real customer data, but the test database runs on a CI runner or a laptop. mask blocks rewrite the columns you select before the dataset writes them, so raw values never reach the test database. A dataset names the sampler and the masks it applies:

schema.test.hcl
mask "names" {
columns = ["billing.users.full_name"]
method = HASH
salt = var.mask_salt
}

mask "customers" {
columns = ["billing.tenants.display_name"]
method = PARTIAL
keep_left = 1
}

mask "tickets" {
columns = ["billing.support_tickets.body"]
entities = [ALL]
}

mask "pii" {
use = [mask.names, mask.customers, mask.tickets]
}

dataset "rds_snapshot" "masked" {
src = "s3://backups/exports/prod-2026-10-13/appdb?region=us-east-1"
include = ["billing.*"]
sampler = sampler.composite.prod
masks = [mask.pii]
}
  • names hashes with a salt, which gives a value the same digest in every table, so masked values stay unique and joinable. The salt is a secret: the project file reads it from the environment and passes it to the test file as an input variable.
  • customers keeps the first character of each display name and masks the rest.
  • tickets replaces the emails, phone numbers, card numbers, and IP addresses found in free text and keeps the rest of the text.
  • pii groups the three, so the dataset applies them with one reference.

With the tickets mask, a ticket that reads Login fails for ada.lovelace@globex-001.example.com since this morning. is loaded as Login fails for <EMAIL> since this morning.

Which one to use, a snapshot or synthetic rows?​

When the cost depends on how many rows a statement touches, such as the time an index build or a backfill holds a lock, generated rows at production scale measure it about as well as real ones. The difference is in the values:

  • A synthetic dataset holds the values you thought to write. It runs anywhere without production access, and can hold cases production does not have yet.
  • A snapshot holds the values you did not think of: NULLs in a column a migration makes NOT NULL, duplicates under a new unique index, the skew that decides a query plan, and the row widths that decide how much a rewrite writes.

The two work well together: synthetic data on every pull request, where the job holds no production credentials, and a masked snapshot on a schedule or before a risky change.

note

A sample is only part of the table. A profile over it measures only the rows it holds, and can miss the one row that breaks a new constraint. When either matters, load the full table.

To learn more, see the profiling and testing with data documentation.

Drift Detection Between Deployments​

In v1.3, we added a check that blocks a deployment when the database has drifted from its migrations. The new atlas migrate drift command runs the same comparison between deployments, from a cron job or a CI pipeline, and reports every object that diverged:

atlas migrate drift --env prod
Output
Drift Status: DRIFTED
-- Current Version: 20260423120000
-- Expected State: atlas://my-app (registry)
-- Pending Files: 0
-- Changes: 3 (1 extra, 1 missing, 1 modified)
-- Objects: 3 tables
-- Fingerprint: 28274a91e01d

--- expected state (version 20260423120000)
+++ actual state (postgres://localhost:5432/app)
@@ -1,7 +1,8 @@
CREATE TABLE "authors" (
"id" integer NOT NULL,
"name" text NOT NULL,
"email" text NULL,
+ "nickname" text NULL,
PRIMARY KEY ("id")
);
+CREATE INDEX "authors_name" ON "authors" ("name");

The database diverged from the expected state as if the following were executed:

-- modified table "authors":
-> ALTER TABLE "authors" ADD COLUMN "nickname" text NULL;
-> CREATE INDEX "authors_name" ON "authors" ("name");
-- missing table "logs":
-> DROP TABLE "logs";
-- extra table "audit":
-> CREATE TABLE "audit" ("id" integer NOT NULL, PRIMARY KEY ("id"));
Error: database state does not match expected state at version 20260423120000

The command never changes the database, and exits with status 1 when drift is found, so a scheduled job fails on drift without parsing the output. The same check also runs:

Anthropic's playbook closes its loop the same way: "A deterministic script watches production and invokes Claude when a control band is breached." For the database, the metric is drift: the exit status of atlas migrate drift is the breach, and its report is what the agent starts from.

Drift detection is part of Atlas Pro; run atlas login to get started. To learn more, see the drift detection documentation.

Self-Hosted Schema Storage​

Schema repositories in the Atlas Registry can now be stored outside Atlas Cloud, in your own blob storage bucket or OCI registry. Set url in the repo block of a schema, and Atlas pushes schema states and plans there and resolves atlas:// references against it:

atlas.hcl
env "prod" {
url = getenv("DATABASE_URL")
dev = "sqlite://dev?mode=memory"
schema {
src = "file://schema.sql"
repo {
name = "app"
url = getenv("ATLAS_REGISTRY_URL")
}
}
}

The URL points to an AWS S3, Google Cloud Storage, or Azure Blob Storage bucket, or an OCI registry. Buckets authenticate with the provider's standard credentials. An OCI URL carries its credentials, so read it from an environment variable or a secret store, never as a literal in atlas.hcl:

atlas schema push --env prod
Output
Schema: app
-- Atlas URL: atlas://app
-- Registry URL: oci://ghcr.io/org/atlas-registry

The schema lands in the OCI registry, not in Atlas Cloud. Plans and deployments work as before: atlas schema plan writes plans to the URL, and atlas schema apply --to atlas://app runs the approved plan it finds there. Backup repositories work alongside the URL, and reads fall back to them when the URL cannot serve them.

Commands that use the repository still require atlas login. To learn more, see Storing Schemas Outside Atlas Cloud.

Database Driver Improvements​

Beyond the headline features, this release includes enhancements across the supported engines:

Snowflake​

Snowflake had the busiest cycle. Coverage grew from tables and warehouses to the policies and network objects that govern them:

Masking, projection, aggregation, and join policies join row access policies as first-class resources:

schema.sf.hcl
masking_policy "MP_SSN" {
schema = schema.PUBLIC
arg "VAL" {
type = VARCHAR(100)
}
return = VARCHAR(100)
as = "'***'"
exempt_other_policies = true
}

projection_policy "PP" {
schema = schema.PUBLIC
as = "PROJECTION_CONSTRAINT(ALLOW => FALSE)"
}

aggregation_policy "AP" {
schema = schema.PUBLIC
as = "AGGREGATION_CONSTRAINT(MIN_GROUP_SIZE => 11)"
}

join_policy "JP" {
schema = schema.PUBLIC
as = "JOIN_CONSTRAINT(JOIN_REQUIRED => TRUE)"
}

Attach them to a table or a column with a policy block labeled by kind. Atlas alters a policy in place where Snowflake allows it, and recreates it where it does not.

Snowflake also gains:

SQL Server​

SQL Server gains the objects that sit around a database, and joins the lineage graph:

Linked servers and their login mappings are declared as linked_server blocks. Objects that read through one are created after it and dropped before it:

schema.ms.hcl
linked_server "warehouse" {
provider = "MSOLEDBSQL"
data_source = "warehouse-db"
catalog = "sales"
login {
use_self = true
}
}
view "order_ids" {
schema = schema.dbo
column "id" {
null = false
type = int
}
as = "SELECT [id] FROM OPENQUERY([warehouse], 'SELECT id FROM sales.dbo.orders') AS [q]"
depends_on = [linked_server.warehouse]
}
procedure "count_orders" {
schema = schema.dbo
lang = SQL
as = "EXECUTE ('SELECT COUNT(*) FROM sales.dbo.orders') AT [warehouse];"
depends_on = [linked_server.warehouse]
}
synonym "orders" {
schema = schema.dbo
object = "[warehouse].[sales].[dbo].[orders]"
}

The remote password of a login mapping is write-only: Atlas plans it, but never inspects or compares it.

SQL Server is also covered by the security scan and the profiler. If you are moving a database to PostgreSQL, see the SQL Server to PostgreSQL guide.

PostgreSQL​

PostgreSQL gains temporal keys from version 18, and finer control over role memberships and default privileges:

Temporal keys enforce uniqueness and referential integrity over time ranges: WITHOUT OVERLAPS on primary keys and unique constraints, and PERIOD on foreign keys:

schema.pg.hcl
table "parent" {
schema = schema.public
column "id" {
null = false
type = int
}
column "validity" {
null = false
type = tsrange
}
primary_key {
columns = [column.id, column.validity]
type = GIST
without_overlaps = true
}
unique "parent_key" {
columns = [column.id, column.validity]
type = GIST
without_overlaps = true
}
}

table "child" {
schema = schema.public
column "parent_id" {
null = false
type = int
}
column "validity" {
null = false
type = tsrange
}
foreign_key "child_parent_fkey" {
columns = [column.parent_id, column.validity]
ref_columns = [table.parent.column.id, table.parent.column.validity]
period = true
}
}

A temporal key is always backed by a GiST index, so type = GIST may be omitted when authoring.

Atlas also keeps an explicit index operator class that PostgreSQL would not pick for the column on its own, such as text_ops on a citext column.

Databricks​

Databricks gains metric views and tags, and plans struct changes that used to fail:

A metric view is a view block with metrics = true, whose as attribute holds the YAML definition:

schema.hcl
view "revenue_metrics" {
schema = schema.retail_analytics
metrics = true
comment = "Revenue KPIs by region and day"
as = <<-SQL
version: 0.1
source: retail_analytics.orders
dimensions:
- name: region
expr: region
- name: order_day
expr: DATE(placed_on)
measures:
- name: total_revenue
expr: SUM(total_amount)
SQL
depends_on = [table.orders]
}

Definition and comment changes are applied in place with ALTER VIEW, so the view keeps its grants.

Databricks also gains:

Redshift​

Redshift gains access control and data sharing as code:

Roles, groups, users, and permissions are now managed as code, including the users Redshift creates for IAM identities:

schema.rs.hcl
role "app_readonly" {
}

role "app_writer" {
member_of = [role.app_readonly]
}

// A group is a role carrying the group marker: Redshift keeps
// CREATE GROUP apart from CREATE ROLE.
role "app_analysts" {
group = true
}

user "app_api" {
conn_limit = 5
member_of = [role.app_writer, role.app_analysts]
}

Atlas writes each grantee the way Redshift requires, and revokes privileges before it drops the role or user that holds them.

Oracle​

Oracle gains tablespaces, deferrable keys, and column collations:

Tablespaces and physical attributes are declared in a physical block, on tables and on indexes:

schema.hcl
table "T3" {
schema = schema.APP
column "A" {
null = true
type = NUMBER
}
index "I_T3" {
columns = [column.A]
physical {
initrans = 4
tablespace = "SYSAUX"
}
}
physical {
pctfree = 5
tablespace = "SYSAUX"
storage {
buffer_pool = KEEP
}
}
}

Relocations are planned with ALTER TABLE ... MOVE ONLINE, which keeps indexes usable, and a changed index clause as ALTER INDEX ... REBUILD.

MySQL and MariaDB​

Six new lint analyzers report changes that copy or rebuild the table, block concurrent writes, or silently forfeit instant DDL. For example, adding a stored generated column:

ALTER TABLE orders ADD COLUMN total INT AS (price * qty) STORED NOT NULL;
    -- blocking table changes detected:
-- L1: Adding stored generated column "total" on table "orders" requires a table copy and
blocks concurrent DML https://atlasgo.io/lint/analyzers#MY140
-- suggested fix:
-> Define the column as VIRTUAL to add it instantly, unless its value must be stored

ClickHouse​

Some ClickHouse changes cannot keep the rows during a rebuild, such as an engine change on a replicated table with a fixed ZooKeeper path.

A run without a terminal used to leave such a change out of the plan. It now fails and names the table, unless the diff policy allows the rebuild:

atlas.hcl
env "prod" {
diff "clickhouse" {
modify_table {
allow_recreate = true
}
}
}

Distributed SQL​

CockroachDB, YugabyteDB, Aurora DSQL, and Spanner each gain a missing piece:

Triggers, functions, and procedures are written like their PostgreSQL counterparts:

schema.hcl
function "audit_order" {
schema = schema.public
lang = PLpgSQL
return = trigger
as = <<-SQL
BEGIN
RETURN new;
END;
SQL
}
trigger "audit_orders" {
on = table.orders
before {
insert = true
}
for = ROW
when = "((new).amount > 100)"
execute {
function = function.audit_order
args = ["orders"]
}
}

CockroachDB rejects DROP FUNCTION ... CASCADE, so Atlas orders a trigger drop before the function it executes.

Also in This Release​

Atlas v1.3.5 and later are built with Go 1.26.10, which rejects certificates issued under the compromised eMudhra intermediates.

This release also includes improvements to Atlas Scripts, lint, permissions, CI/CD, the Kubernetes Operator, and Azure, and adds dark mode to Atlas Cloud:

The atlas script commands run on every target of an environment defined with for_each, such as a database or a schema per tenant, with each tenant's own URL and variables:

atlas.hcl
locals {
tenants = ["tenant_1", "tenant_2"]
}

env "prod" {
for_each = toset(local.tenants)
url = "sqlite://${each.value}.db"
tenant = each.value
script {
src = "file://scripts"
}
}
atlas script query --env prod --run '^user_counts$' --quiet
tenant_1: 4 users, 2 on pro
tenant_2: 3 users, 1 on pro

Scripts pushed with atlas script push also get a page in the Registry, and run from anywhere by name with an atlas:// URL.

A mask block can also mask entities in free text, such as emails and phone numbers, and keep the rest of the value.

We ship improvements continuously between releases, so follow the Atlas changelog to stay up to date.

Atlas Binaries Are Moving​

Starting December 2026, Atlas CLI binaries are served from https://atlasbinaries.com. Most setups need no change.

release.ariga.io will no longer serve public downloads directly, and requests to it will redirect to the same file on atlasbinaries.com. File paths stay the same, and only the hostname changes:

-https://release.ariga.io/atlas/atlas-linux-amd64-latest
+https://atlasbinaries.com/atlas/atlas-linux-amd64-latest

Here is what to check:

  • If you use the official install script (curl -sSf https://atlasgo.sh | sh), there is nothing to do.
  • If you download binaries directly, in CI pipelines, Dockerfiles, or scripts, replace release.ariga.io with atlasbinaries.com in your URLs.
  • If your firewall or proxy restricts outbound traffic, allow atlasbinaries.com.
  • If your download command does not follow redirects, such as curl without -L, turn it on. Otherwise, once the redirect is active, it saves the redirect response instead of the binary.

Questions? Message us on Intercom or ask on our Discord server.

Wrapping Up​

Atlas v1.4 brings security scanning to your databases, from a lint check in CI to scheduled scans of production.

It also extends the feedback loop we described in The AI-Native SDLC Playbook Stops at the Database. The first example in that post is a migration that passes every test on a dev database with 40 rows, and then holds a lock on the production table for 90 seconds.

Lint classifies such a change by how it breaks production, and the profiler now measures it over production-like data, before the change merges. Together with the agent skills and the drift checks between deployments, more of that loop now has the database inside it.

We'd love to hear your feedback! Join our Discord server or schedule a demo.