diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
index 0594d12c..ca3ad028 100644
--- a/.github/workflows/clippy.yml
+++ b/.github/workflows/clippy.yml
@@ -5,9 +5,23 @@ on:
   push:
     branches: [main]
 
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so repeated pushes do not stack up on a capped pool. Non-PR runs get a group
+# unique to the run (run_id): merge-group runs reuse a ref across re-queues,
+# and GitHub concurrency replaces a PENDING run in a group even with
+# cancel-in-progress false, so keying them by ref would let one merge-group
+# run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   clippy:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (Ubuntu 24.04, 4 vCPU / 16 GB, capped at
+    # 20 concurrent). ubuntu-latest is an Amazon-wide shared pool where our jobs
+    # waited 10-90 minutes to start (2026-09-29/30); see integration.yml.
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 15
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@1.97.0
diff --git a/.github/workflows/fmt.yml b/.github/workflows/fmt.yml
index ac5451b8..b0a847ef 100644
--- a/.github/workflows/fmt.yml
+++ b/.github/workflows/fmt.yml
@@ -5,9 +5,23 @@ on:
   push:
     branches: [main]
 
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so repeated pushes do not stack up on a capped pool. Non-PR runs get a group
+# unique to the run (run_id): merge-group runs reuse a ref across re-queues,
+# and GitHub concurrency replaces a PENDING run in a group even with
+# cancel-in-progress false, so keying them by ref would let one merge-group
+# run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   fmt:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (Ubuntu 24.04, 4 vCPU / 16 GB, capped at
+    # 20 concurrent). ubuntu-latest is an Amazon-wide shared pool where our jobs
+    # waited 10-90 minutes to start (2026-09-29/30); see integration.yml.
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 15
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@1.97.0
diff --git a/.github/workflows/integration-mongodb.yml b/.github/workflows/integration-mongodb.yml
index 912df8bf..3df405a7 100644
--- a/.github/workflows/integration-mongodb.yml
+++ b/.github/workflows/integration-mongodb.yml
@@ -18,9 +18,23 @@ permissions:
 # `run-tests --backend mongodb`, tearing everything down on exit. Both jobs
 # reuse it so CI runs the exact path developers run locally (no drift), while
 # splitting pytest and rust into parallel jobs the way integration.yml does.
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so repeated pushes do not stack up on a capped pool. Non-PR runs get a group
+# unique to the run (run_id): merge-group runs reuse a ref across re-queues,
+# and GitHub concurrency replaces a PENDING run in a group even with
+# cancel-in-progress false, so keying them by ref would let one merge-group
+# run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   mongodb-pytest:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (Ubuntu 24.04, 4 vCPU / 16 GB, capped at
+    # 20 concurrent). ubuntu-latest is an Amazon-wide shared pool where our jobs
+    # waited 10-90 minutes to start (2026-09-29/30); see integration.yml.
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
@@ -38,7 +52,8 @@ jobs:
         run: devtools/run-mongodb-tests -- --pytest --comprehensive --parallel
 
   mongodb-rust:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
@@ -56,7 +71,8 @@ jobs:
         run: devtools/run-mongodb-tests -- --rust --rust-integration
 
   mongodb-production-build:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
       - uses: dtolnay/rust-toolchain@stable
@@ -67,7 +83,8 @@ jobs:
         run: cargo check --release --no-default-features --features mongodb
 
   mongodb-integration:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     needs: [mongodb-pytest, mongodb-rust, mongodb-production-build]
     if: always()
     steps:
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index da5d274a..5d1ab88a 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -8,9 +8,27 @@ on:
 permissions:
   contents: read
 
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so two pushes do not each hold six slots on a capped pool. Everything that is
+# not a pull request gets a group unique to the run (run_id): merge-group runs
+# can share a ref (gh-readonly-queue/main/pr-N-<sha> is reused across
+# re-queues of the same PR), and GitHub concurrency replaces a PENDING run in
+# a group even with cancel-in-progress false — so keying non-PR runs by ref
+# would let one merge-group run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   run-integration:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (4 vCPU / 16 GB, capped at 20 concurrent),
+    # pinned to Ubuntu 24.04. ubuntu-latest is an Amazon-wide pool of 1,000
+    # concurrent jobs shared first-come first-served across every org; our jobs
+    # sat queued 10–90 minutes behind other teams' load (2026-09-29/30). Pinned
+    # rather than "latest" because ubuntu-latest migrates to 26.04 in Oct–Nov
+    # 2026 and this compiles Rust; move to 26 deliberately.
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     services:
       postgres:
         # pgvector's own image, which is postgres:16 plus the extension. The
