Skip to main content
Open source, Apache 2.0

The agent‑safe data plane
for DuckDB and DuckLake.

One governed endpoint for people, BI tools and AI agents. Every statement is authorized inside the engine, agents write on branches a human merges, and it runs in your own cloud, AWS or any other, or on a laptop. Connect over JDBC, ODBC, ADBC or MCP, or ATTACH it straight from DuckDB.

uvx qod@latest serve --demo no install, no Postgres

client.py
# One endpoint, JDBC / ADBC / ODBC / PyArrow
conn = flight_sql.connect(
    "grpc+tls://gateway:31338",
    db_kwargs={
      "username": "alice", "password": "•••",
      tenant: "acme", pool: "analytics"})

# routed to the least-loaded node for the tenant
cur = conn.cursor()
cur.execute("SELECT count(*) FROM orders")
cur.fetchone()
(1500000,)

From a single database to a fleet

uvx qod start
$ uvx qod start
control-plane Postgres: jdbc:postgresql://localhost:5432/qod (user postgres)
 QoD 0.5.0 is up
   control plane : jdbc:postgresql://localhost:5432/qod
   REST API + UI : http://localhost:20900  (UI: http://localhost:20900/ui)
   FlightSQL     : grpc+tls://localhost:31338
   Quack (DuckDB): quack:localhost:9494  (plain HTTP)

 Client connection strings (replace <tenant>, <pool>, <user>):
   DuckDB: ATTACH 'quack:localhost:9494' AS qod (TYPE quack, TOKEN 'tenant=<tenant>&pool=<pool>&user=<user>&password=<password>');
   JDBC : jdbc:arrow-flight-sql://localhost:31338/?tenant=<tenant>&pool=<pool>&user=<user>&useEncryption=true&disableCertificateVerification=true
   ADBC : uri=grpc+tls://localhost:31338  (adbc_driver_flightsql)
   ODBC : Driver={Arrow Flight SQL ODBC Driver};Host=localhost;Port=31338;...

From zero to SQL in one command

One command boots the whole platform: manager, FlightSQL endpoint, native Quack front door, admin UI, and demo data. No cluster, no YAML, nothing to install beyond uv: the launcher fetches the rest.

The boot banner hands you working JDBC, ADBC, and ODBC connection strings and a ready-to-paste DuckDB ATTACH. Paste one into your tool and you are querying.

qod sql
qod> SELECT o_orderpriority, count(*) FROM orders GROUP BY 1 ORDER BY 1;
+-----------------+----------+
| o_orderpriority | count(*) |
+-----------------+----------+
| 1-URGENT        |    30044 |
| 2-HIGH          |    30076 |
| 3-MEDIUM        |    29949 |
+-----------------+----------+
3 rows in 0.04s

Talk to it from anything that speaks SQL

Two wires, one gateway. Arrow FlightSQL serves the driver estate: JDBC and ODBC for BI tools, ADBC and Python for notebooks, the qod CLI for your terminal. DuckDB’s own Quack protocol serves DuckDB itself, so a laptop, a notebook, or an embedded engine runs ATTACH 'quack:host:9494' and joins local tables with governed shared ones, no driver to install.

Both land in the same path: same identity, same per-statement ACL, same audit log. Statements are classified read or write and routed to the least-loaded node that can serve them, with transaction pinning.

Tenants, pools, and a hibernated pool one click from waking.

A real multi-tenant control plane

Tenants own databases, users, and pools of DuckDB nodes, isolated by storage layout and access control.

Idle pools suspend to zero nodes and keep their catalogs; the first query wakes them automatically. You pay for compute only while queries run.

alice (analyst) $ SELECT c_phone, c_mktsegment FROM customer
c_phonec_mktsegment
***BUILDING
***BUILDING
***BUILDING
admin $ SELECT c_phone, c_mktsegment FROM customer
c_phonec_mktsegment
25-989-741-2988BUILDING
23-768-687-3665AUTOMOBILE
13-761-547-5974MACHINERY

Every user sees only their data

The same query, two users, two answers: that is the access-control model working.

Per-table grants (read, write, DDL), row-level security filters and column masking apply to every client, agents included. Each node decides a statement on what DuckDB actually resolved for it (tables, views, columns, functions, files) before it runs, against the user's grants or the tenant's own OPA policy.

qod branch
$ qod branch create --tenant acme --db acme_tpch \
    --name agent-fix --ttl-hours 24
# the agent writes on agent-fix, never on main

$ qod branch changes --tenant acme --db acme_tpch --branch agent-fix
$ qod branch diff --tenant acme --db acme_tpch --branch agent-fix \
    --schema tpch1 --table customer

$ qod branch propose --tenant acme --db acme_tpch --branch agent-fix
$ qod branch merge --tenant acme --db acme_tpch --branch agent-fix \
    --proposal <id>      # a different user approves

Agents work on branches. Humans approve merges.

A branch is a writable copy of a DuckLake database that copies no data and is served by its own pool. An agent connects with the branch header or the MCP branch argument and writes there, as its own user, under its own grants.

You review the change set and the row diff, and someone other than the proposer merges it into main as one tagged snapshot, cell by cell, with conflicts refused unless the proposal names a winner. A branch-only token makes writes to the live database impossible for that agent.

Every write is a snapshot: browse, tag, diff, restore.

Your data has an undo button

DuckLake gives every table a history: time-travel reads, named tags, undrop for deleted tables, and restore that rolls back as a new snapshot with nothing lost.

Mistakes stop being incidents and become queries.

Per-statement history, audit trail, usage trends.

See everything

Per-statement history with latency and routing, a full audit trail, usage trends per tenant, and Prometheus metrics for your dashboards.

One containeruvx qod startembedded demo dataOne nodeyour Postgres catalogyour S3 or diskKubernetespools of pods, HA managersscale-to-zero tenants

Start on a laptop. Grow to a cluster.

The single-container mode is first-class, not a demo: run it on one box for years if that is all you need.

When you outgrow it, point the same gateway at your Postgres and object store, then move to Kubernetes with pools of pods and HA managers. Your clients never notice: same endpoint, same tenants, same SQL.

Which setup do you need?

CapabilityPlain DuckDBqod serve on filesqod serve + Icebergqod serve on DuckLake
Access
Arrow Flight SQL endpoint (BI tools, ODBC, JDBC, ADBC)✓✓✓
Native Quack protocol (ATTACH straight from DuckDB)✓✓✓
MCP server for AI agents✓✓✓
Security
TLS and authentication✓✓✓
RBAC on tables, columns and rows✓✓✓
Encryption at rest for Parquet and database files✓✓✓
Data
Serve DuckDB files, parquet, csv, S3 prefixes✓✓✓
Iceberg REST catalog federation✓✓
DuckLake warehouse on Postgres and object storage✓
History
Time travel and snapshot tags✓
Undrop and rollback✓
Author stamping and audit timeline✓
Operations
Multi-tenant isolation✓✓✓
Multi-node routing✓✓✓
Kubernetes deployment✓✓✓
Compaction and cleanup policies✓
Sovereignty
Runs fully in your infrastructure✓✓✓✓

Plain DuckDB can read these formats locally. This table shows what is served to others.

Reach for it when sharing matters.

Many users and agents on shared DuckDB/DuckLake data, access control on every query, writes you can review before they land, tenant isolation, your own cloud. Querying one local file? Use DuckDB directly.

Looking for one answer? The DuckDB how-tos cover access control, single sign-on, ADBC and multi-tenancy.