Add this to your agent's context
Give your AI agent the context it needs to work with Xata production Postgres.
Connecting your existing Postgres to Xata gives you powerful branching and anonymization for development and staging. But Xata is designed to run your production database too. When production runs on Xata, branches become instant point-in-time forks with no replication lag, anonymization happens at branch creation with zero configuration, and a single platform manages every environment — dev, staging, and production — with the same CLI, the same API, and the same workflow.
Not just branching — the whole stack
Connecting an external Postgres gives you powerful branching and anonymization. Running production on Xata unlocks the full platform: purpose-built storage, instant native branching, end-to-end zero-downtime migrations, and a unified environment from development to production.
NVMe-over-Fabrics storage
Xata's storage engine — Xatastor — is a purpose-built distributed block storage system using NVMe/TCP and SPDK for ultra-low latency. This is not a managed wrapper around EBS or persistent disk. It was designed from scratch for Postgres workloads, with hot data on NVMe, warm data on SSD, and cold data on S3. The storage engine moves data between tiers automatically — you get high performance where it matters without paying for all-NVMe.
Branching is native
When production runs on Xata, branches are instant and free. There is no logical replication lag to wait for, no sync job to schedule, no snapshot window. Every branch is a point-in-time fork of the real thing — the moment you call the API, the branch exists and reflects production data exactly as it was at that instant.
Anonymization at the source
PII is detected and anonymized as branches are created — not after the fact, and not via a separate replication pipeline. When production is on Xata, there is no external replication to configure. Branches start clean by default, with sensitive fields replaced by realistic synthetic values that preserve data shape and distribution.
Unified scale-to-zero
Production stays always-on. Dev and staging branches scale to zero automatically when idle and reactivate on the first connection. One platform manages both — no separate infrastructure for pre-production environments, no split billing, no context switching between tools.
Smart storage tiering
Hot data lives on NVMe, warm data on SSD, cold data on S3. Xatastor moves data between tiers automatically based on access patterns. You do not need to configure tiering rules or manually archive old data — the storage engine handles it, so you pay for the performance level you actually use.
BYOC or fully managed
Run in your own AWS, GCP, Azure, or Hetzner account with Bring Your Own Cloud — or let Xata manage everything. Either way, you get the same performance, the same branching workflow, and the same API. BYOC is particularly relevant for data residency requirements or enterprise procurement constraints.
Start connected, grow into production
Most teams start by connecting their existing database. The move to Xata-hosted production happens naturally — when you are ready and on your terms.
The first step is connecting your existing RDS, Aurora, or Cloud SQL instance. Xata replicates to a staging environment with built-in anonymization. Production stays exactly where it is. Zero risk, zero disruption.
From there, your team starts using the workflow: creating branches, running tests against production-like data, running zero-downtime schema migrations with pgroll. Development gets faster without touching the production infrastructure.
At this stage you are getting most of the value — but you can feel the edge: branch creation waits on replication lag, snapshots are periodic rather than instant, and anonymization happens in the replication pipeline rather than at branch creation. You are getting 80% of the platform.
When you are ready, migrating production to Xata storage takes the workflow to its full potential. Branches become instant point-in-time forks. Anonymization happens at branch creation with zero configuration. pgroll runs end-to-end across production and branches with zero downtime. The full platform, no compromises.
What changes when production runs on Xata
Both modes — connected external Postgres and production on Xata — use the same CLI, the same API, and the same branching workflow. The difference is in what becomes possible and how much friction remains.
Branch creation with a connected Postgres takes seconds and depends on the latest replica. With production on Xata, it is instant and reflects a point-in-time fork of live data. Data freshness shifts from replication lag (seconds to minutes) to real-time. Anonymization moves from a replication pipeline step to a zero-config branch creation default. Schema migrations with pgroll apply to branches when connected externally, but run end-to-end — including production — when Xata hosts everything. The storage engine changes from your provider's default (EBS, Persistent Disk) to Xatastor NVMe-over-Fabrics.
Vanilla Postgres. Open source. Portable.
Xata runs unmodified Postgres — not a fork, not a custom engine with proprietary extensions. Every tool, ORM, and extension that works with standard Postgres works with Xata unchanged. The tooling that manages your data — pgroll, pgstream, and Xata Agent — is all Apache 2.0 open source. You can inspect the code that runs against your database.
Migration in happens via logical replication with zero downtime. Migration out, if you ever need it, is the same process in reverse — pg_dump and go. That portability is not a concession or a disclaimer. It is the point. A database platform you can trust is one you could leave if you needed to.