@@ -88,7 +106,8 @@ jobs:
         run: sudo journalctl -t extenddb --no-pager -n 500 || true
 
   run-integration-sqlite:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
 
@@ -149,7 +168,8 @@ jobs:
     # transaction authorization regression reached main: the build compiled, so
     # a feature-matrix check passed, while nothing ever issued a request against
     # a dev-mode server. This job starts one and exercises the data plane.
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     steps:
       - uses: actions/checkout@v6
 
@@ -197,7 +217,8 @@ jobs:
         run: python3 -m pytest tests/test_dev_mode_authorization.py -v
 
   run-rust-integration:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     services:
       postgres:
         image: pgvector/pgvector:pg16
@@ -296,7 +317,8 @@ jobs:
   # EXTENDDB_EXPECT_VECTORS flips to "1". Without this job the refusal surface
   # would stop being tested at exactly that point.
   run-rust-integration-postgres-novector:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     services:
       postgres:
         image: postgres:16
@@ -368,7 +390,8 @@ jobs:
       # image and the job above already runs them; repeating them here would buy
       # a second release build and no coverage.
   run-rust-integration-sqlite:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
 
     steps:
       - uses: actions/checkout@v6
@@ -434,7 +457,8 @@ jobs:
         run: sudo journalctl -t extenddb --no-pager -n 500 || true
 
   integration:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 40
     needs:
       [
         run-integration,
diff --git a/.github/workflows/licenses.yml b/.github/workflows/licenses.yml
index 75d1ff2a..e466004d 100644
--- a/.github/workflows/licenses.yml
+++ b/.github/workflows/licenses.yml
@@ -40,9 +40,22 @@ on:
 permissions:
   contents: read
 
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so repeated pushes do not stack up on a capped pool. Non-PR runs get a group
+# unique to the run (run_id): merge-group runs reuse a ref across re-queues,
+# and GitHub concurrency replaces a PENDING run in a group even with
+# cancel-in-progress false, so keying them by ref would let one merge-group
+# run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   notices-current:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (Ubuntu 24.04, 4 vCPU / 16 GB, capped at
+    # 20 concurrent). ubuntu-latest is an Amazon-wide shared pool where our jobs
+    # waited 10-90 minutes to start (2026-09-29/30); see integration.yml.
+    runs-on: extenddb_ubuntu-2404_4-core
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 73bbdb51..70325655 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -8,9 +8,23 @@ on:
 permissions:
   contents: read
 
+# Supersede an in-flight run of the SAME pull request when a new push arrives,
+# so repeated pushes do not stack up on a capped pool. Non-PR runs get a group
+# unique to the run (run_id): merge-group runs reuse a ref across re-queues,
+# and GitHub concurrency replaces a PENDING run in a group even with
+# cancel-in-progress false, so keying them by ref would let one merge-group
+# run cancel another and evict its queue entry.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
   run-tests:
-    runs-on: ubuntu-latest
+    # Dedicated ExtendDB runner group (Ubuntu 24.04, 4 vCPU / 16 GB, capped at
+    # 20 concurrent). ubuntu-latest is an Amazon-wide shared pool where our jobs
+    # waited 10-90 minutes to start (2026-09-29/30); see integration.yml.
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 15
     strategy:
       matrix:
         toolchain: [stable, "1.88.0"]
@@ -23,7 +37,8 @@ jobs:
       - run: cargo test --workspace
 
   test:
-    runs-on: ubuntu-latest
+    runs-on: extenddb_ubuntu-2404_4-core
+    timeout-minutes: 15
     needs: run-tests
     if: always()
     steps: