diff --git a/aggregator/src/aggregator.rs b/aggregator/src/aggregator.rs
index 80c28817c..a2c0ac07b 100644
--- a/aggregator/src/aggregator.rs
+++ b/aggregator/src/aggregator.rs
@@ -797,7 +797,6 @@ impl<C: Clock> Aggregator<C> {
                 task_config.query_config().query().try_into()?,
                 vdaf_instance,
                 vdaf_verify_key,
-                task_config.query_config().max_batch_query_count() as u64,
                 Some(*task_config.task_expiration()),
                 peer_aggregator.report_expiry_age().cloned(),
                 task_config.query_config().min_batch_size() as u64,
diff --git a/aggregator/src/aggregator/batch_mode.rs b/aggregator/src/aggregator/batch_mode.rs
index f87fd309f..8bfaa24b7 100644
--- a/aggregator/src/aggregator/batch_mode.rs
+++ b/aggregator/src/aggregator/batch_mode.rs
@@ -14,7 +14,7 @@ use janus_messages::{
     Role,
 };
 use prio::vdaf;
-use std::{collections::HashSet, hash::Hash};
+use std::hash::Hash;
 
 #[async_trait]
 pub trait UploadableBatchMode: BatchMode {
@@ -124,13 +124,9 @@ impl CollectableBatchMode for TimeInterval {
     where
         A::AggregationParam: Send + Sync + Eq + Hash,
     {
-        // Check how distinct aggregation parameters appear in rows in the relevant table with an
-        // intersecting batch interval. Each distinct aggregation parameter consumes one unit of
-        // query count.
-        //
-        // https://www.ietf.org/archive/id/draft-ietf-ppm-dap-05.html#section-4.6.6
+        // Compute the aggregation parameters that have already been collected for.
         let mut found_overlapping_nonequal_interval = false;
-        let agg_params = match task.role() {
+        let agg_params: Vec<_> = match task.role() {
             Role::Leader => tx
                 .get_collection_jobs_intersecting_interval::<SEED_SIZE, A>(
                     vdaf,
@@ -145,7 +141,7 @@ impl CollectableBatchMode for TimeInterval {
                     }
                     job.take_aggregation_parameter()
                 })
-                .collect::<HashSet<_>>(),
+                .collect(),
 
             Role::Helper => tx
                 .get_aggregate_share_jobs_intersecting_interval::<SEED_SIZE, A>(
@@ -161,7 +157,7 @@ impl CollectableBatchMode for TimeInterval {
                     };
                     job.take_aggregation_parameter()
                 })
-                .collect::<HashSet<_>>(),
+                .collect(),
 
             _ => panic!("Unexpected task role {:?}", task.role()),
         };
@@ -173,17 +169,13 @@ impl CollectableBatchMode for TimeInterval {
             ));
         }
 
-        // Check that the batch query count is being consumed appropriately.
-        let max_batch_query_count: usize = task.max_batch_query_count().try_into()?;
-        let query_count = agg_params.len()
-            + if agg_params.contains(aggregation_param) {
-                0
-            } else {
-                1
-            };
-        if query_count > max_batch_query_count {
+        // Check that the batch has not already been queried with a distinct aggregation parameter.
+        if agg_params
+            .iter()
+            .any(|agg_param| agg_param != aggregation_param)
+        {
             return Err(datastore::Error::User(
-                Error::BatchQueriedTooManyTimes(*task.id(), query_count as u64).into(),
+                Error::BatchQueriedMultipleTimes(*task.id()).into(),
             ));
         }
         Ok(())
@@ -206,39 +198,32 @@ impl CollectableBatchMode for LeaderSelected {
     where
         A::AggregationParam: Send + Sync + Eq + Hash,
     {
-        // Check how distinct aggregation parameters appear in rows in the relevant table with an
-        // intersecting batch interval. Each distinct aggregation parameter consumes one unit of
-        // query count.
-        //
-        // https://www.ietf.org/archive/id/draft-ietf-ppm-dap-05.html#section-4.6.6
-        let agg_params = match task.role() {
+        // Compute the aggregation parameters that have already been collected for.
+        let agg_params: Vec<_> = match task.role() {
             Role::Leader => tx
                 .get_collection_jobs_by_batch_id::<SEED_SIZE, A>(vdaf, task.id(), batch_id)
                 .await?
                 .into_iter()
                 .map(|job| job.take_aggregation_parameter())
-                .collect::<HashSet<_>>(),
+                .collect(),
 
             Role::Helper => tx
                 .get_aggregate_share_jobs_by_batch_id::<SEED_SIZE, A>(vdaf, task.id(), batch_id)
                 .await?
                 .into_iter()
                 .map(|job| job.take_aggregation_parameter())
-                .collect::<HashSet<_>>(),
+                .collect(),
 
             _ => panic!("Unexpected task role {:?}", task.role()),
         };
 
-        let max_batch_query_count: usize = task.max_batch_query_count().try_into()?;
-        let query_count = agg_params.len()
-            + if agg_params.contains(aggregation_param) {
-                0
-            } else {
-                1
-            };
-        if query_count > max_batch_query_count {
+        // Check that the batch has not already been queried with a distinct aggregation parameter.
+        if agg_params
+            .iter()
+            .any(|agg_param| agg_param != aggregation_param)
+        {
             return Err(datastore::Error::User(
-                Error::BatchQueriedTooManyTimes(*task.id(), query_count as u64).into(),
+                Error::BatchQueriedMultipleTimes(*task.id()).into(),
             ));
         }
         Ok(())
diff --git a/aggregator/src/aggregator/collection_job_driver.rs b/aggregator/src/aggregator/collection_job_driver.rs
index f82f0bf3c..e4a90c55f 100644
--- a/aggregator/src/aggregator/collection_job_driver.rs
+++ b/aggregator/src/aggregator/collection_job_driver.rs
@@ -1246,7 +1246,7 @@ mod tests {
             .match_body(leader_request.get_encoded().unwrap())
             .with_status(500)
             .with_header("Content-Type", "application/problem+json")
-            .with_body("{\"type\": \"urn:ietf:params:ppm:dap:error:batchQueriedTooManyTimes\"}")
+            .with_body("{\"type\": \"urn:ietf:params:ppm:dap:error:batchQueriedMultipleTimes\"}")
             .create_async()
             .await;
 
@@ -1257,7 +1257,7 @@ mod tests {
         assert_matches!(
             error,
             Error::Http(error_response) => {
-                assert_matches!(error_response.dap_problem_type(), Some(DapProblemType::BatchQueriedTooManyTimes));
+                assert_matches!(error_response.dap_problem_type(), Some(DapProblemType::BatchQueriedMultipleTimes));
                 assert_eq!(error_response.status(), StatusCode::INTERNAL_SERVER_ERROR);
             }
         );
diff --git a/aggregator/src/aggregator/collection_job_tests.rs b/aggregator/src/aggregator/collection_job_tests.rs
index 394a246cc..b400545c2 100644
--- a/aggregator/src/aggregator/collection_job_tests.rs
+++ b/aggregator/src/aggregator/collection_job_tests.rs
@@ -29,7 +29,7 @@ use janus_core::{
 use janus_messages::{
     batch_mode::{BatchMode as BatchModeTrait, LeaderSelected, TimeInterval},
     AggregateShareAad, AggregationJobStep, BatchId, BatchSelector, Collection, CollectionJobId,
-    CollectionReq, Interval, LeaderSelectedQuery, Query, Role, Time,
+    CollectionReq, Interval, Query, Role, Time,
 };
 use prio::{
     codec::{Decode, Encode},
@@ -331,7 +331,7 @@ async fn collection_job_success_leader_selected() {
     let helper_aggregate_share = dummy::AggregateShare(1);
     let aggregation_param = dummy::AggregationParam::default();
     let request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+        Query::new_leader_selected(),
         aggregation_param.get_encoded().unwrap(),
     );
 
@@ -526,9 +526,9 @@ async fn collection_job_put_idempotence_time_interval() {
 #[tokio::test]
 async fn collection_job_put_idempotence_time_interval_varied_collection_id() {
     // This test sends repeated, identical collection requests with differing collection job IDs and
-    // validates that they are accepted. They should be accepted because calculation of the query
-    // count for max_batch_query_count testing is based on the number of distinct aggregation
-    // parameters that the batch has been collected against.
+    // validates that they are accepted. They should be accepted because the check for repeated
+    // collection should allow a batch to be repeatedly collected as long as it uses the same
+    // aggregation parameter each time.
 
     let test_case = setup_collection_job_test_case(Role::Leader, BatchMode::TimeInterval).await;
     test_case
@@ -585,60 +585,6 @@ async fn collection_job_put_idempotence_time_interval_varied_collection_id() {
         .unwrap();
 }
 
-#[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_varied_collection_id() {
-    // This test sends repeated, identical collection requests with differing collection job IDs and
-    // validates that they are accepted. They should be accepted because calculation of the query
-    // count for max_batch_query_count testing is based on the number of distinct aggregation
-    // parameters that the batch has been collected against.
-
-    let (test_case, batch_id, _, _) =
-        setup_leader_selected_current_batch_collection_job_test_case().await;
-
-    let collection_job_ids = HashSet::from(random::<[CollectionJobId; 2]>());
-    let request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-        dummy::AggregationParam::default().get_encoded().unwrap(),
-    );
-
-    for collection_job_id in &collection_job_ids {
-        let response = test_case
-            .put_collection_job(collection_job_id, &request)
-            .await;
-        assert_eq!(response.status(), Some(Status::Created));
-    }
-
-    test_case
-        .datastore
-        .run_unnamed_tx(|tx| {
-            let task_id = *test_case.task.id();
-            let collection_job_ids = collection_job_ids.clone();
-
-            Box::pin(async move {
-                let collection_jobs = tx
-                    .get_collection_jobs_for_task::<0, LeaderSelected, dummy::Vdaf>(
-                        &dummy::Vdaf::new(1),
-                        &task_id,
-                    )
-                    .await
-                    .unwrap();
-
-                assert_eq!(collection_jobs.len(), 2);
-                assert_eq!(
-                    collection_jobs
-                        .into_iter()
-                        .map(|job| *job.id())
-                        .collect::<HashSet<_>>(),
-                    collection_job_ids
-                );
-
-                Ok(())
-            })
-        })
-        .await
-        .unwrap();
-}
-
 #[tokio::test]
 async fn collection_job_put_idempotence_time_interval_mutate_time_interval() {
     let test_case = setup_collection_job_test_case(Role::Leader, BatchMode::TimeInterval).await;
@@ -722,13 +668,13 @@ async fn collection_job_put_idempotence_time_interval_mutate_aggregation_param()
 }
 
 #[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_current_batch() {
+async fn collection_job_put_idempotence_leader_selected() {
     let (test_case, batch_id_1, batch_id_2, _) =
         setup_leader_selected_current_batch_collection_job_test_case().await;
 
     let collection_job_id = random();
     let request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+        Query::new_leader_selected(),
         dummy::AggregationParam(0).get_encoded().unwrap(),
     );
     let mut seen_batch_id = None;
@@ -774,12 +720,12 @@ async fn collection_job_put_idempotence_leader_selected_current_batch() {
 }
 
 #[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_current_batch_mutate_aggregation_param() {
+async fn collection_job_put_idempotence_leader_selected_mutate_aggregation_param() {
     let (test_case, _, _, _) = setup_leader_selected_current_batch_collection_job_test_case().await;
 
     let collection_job_id = random();
     let request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+        Query::new_leader_selected(),
         dummy::AggregationParam(0).get_encoded().unwrap(),
     );
 
@@ -790,7 +736,7 @@ async fn collection_job_put_idempotence_leader_selected_current_batch_mutate_agg
     assert_eq!(response.status(), Some(Status::Created));
 
     let mutated_request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+        Query::new_leader_selected(),
         dummy::AggregationParam(1).get_encoded().unwrap(),
     );
 
@@ -801,14 +747,14 @@ async fn collection_job_put_idempotence_leader_selected_current_batch_mutate_agg
 }
 
 #[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_current_batch_no_extra_reports() {
+async fn collection_job_put_idempotence_leader_selected_no_extra_reports() {
     let (test_case, _batch_id_1, _batch_id_2, _) =
         setup_leader_selected_current_batch_collection_job_test_case().await;
 
     let collection_job_id_1 = random();
     let collection_job_id_2 = random();
-    let request = Arc::new(CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+    let request: Arc<CollectionReq<LeaderSelected>> = Arc::new(CollectionReq::new(
+        Query::new_leader_selected(),
         dummy::AggregationParam(0).get_encoded().unwrap(),
     ));
 
@@ -843,120 +789,3 @@ async fn collection_job_put_idempotence_leader_selected_current_batch_no_extra_r
         .await;
     assert_eq!(response.status(), Some(Status::Created));
 }
-
-#[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_by_batch_id() {
-    let test_case = setup_collection_job_test_case(
-        Role::Leader,
-        BatchMode::LeaderSelected {
-            max_batch_size: Some(10),
-            batch_time_window_size: None,
-        },
-    )
-    .await;
-    let batch_id = test_case
-        .setup_leader_selected_batch(test_case.clock.now(), 1)
-        .await;
-
-    let collection_job_id = random();
-
-    let request = CollectionReq::new(
-        Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-        dummy::AggregationParam(0).get_encoded().unwrap(),
-    );
-
-    for _ in 0..2 {
-        let response = test_case
-            .put_collection_job(&collection_job_id, &request)
-            .await;
-
-        assert_eq!(response.status(), Some(Status::Created));
-    }
-}
-
-#[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_by_batch_id_mutate_batch_id() {
-    let test_case = setup_collection_job_test_case(
-        Role::Leader,
-        BatchMode::LeaderSelected {
-            max_batch_size: Some(10),
-            batch_time_window_size: None,
-        },
-    )
-    .await;
-    let first_batch_id = test_case
-        .setup_leader_selected_batch(test_case.clock.now(), 1)
-        .await;
-    let second_batch_id = test_case
-        .setup_leader_selected_batch(test_case.clock.now(), 1)
-        .await;
-
-    let collection_job_id = random();
-
-    let response = test_case
-        .put_collection_job(
-            &collection_job_id,
-            &CollectionReq::new(
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId {
-                    batch_id: first_batch_id,
-                }),
-                dummy::AggregationParam(0).get_encoded().unwrap(),
-            ),
-        )
-        .await;
-    assert_eq!(response.status(), Some(Status::Created));
-
-    let response = test_case
-        .put_collection_job(
-            &collection_job_id,
-            &CollectionReq::new(
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId {
-                    batch_id: second_batch_id,
-                }),
-                dummy::AggregationParam(0).get_encoded().unwrap(),
-            ),
-        )
-        .await;
-    assert_eq!(response.status(), Some(Status::Conflict));
-}
-
-#[tokio::test]
-async fn collection_job_put_idempotence_leader_selected_by_batch_id_mutate_aggregation_param() {
-    let test_case = setup_collection_job_test_case(
-        Role::Leader,
-        BatchMode::LeaderSelected {
-            max_batch_size: Some(10),
-            batch_time_window_size: None,
-        },
-    )
-    .await;
-    let batch_id = test_case
-        .setup_leader_selected_batch(test_case.clock.now(), 1)
-        .await;
-
-    let collection_job_id = random();
-    let first_aggregation_param = dummy::AggregationParam(0);
-    let second_aggregation_param = dummy::AggregationParam(1);
-
-    let response = test_case
-        .put_collection_job(
-            &collection_job_id,
-            &CollectionReq::new(
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-                first_aggregation_param.get_encoded().unwrap(),
-            ),
-        )
-        .await;
-    assert_eq!(response.status(), Some(Status::Created));
-
-    let response = test_case
-        .put_collection_job(
-            &collection_job_id,
-            &CollectionReq::new(
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-                second_aggregation_param.get_encoded().unwrap(),
-            ),
-        )
-        .await;
-    assert_eq!(response.status(), Some(Status::Conflict));
-}
diff --git a/aggregator/src/aggregator/error.rs b/aggregator/src/aggregator/error.rs
index a16ac2d1d..c763aef5e 100644
--- a/aggregator/src/aggregator/error.rs
+++ b/aggregator/src/aggregator/error.rs
@@ -96,10 +96,10 @@ pub enum Error {
     /// sets of reports were aggregated.
     #[error("{0}")]
     BatchMismatch(Box<BatchMismatch>),
-    /// Corresponds to `batchQueriedTooManyTimes` in DAP. A collect or aggregate share request was
-    /// rejected because the queries against a single batch exceed the task's `max_batch_query_count`.
-    #[error("task {0}: batch queried too many times ({1})")]
-    BatchQueriedTooManyTimes(TaskId, u64),
+    /// Corresponds to `batchQueriedMultipleTimes` in DAP. A collect or aggregate share request was
+    /// rejected because there was already a distinct query against the relevant batch.
+    #[error("task {0}: batch queried multiple times")]
+    BatchQueriedMultipleTimes(TaskId),
     /// A collect or aggregate share request was rejected because the batch overlaps with a
     /// previously collected one.
     #[error("task {0}: queried batch {1} overlaps with previously collected batch(es)")]
@@ -300,7 +300,7 @@ impl Error {
             Error::InvalidBatchSize(_, _) => "invalid_batch_size",
             Error::Url(_) => "url",
             Error::BatchMismatch { .. } => "batch_mismatch",
-            Error::BatchQueriedTooManyTimes(_, _) => "batch_queried_too_many_times",
+            Error::BatchQueriedMultipleTimes(_) => "batch_queried_multiple_times",
             Error::BatchOverlap(_, _) => "batch_overlap",
             Error::Hpke(_) => "hpke",
             Error::TaskParameters(_) => "task_parameters",
diff --git a/aggregator/src/aggregator/garbage_collector.rs b/aggregator/src/aggregator/garbage_collector.rs
index c0178170d..b67762b8c 100644
--- a/aggregator/src/aggregator/garbage_collector.rs
+++ b/aggregator/src/aggregator/garbage_collector.rs
@@ -192,8 +192,8 @@ mod tests {
     };
     use janus_messages::{
         batch_mode::{LeaderSelected, TimeInterval},
-        AggregationJobStep, Duration, HpkeCiphertext, HpkeConfigId, Interval, LeaderSelectedQuery,
-        Query, ReportIdChecksum, ReportMetadata, ReportShare, Role, Time,
+        AggregationJobStep, Duration, HpkeCiphertext, HpkeConfigId, Interval, Query,
+        ReportIdChecksum, ReportMetadata, ReportShare, Role, Time,
     };
     use prio::vdaf::dummy;
     use rand::random;
@@ -608,7 +608,7 @@ mod tests {
                     tx.put_collection_job(&CollectionJob::<0, LeaderSelected, dummy::Vdaf>::new(
                         *task.id(),
                         random(),
-                        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+                        Query::new_leader_selected(),
                         dummy::AggregationParam(0),
                         batch_id,
                         CollectionJobState::Start,
diff --git a/aggregator/src/aggregator/http_handlers.rs b/aggregator/src/aggregator/http_handlers.rs
index cae9a4e83..0ffb389a7 100644
--- a/aggregator/src/aggregator/http_handlers.rs
+++ b/aggregator/src/aggregator/http_handlers.rs
@@ -131,8 +131,8 @@ async fn run_error_handler(error: &Error, mut conn: Conn) -> Conn {
                 .with_task_id(&inner.task_id)
                 .with_detail(&inner.to_string()),
         ),
-        Error::BatchQueriedTooManyTimes(task_id, _) => conn.with_problem_document(
-            &ProblemDocument::new_dap(DapProblemType::BatchQueriedTooManyTimes)
+        Error::BatchQueriedMultipleTimes(task_id) => conn.with_problem_document(
+            &ProblemDocument::new_dap(DapProblemType::BatchQueriedMultipleTimes)
                 .with_task_id(task_id),
         ),
         Error::Hpke(_)
diff --git a/aggregator/src/aggregator/http_handlers/tests/aggregate_share.rs b/aggregator/src/aggregator/http_handlers/tests/aggregate_share.rs
index 9df3ac4cc..633efce55 100644
--- a/aggregator/src/aggregator/http_handlers/tests/aggregate_share.rs
+++ b/aggregator/src/aggregator/http_handlers/tests/aggregate_share.rs
@@ -160,7 +160,6 @@ async fn aggregate_share_request() {
     } = HttpHandlerTest::new().await;
 
     let task = TaskBuilder::new(BatchMode::TimeInterval, VdafInstance::Fake { rounds: 1 })
-        .with_max_batch_query_count(1)
         .with_time_precision(Duration::from_seconds(500))
         .with_min_batch_size(10)
         .build();
@@ -583,8 +582,8 @@ async fn aggregate_share_request() {
             take_problem_details(&mut test_conn).await,
             json!({
                 "status": Status::BadRequest as u16,
-                "type": "urn:ietf:params:ppm:dap:error:batchQueriedTooManyTimes",
-                "title": "The batch described by the query has been queried too many times.",
+                "type": "urn:ietf:params:ppm:dap:error:batchQueriedMultipleTimes",
+                "title": "The batch described by the query has been queried already.",
                 "taskid": format!("{}", task.id()),
             })
         );
diff --git a/aggregator/src/aggregator/http_handlers/tests/collection_job.rs b/aggregator/src/aggregator/http_handlers/tests/collection_job.rs
index 258ca162e..75458fe50 100644
--- a/aggregator/src/aggregator/http_handlers/tests/collection_job.rs
+++ b/aggregator/src/aggregator/http_handlers/tests/collection_job.rs
@@ -525,7 +525,7 @@ async fn collection_job_get_request_no_such_collection_job() {
 }
 
 #[tokio::test]
-async fn collection_job_put_request_batch_queried_too_many_times() {
+async fn collection_job_put_request_batch_queried_multiple_times() {
     let test_case = setup_collection_job_test_case(Role::Leader, BatchMode::TimeInterval).await;
     let interval = test_case
         .setup_time_interval_batch(Time::from_seconds_since_epoch(0))
@@ -555,8 +555,8 @@ async fn collection_job_put_request_batch_queried_too_many_times() {
         take_problem_details(&mut test_conn).await,
         json!({
             "status": Status::BadRequest as u16,
-            "type": "urn:ietf:params:ppm:dap:error:batchQueriedTooManyTimes",
-            "title": "The batch described by the query has been queried too many times.",
+            "type": "urn:ietf:params:ppm:dap:error:batchQueriedMultipleTimes",
+            "title": "The batch described by the query has been queried already.",
             "taskid": format!("{}", test_case.task.id()),
         })
     );
diff --git a/aggregator/src/aggregator/http_handlers/tests/helper_e2e.rs b/aggregator/src/aggregator/http_handlers/tests/helper_e2e.rs
index 53f094435..f97fcb549 100644
--- a/aggregator/src/aggregator/http_handlers/tests/helper_e2e.rs
+++ b/aggregator/src/aggregator/http_handlers/tests/helper_e2e.rs
@@ -41,7 +41,6 @@ async fn helper_aggregation_report_share_replay() {
         VdafInstance::Fake { rounds: 1 },
     )
     .with_min_batch_size(1)
-    .with_max_batch_query_count(1)
     .build();
     let vdaf = dummy::Vdaf::new(1);
     let agg_param = dummy::AggregationParam(0);
diff --git a/aggregator/src/aggregator/problem_details.rs b/aggregator/src/aggregator/problem_details.rs
index 1ba26d8d9..f5d7f5e36 100644
--- a/aggregator/src/aggregator/problem_details.rs
+++ b/aggregator/src/aggregator/problem_details.rs
@@ -163,7 +163,7 @@ mod tests {
             DapProblemType::ReportTooEarly,
             DapProblemType::BatchInvalid,
             DapProblemType::InvalidBatchSize,
-            DapProblemType::BatchQueriedTooManyTimes,
+            DapProblemType::BatchQueriedMultipleTimes,
             DapProblemType::BatchMismatch,
             DapProblemType::UnauthorizedRequest,
             DapProblemType::BatchOverlap,
@@ -297,8 +297,8 @@ mod tests {
                     Some(DapProblemType::BatchMismatch),
                 ),
                 TestCase::new(
-                    Box::new(|| Error::BatchQueriedTooManyTimes(random(), 99)),
-                    Some(DapProblemType::BatchQueriedTooManyTimes),
+                    Box::new(|| Error::BatchQueriedMultipleTimes(random())),
+                    Some(DapProblemType::BatchQueriedMultipleTimes),
                 ),
             ]
             .into_iter()
diff --git a/aggregator/src/aggregator/taskprov_tests.rs b/aggregator/src/aggregator/taskprov_tests.rs
index 4148eea9f..a98bdfbec 100644
--- a/aggregator/src/aggregator/taskprov_tests.rs
+++ b/aggregator/src/aggregator/taskprov_tests.rs
@@ -168,7 +168,6 @@ where
         .unwrap();
 
         let time_precision = Duration::from_seconds(1);
-        let max_batch_query_count = 1;
         let min_batch_size = 1;
         let max_batch_size = 1;
         let task_expiration = clock.now().add(&Duration::from_hours(24).unwrap()).unwrap();
@@ -178,7 +177,6 @@ where
             "https://helper.example.com/".as_bytes().try_into().unwrap(),
             QueryConfig::new(
                 time_precision,
-                max_batch_query_count,
                 min_batch_size,
                 TaskprovQuery::LeaderSelected { max_batch_size },
             ),
@@ -204,7 +202,6 @@ where
         .with_leader_aggregator_endpoint(Url::parse("https://leader.example.com/").unwrap())
         .with_helper_aggregator_endpoint(Url::parse("https://helper.example.com/").unwrap())
         .with_vdaf_verify_key(vdaf_verify_key)
-        .with_max_batch_query_count(max_batch_query_count as u64)
         .with_task_expiration(Some(task_expiration))
         .with_report_expiry_age(peer_aggregator.report_expiry_age().copied())
         .with_min_batch_size(min_batch_size as u64)
@@ -664,7 +661,6 @@ async fn taskprov_opt_out_mismatched_task_id() {
         QueryConfig::new(
             Duration::from_seconds(1),
             100,
-            100,
             TaskprovQuery::LeaderSelected {
                 max_batch_size: 100,
             },
@@ -744,7 +740,6 @@ async fn taskprov_opt_out_peer_aggregator_wrong_role() {
         QueryConfig::new(
             Duration::from_seconds(1),
             100,
-            100,
             TaskprovQuery::LeaderSelected {
                 max_batch_size: 100,
             },
@@ -825,7 +820,6 @@ async fn taskprov_opt_out_peer_aggregator_does_not_exist() {
         QueryConfig::new(
             Duration::from_seconds(1),
             100,
-            100,
             TaskprovQuery::LeaderSelected {
                 max_batch_size: 100,
             },
diff --git a/aggregator/src/binaries/janus_cli.rs b/aggregator/src/binaries/janus_cli.rs
index 502420d0a..253e0c4d4 100644
--- a/aggregator/src/binaries/janus_cli.rs
+++ b/aggregator/src/binaries/janus_cli.rs
@@ -1345,7 +1345,6 @@ mod tests {
     bits: 2
   role: Leader
   vdaf_verify_key:
-  max_batch_query_count: 1
   task_expiration: 9000000000
   min_batch_size: 10
   time_precision: 300
@@ -1369,7 +1368,6 @@ mod tests {
     bits: 2
   role: Helper
   vdaf_verify_key:
-  max_batch_query_count: 1
   task_expiration: 9000000000
   min_batch_size: 10
   time_precision: 300
diff --git a/aggregator_api/src/models.rs b/aggregator_api/src/models.rs
index 8085164c5..749dcfc60 100644
--- a/aggregator_api/src/models.rs
+++ b/aggregator_api/src/models.rs
@@ -74,8 +74,6 @@ pub(crate) struct PostTaskReq {
     /// The VDAF verification key used for this DAP task, as Base64 encoded bytes. Task ID is
     /// derived from the verify key.
     pub(crate) vdaf_verify_key: String,
-    /// The maximum number of times a given batch may be collected.
-    pub(crate) max_batch_query_count: u64,
     /// The time after which the task is considered invalid.
     pub(crate) task_expiration: Option<Time>,
     /// The minimum number of reports in a batch to allow it to be collected.
@@ -118,8 +116,6 @@ pub(crate) struct TaskResp {
     /// The VDAF verification key used for this DAP task, as Base64 encoded bytes. Task ID is
     /// derived from the verify key.
     pub(crate) vdaf_verify_key: String,
-    /// The maximum number of times a given batch may be collected.
-    pub(crate) max_batch_query_count: u64,
     /// The time after which the task is considered invalid.
     pub(crate) task_expiration: Option<Time>,
     /// The age after which a report is considered to be "expired" and will be considered a
@@ -160,7 +156,6 @@ impl TryFrom<&AggregatorTask> for TaskResp {
             vdaf: task.vdaf().clone(),
             role: *task.role(),
             vdaf_verify_key: URL_SAFE_NO_PAD.encode(task.opaque_vdaf_verify_key().as_ref()),
-            max_batch_query_count: task.max_batch_query_count(),
             task_expiration: task.task_expiration().copied(),
             report_expiry_age: task.report_expiry_age().cloned(),
             min_batch_size: task.min_batch_size(),
diff --git a/aggregator_api/src/routes.rs b/aggregator_api/src/routes.rs
index 8d37cc244..60365e7a8 100644
--- a/aggregator_api/src/routes.rs
+++ b/aggregator_api/src/routes.rs
@@ -173,7 +173,6 @@ pub(super) async fn post_task<C: Clock>(
             /* batch_mode */ req.batch_mode,
             /* vdaf */ req.vdaf,
             vdaf_verify_key,
-            /* max_batch_query_count */ req.max_batch_query_count,
             /* task_expiration */ req.task_expiration,
             /* report_expiry_age */
             Some(Duration::from_seconds(3600 * 24 * 7 * 2)), // 2 weeks
@@ -206,7 +205,6 @@ pub(super) async fn post_task<C: Clock>(
                 && existing_task.vdaf() == task.vdaf()
                 && existing_task.opaque_vdaf_verify_key() == task.opaque_vdaf_verify_key()
                 && existing_task.role() == task.role()
-                && existing_task.max_batch_query_count() == task.max_batch_query_count()
                 && existing_task.task_expiration() == task.task_expiration()
                 && existing_task.min_batch_size() == task.min_batch_size()
                 && existing_task.time_precision() == task.time_precision()
diff --git a/aggregator_api/src/tests.rs b/aggregator_api/src/tests.rs
index c65c451c6..09ff27874 100644
--- a/aggregator_api/src/tests.rs
+++ b/aggregator_api/src/tests.rs
@@ -193,7 +193,6 @@ async fn post_task_bad_role() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Collector,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -227,7 +226,6 @@ async fn post_task_unauthorized() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Helper,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -262,7 +260,6 @@ async fn post_task_helper_no_optional_fields() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Helper,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -312,7 +309,6 @@ async fn post_task_helper_no_optional_fields() {
     assert_eq!(&req.batch_mode, got_task.batch_mode());
     assert_eq!(&req.vdaf, got_task.vdaf());
     assert_eq!(&req.role, got_task.role());
-    assert_eq!(req.max_batch_query_count, got_task.max_batch_query_count());
     assert_eq!(req.task_expiration.as_ref(), got_task.task_expiration());
     assert_eq!(req.min_batch_size, got_task.min_batch_size());
     assert_eq!(&req.time_precision, got_task.time_precision());
@@ -344,7 +340,6 @@ async fn post_task_helper_with_aggregator_auth_token() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Helper,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -380,7 +375,6 @@ async fn post_task_idempotence() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Leader,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -428,7 +422,7 @@ async fn post_task_idempotence() {
     assert_eq!(got_tasks[0].id(), &first_task_resp.task_id);
 
     // Mutate the PostTaskReq and re-send it.
-    req.max_batch_query_count = 10;
+    req.min_batch_size = 332;
     let conn = post("/tasks")
         .with_request_body(serde_json::to_vec(&req).unwrap())
         .with_request_header("Authorization", format!("Bearer {AUTH_TOKEN}"))
@@ -455,7 +449,6 @@ async fn post_task_leader_all_optional_fields() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Leader,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -499,7 +492,6 @@ async fn post_task_leader_all_optional_fields() {
     assert_eq!(&req.vdaf, got_task.vdaf());
     assert_eq!(&req.role, got_task.role());
     assert_eq!(&vdaf_verify_key, got_task.opaque_vdaf_verify_key());
-    assert_eq!(req.max_batch_query_count, got_task.max_batch_query_count());
     assert_eq!(req.task_expiration.as_ref(), got_task.task_expiration());
     assert_eq!(req.min_batch_size, got_task.min_batch_size());
     assert_eq!(&req.time_precision, got_task.time_precision());
@@ -535,7 +527,6 @@ async fn post_task_leader_no_aggregator_auth_token() {
         vdaf: VdafInstance::Prio3Count,
         role: Role::Leader,
         vdaf_verify_key: URL_SAFE_NO_PAD.encode(&vdaf_verify_key),
-        max_batch_query_count: 12,
         task_expiration: Some(Time::from_seconds_since_epoch(12345)),
         min_batch_size: 223,
         time_precision: Duration::from_seconds(62),
@@ -1667,7 +1658,6 @@ fn post_task_req_serialization() {
             },
             role: Role::Helper,
             vdaf_verify_key: "encoded".to_owned(),
-            max_batch_query_count: 1,
             task_expiration: None,
             min_batch_size: 100,
             time_precision: Duration::from_seconds(3600),
@@ -1684,7 +1674,7 @@ fn post_task_req_serialization() {
         &[
             Token::Struct {
                 name: "PostTaskReq",
-                len: 12,
+                len: 11,
             },
             Token::Str("peer_aggregator_endpoint"),
             Token::Str("https://example.com/"),
@@ -1728,8 +1718,6 @@ fn post_task_req_serialization() {
             },
             Token::Str("vdaf_verify_key"),
             Token::Str("encoded"),
-            Token::Str("max_batch_query_count"),
-            Token::U64(1),
             Token::Str("task_expiration"),
             Token::None,
             Token::Str("min_batch_size"),
@@ -1789,7 +1777,6 @@ fn post_task_req_serialization() {
             },
             role: Role::Leader,
             vdaf_verify_key: "encoded".to_owned(),
-            max_batch_query_count: 1,
             task_expiration: Some(Time::from_seconds_since_epoch(1000)),
             min_batch_size: 100,
             time_precision: Duration::from_seconds(3600),
@@ -1810,7 +1797,7 @@ fn post_task_req_serialization() {
         &[
             Token::Struct {
                 name: "PostTaskReq",
-                len: 12,
+                len: 11,
             },
             Token::Str("peer_aggregator_endpoint"),
             Token::Str("https://example.com/"),
@@ -1854,8 +1841,6 @@ fn post_task_req_serialization() {
             },
             Token::Str("vdaf_verify_key"),
             Token::Str("encoded"),
-            Token::Str("max_batch_query_count"),
-            Token::U64(1),
             Token::Str("task_expiration"),
             Token::Some,
             Token::NewtypeStruct { name: "Time" },
@@ -1942,7 +1927,6 @@ fn task_resp_serialization() {
             dp_strategy: vdaf_dp_strategies::Prio3SumVec::NoDifferentialPrivacy,
         },
         SecretBytes::new(b"vdaf verify key!".to_vec()),
-        1,
         None,
         None,
         100,
@@ -1982,7 +1966,7 @@ fn task_resp_serialization() {
         &[
             Token::Struct {
                 name: "TaskResp",
-                len: 15,
+                len: 14,
             },
             Token::Str("task_id"),
             Token::Str("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"),
@@ -2028,8 +2012,6 @@ fn task_resp_serialization() {
             },
             Token::Str("vdaf_verify_key"),
             Token::Str("dmRhZiB2ZXJpZnkga2V5IQ"),
-            Token::Str("max_batch_query_count"),
-            Token::U64(1),
             Token::Str("task_expiration"),
             Token::None,
             Token::Str("report_expiry_age"),
diff --git a/aggregator_core/src/batch_mode.rs b/aggregator_core/src/batch_mode.rs
index bcca8ffff..dd5022f66 100644
--- a/aggregator_core/src/batch_mode.rs
+++ b/aggregator_core/src/batch_mode.rs
@@ -11,7 +11,7 @@ use futures::future::try_join_all;
 use janus_core::time::{Clock, IntervalExt as _, TimeExt as _};
 use janus_messages::{
     batch_mode::{BatchMode, LeaderSelected, TimeInterval},
-    Duration, Interval, LeaderSelectedQuery, Query, TaskId, Time,
+    Duration, Interval, Query, TaskId, Time,
 };
 use prio::vdaf;
 use std::iter;
@@ -398,15 +398,10 @@ impl CollectableBatchMode for LeaderSelected {
     async fn collection_identifier_for_query<C: Clock>(
         tx: &Transaction<'_, C>,
         task: &AggregatorTask,
-        query: &Query<Self>,
+        _: &Query<Self>,
     ) -> Result<Option<Self::BatchIdentifier>, datastore::Error> {
-        match query.leader_selected_query() {
-            LeaderSelectedQuery::ByBatchId { batch_id } => Ok(Some(*batch_id)),
-            LeaderSelectedQuery::CurrentBatch => {
-                tx.acquire_outstanding_batch_with_report_count(task.id(), task.min_batch_size())
-                    .await
-            }
-        }
+        tx.acquire_outstanding_batch_with_report_count(task.id(), task.min_batch_size())
+            .await
     }
 
     fn batch_identifiers_for_collection_identifier(
diff --git a/aggregator_core/src/datastore.rs b/aggregator_core/src/datastore.rs
index ad37c27f3..ce53e1ad9 100644
--- a/aggregator_core/src/datastore.rs
+++ b/aggregator_core/src/datastore.rs
@@ -647,14 +647,14 @@ WHERE success = TRUE ORDER BY version DESC LIMIT(1)",
                 "-- put_aggregator_task()
 INSERT INTO tasks (
     task_id, aggregator_role, peer_aggregator_endpoint, batch_mode, vdaf,
-    max_batch_query_count, task_expiration, report_expiry_age, min_batch_size,
-    time_precision, tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
+    task_expiration, report_expiry_age, min_batch_size, time_precision,
+    tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
     taskprov_task_info, aggregator_auth_token_type, aggregator_auth_token,
     aggregator_auth_token_hash, collector_auth_token_type,
     collector_auth_token_hash, created_at, updated_at, updated_by)
 VALUES (
     $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18,
-    $19, $20, $21, $22
+    $19, $20, $21
 )
 ON CONFLICT DO NOTHING",
             )
@@ -669,8 +669,6 @@ ON CONFLICT DO NOTHING",
                     &task.peer_aggregator_endpoint().as_str(),
                     /* batch_mode */ &Json(task.batch_mode()),
                     /* vdaf */ &Json(task.vdaf()),
-                    /* max_batch_query_count */
-                    &i64::try_from(task.max_batch_query_count())?,
                     /* task_expiration */
                     &task
                         .task_expiration()
@@ -845,8 +843,8 @@ UPDATE tasks SET task_expiration = $1, updated_at = $2, updated_by = $3
             .prepare_cached(
                 "-- get_aggregator_task()
 SELECT aggregator_role, peer_aggregator_endpoint, batch_mode, vdaf,
-    max_batch_query_count, task_expiration, report_expiry_age, min_batch_size,
-    time_precision, tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
+    task_expiration, report_expiry_age, min_batch_size, time_precision,
+    tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
     taskprov_task_info, aggregator_auth_token_type, aggregator_auth_token,
     aggregator_auth_token_hash, collector_auth_token_type, collector_auth_token_hash
 FROM tasks WHERE task_id = $1",
@@ -876,8 +874,8 @@ WHERE task_id = (SELECT id FROM tasks WHERE task_id = $1)",
             .prepare_cached(
                 "-- get_aggregator_tasks()
 SELECT task_id, aggregator_role, peer_aggregator_endpoint, batch_mode, vdaf,
-    max_batch_query_count, task_expiration, report_expiry_age, min_batch_size,
-    time_precision, tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
+    task_expiration, report_expiry_age, min_batch_size, time_precision,
+    tolerable_clock_skew, collector_hpke_config, vdaf_verify_key,
     taskprov_task_info, aggregator_auth_token_type, aggregator_auth_token,
     aggregator_auth_token_hash, collector_auth_token_type, collector_auth_token_hash
 FROM tasks",
@@ -938,7 +936,6 @@ config_id, config, private_key FROM task_hpke_keys",
         let peer_aggregator_endpoint = row.get::<_, String>("peer_aggregator_endpoint").parse()?;
         let batch_mode = row.try_get::<_, Json<task::BatchMode>>("batch_mode")?.0;
         let vdaf = row.try_get::<_, Json<VdafInstance>>("vdaf")?.0;
-        let max_batch_query_count = row.get_bigint_and_convert("max_batch_query_count")?;
         let task_expiration = row
             .get::<_, Option<NaiveDateTime>>("task_expiration")
             .as_ref()
@@ -1059,7 +1056,6 @@ config_id, config, private_key FROM task_hpke_keys",
             batch_mode,
             vdaf,
             vdaf_verify_key,
-            max_batch_query_count,
             task_expiration,
             report_expiry_age,
             min_batch_size,
diff --git a/aggregator_core/src/datastore/tests.rs b/aggregator_core/src/datastore/tests.rs
index 608ba263b..d3fbee723 100644
--- a/aggregator_core/src/datastore/tests.rs
+++ b/aggregator_core/src/datastore/tests.rs
@@ -34,8 +34,8 @@ use janus_messages::{
     batch_mode::{BatchMode, LeaderSelected, TimeInterval},
     AggregateShareAad, AggregationJobId, AggregationJobStep, BatchId, BatchSelector,
     CollectionJobId, Duration, Extension, ExtensionType, HpkeCiphertext, HpkeConfigId, Interval,
-    LeaderSelectedQuery, PrepareResp, PrepareStepResult, Query, ReportError, ReportId,
-    ReportIdChecksum, ReportMetadata, ReportShare, Role, TaskId, Time,
+    PrepareResp, PrepareStepResult, Query, ReportError, ReportId, ReportIdChecksum, ReportMetadata,
+    ReportShare, Role, TaskId, Time,
 };
 use prio::{
     codec::{Decode, Encode},
@@ -3336,8 +3336,7 @@ impl TestBatchModeExt for TimeInterval {
 #[async_trait]
 impl TestBatchModeExt for LeaderSelected {
     fn query_for_batch_identifier(_: &Self::BatchIdentifier) -> Query<Self> {
-        // We could also generate a by-batch-id query, but using current-batch is more realistic.
-        Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch)
+        Query::new_leader_selected()
     }
 
     fn batch_identifier_for_client_timestamps(_: &[Time]) -> Self::BatchIdentifier {
diff --git a/aggregator_core/src/task.rs b/aggregator_core/src/task.rs
index b20413dee..85b42eab6 100644
--- a/aggregator_core/src/task.rs
+++ b/aggregator_core/src/task.rs
@@ -116,8 +116,6 @@ struct CommonTaskParameters {
     vdaf: VdafInstance,
     /// Secret verification key shared by the aggregators.
     vdaf_verify_key: SecretBytes,
-    /// The maximum number of times a given batch may be collected.
-    max_batch_query_count: u64,
     /// The time after which the task is considered invalid.
     task_expiration: Option<Time>,
     /// The age after which a report is considered to be "expired" and will be considered a
@@ -147,7 +145,6 @@ impl CommonTaskParameters {
         batch_mode: BatchMode,
         vdaf: VdafInstance,
         vdaf_verify_key: SecretBytes,
-        max_batch_query_count: u64,
         task_expiration: Option<Time>,
         report_expiry_age: Option<Duration>,
         min_batch_size: u64,
@@ -194,7 +191,6 @@ impl CommonTaskParameters {
             batch_mode,
             vdaf,
             vdaf_verify_key,
-            max_batch_query_count,
             task_expiration,
             report_expiry_age,
             min_batch_size,
@@ -240,7 +236,6 @@ impl AggregatorTask {
         batch_mode: BatchMode,
         vdaf: VdafInstance,
         vdaf_verify_key: SecretBytes,
-        max_batch_query_count: u64,
         task_expiration: Option<Time>,
         report_expiry_age: Option<Duration>,
         min_batch_size: u64,
@@ -254,7 +249,6 @@ impl AggregatorTask {
             batch_mode,
             vdaf,
             vdaf_verify_key,
-            max_batch_query_count,
             task_expiration,
             report_expiry_age,
             min_batch_size,
@@ -347,11 +341,6 @@ impl AggregatorTask {
         &self.common_parameters.vdaf_verify_key
     }
 
-    /// Retrieves the max batch query count parameter associated with this task.
-    pub fn max_batch_query_count(&self) -> u64 {
-        self.common_parameters.max_batch_query_count
-    }
-
     /// Retrieves the task expiration associated with this task.
     pub fn task_expiration(&self) -> Option<&Time> {
         self.common_parameters.task_expiration.as_ref()
@@ -626,7 +615,6 @@ pub struct SerializedAggregatorTask {
     vdaf: VdafInstance,
     role: Role,
     vdaf_verify_key: Option<String>, // in unpadded base64url
-    max_batch_query_count: u64,
     task_expiration: Option<Time>,
     report_expiry_age: Option<Duration>,
     min_batch_size: u64,
@@ -699,7 +687,6 @@ impl Serialize for AggregatorTask {
             vdaf: self.vdaf().clone(),
             role: *self.role(),
             vdaf_verify_key: Some(URL_SAFE_NO_PAD.encode(self.opaque_vdaf_verify_key())),
-            max_batch_query_count: self.max_batch_query_count(),
             task_expiration: self.task_expiration().copied(),
             report_expiry_age: self.report_expiry_age().copied(),
             min_batch_size: self.min_batch_size(),
@@ -764,7 +751,6 @@ impl TryFrom<SerializedAggregatorTask> for AggregatorTask {
             serialized_task.batch_mode,
             serialized_task.vdaf,
             SecretBytes::new(URL_SAFE_NO_PAD.decode(vdaf_verify_key)?),
-            serialized_task.max_batch_query_count,
             serialized_task.task_expiration,
             serialized_task.report_expiry_age,
             serialized_task.min_batch_size,
@@ -845,7 +831,6 @@ pub mod test_util {
             batch_mode: BatchMode,
             vdaf: VdafInstance,
             vdaf_verify_key: SecretBytes,
-            max_batch_query_count: u64,
             task_expiration: Option<Time>,
             report_expiry_age: Option<Duration>,
             min_batch_size: u64,
@@ -874,7 +859,6 @@ pub mod test_util {
                     batch_mode,
                     vdaf,
                     vdaf_verify_key,
-                    max_batch_query_count,
                     task_expiration,
                     report_expiry_age,
                     min_batch_size,
@@ -925,11 +909,6 @@ pub mod test_util {
             &self.common_parameters.vdaf_verify_key
         }
 
-        /// Retrieves the max batch query count parameter associated with this task.
-        pub fn max_batch_query_count(&self) -> u64 {
-            self.common_parameters.max_batch_query_count
-        }
-
         /// Retrieves the task expiration associated with this task.
         pub fn task_expiration(&self) -> Option<&Time> {
             self.common_parameters.task_expiration.as_ref()
@@ -1109,7 +1088,6 @@ pub mod test_util {
                 batch_mode,
                 vdaf,
                 vdaf_verify_key,
-                1,
                 None,
                 None,
                 1,
@@ -1186,17 +1164,6 @@ pub mod test_util {
             })
         }
 
-        /// Associates the eventual task with the given max batch query count parameter.
-        pub fn with_max_batch_query_count(self, max_batch_query_count: u64) -> Self {
-            Self(Task {
-                common_parameters: CommonTaskParameters {
-                    max_batch_query_count,
-                    ..self.0.common_parameters
-                },
-                ..self.0
-            })
-        }
-
         /// Associates the eventual task with the given min batch size parameter.
         pub fn with_min_batch_size(self, min_batch_size: u64) -> Self {
             Self(Task {
@@ -1466,7 +1433,6 @@ mod tests {
                 BatchMode::TimeInterval,
                 VdafInstance::Prio3Count,
                 SecretBytes::new(b"1234567812345678".to_vec()),
-                1,
                 None,
                 None,
                 10,
@@ -1504,7 +1470,7 @@ mod tests {
             &[
                 Token::Struct {
                     name: "SerializedAggregatorTask",
-                    len: 17,
+                    len: 16,
                 },
                 Token::Str("task_id"),
                 Token::Some,
@@ -1529,8 +1495,6 @@ mod tests {
                 Token::Str("vdaf_verify_key"),
                 Token::Some,
                 Token::Str("MTIzNDU2NzgxMjM0NTY3OA"),
-                Token::Str("max_batch_query_count"),
-                Token::U64(1),
                 Token::Str("task_expiration"),
                 Token::None,
                 Token::Str("report_expiry_age"),
@@ -1658,7 +1622,6 @@ mod tests {
                     dp_strategy: vdaf_dp_strategies::Prio3SumVec::NoDifferentialPrivacy,
                 },
                 SecretBytes::new(b"1234567812345678".to_vec()),
-                1,
                 None,
                 Some(Duration::from_seconds(1800)),
                 10,
@@ -1694,7 +1657,7 @@ mod tests {
             &[
                 Token::Struct {
                     name: "SerializedAggregatorTask",
-                    len: 17,
+                    len: 16,
                 },
                 Token::Str("task_id"),
                 Token::Some,
@@ -1742,8 +1705,6 @@ mod tests {
                 Token::Str("vdaf_verify_key"),
                 Token::Some,
                 Token::Str("MTIzNDU2NzgxMjM0NTY3OA"),
-                Token::Str("max_batch_query_count"),
-                Token::U64(1),
                 Token::Str("task_expiration"),
                 Token::None,
                 Token::Str("report_expiry_age"),
diff --git a/collector/src/lib.rs b/collector/src/lib.rs
index d33435d59..9fa8a7c26 100644
--- a/collector/src/lib.rs
+++ b/collector/src/lib.rs
@@ -12,7 +12,7 @@
 //! use std::{fs::File, str::FromStr};
 //!
 //! use janus_collector::{Collector, PrivateCollectorCredential};
-//! use janus_messages::{Duration, LeaderSelectedQuery, Interval, Query, TaskId, Time};
+//! use janus_messages::{Duration, Interval, Query, TaskId, Time};
 //! use prio::vdaf::prio3::Prio3;
 //! use url::Url;
 //!
@@ -54,7 +54,7 @@
 //!     .unwrap();
 //!
 //! // Or if this is a leader-selected task, make a leader-selected query.
-//! let query = Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch);
+//! let query = Query::new_leader_selected();
 //! let aggregation_result = collector.collect(query, &()).await.unwrap();
 //! # }
 //! ```
@@ -771,8 +771,8 @@ mod tests {
         batch_mode::{LeaderSelected, TimeInterval},
         problem_type::DapProblemType,
         AggregateShareAad, BatchId, BatchSelector, Collection as CollectionMessage,
-        CollectionJobId, CollectionReq, Duration, HpkeCiphertext, Interval, LeaderSelectedQuery,
-        PartialBatchSelector, Query, Role, TaskId, Time,
+        CollectionJobId, CollectionReq, Duration, HpkeCiphertext, Interval, PartialBatchSelector,
+        Query, Role, TaskId, Time,
     };
     use mockito::Matcher;
     use prio::{
@@ -1250,16 +1250,9 @@ mod tests {
             .await;
 
         let job = collector
-            .start_collection(
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-                &(),
-            )
+            .start_collection(Query::new_leader_selected(), &())
             .await
             .unwrap();
-        assert_eq!(
-            job.query.leader_selected_query(),
-            &LeaderSelectedQuery::ByBatchId { batch_id }
-        );
 
         mocked_collect_start_success.assert_async().await;
 
@@ -1897,7 +1890,7 @@ mod tests {
         let collection_job_id = random();
         let collection_job = CollectionJob::new(
             collection_job_id,
-            Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id: random() }),
+            Query::new_leader_selected(),
             dummy::AggregationParam(1),
         );
         let matcher = collection_uri_regex_matcher(&collector.task_id);
@@ -1934,7 +1927,7 @@ mod tests {
         let collection_job_id = random();
         let collection_job = CollectionJob::new(
             collection_job_id,
-            Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id: random() }),
+            Query::new_leader_selected(),
             dummy::AggregationParam(1),
         );
         let matcher = collection_uri_regex_matcher(&collector.task_id);
diff --git a/db/00000000000001_initial_schema.up.sql b/db/00000000000001_initial_schema.up.sql
index aa0822249..b24b27af9 100644
--- a/db/00000000000001_initial_schema.up.sql
+++ b/db/00000000000001_initial_schema.up.sql
@@ -98,7 +98,6 @@ CREATE TABLE tasks(
     peer_aggregator_endpoint    TEXT NOT NULL,             -- peer aggregator's API endpoint
     batch_mode                  JSONB NOT NULL,            -- the batch mode in use for this task, along with its parameters
     vdaf                        JSON NOT NULL,             -- the VDAF instance in use for this task, along with its parameters
-    max_batch_query_count       BIGINT NOT NULL,           -- the maximum number of times a given batch may be collected
     task_expiration             TIMESTAMP,                 -- the time after which client reports are no longer accepted
     report_expiry_age           BIGINT,                    -- the maximum age of a report before it is considered expired (and acceptable for garbage collection), in seconds. NULL means that GC is disabled.
     min_batch_size              BIGINT NOT NULL,           -- the minimum number of reports in a batch to allow it to be collected
diff --git a/docs/samples/tasks.yaml b/docs/samples/tasks.yaml
index 81a9c620b..49474d7da 100644
--- a/docs/samples/tasks.yaml
+++ b/docs/samples/tasks.yaml
@@ -24,9 +24,6 @@
   # determined by the task's VDAF.
   vdaf_verify_key: "1CmuYNtBLYIoXN8bU0T_XA"
 
-  # The maximum number of times any report can be collected.
-  max_batch_query_count: 1
-
   # The task's expiration time, as a number of seconds after the Unix epoch.
   task_expiration: 1704088800
 
@@ -105,7 +102,6 @@
   vdaf: Prio3Count
   role: Helper
   vdaf_verify_key: "ZXtE4kLqtsCOr8h_pNUeoQ"
-  max_batch_query_count: 1
   task_expiration: 1704088800
   report_expiry_age: null
   min_batch_size: 100
diff --git a/integration_tests/tests/integration/common.rs b/integration_tests/tests/integration/common.rs
index e829c2012..6cc4cf139 100644
--- a/integration_tests/tests/integration/common.rs
+++ b/integration_tests/tests/integration/common.rs
@@ -14,11 +14,11 @@ use janus_integration_tests::{
 use janus_messages::{
     batch_mode::{self, LeaderSelected},
     problem_type::DapProblemType,
-    Duration, Interval, LeaderSelectedQuery, Query, Time,
+    Duration, Interval, Query, Time,
 };
 use prio::{
     flp::gadgets::ParallelSumMultithreaded,
-    vdaf::{self, dummy, prio3::Prio3},
+    vdaf::{self, prio3::Prio3},
 };
 use rand::{random, thread_rng, Rng};
 use std::{iter, time::Duration as StdDuration};
@@ -314,13 +314,14 @@ where
                 collection_2.aggregate_result().clone(),
             )
         }
+
         BatchMode::LeaderSelected { .. } => {
             let mut requests = 0;
-            let collection_1 = loop {
+            let collection = loop {
                 requests += 1;
                 let collection_res = collect_generic::<_, LeaderSelected>(
                     &collector,
-                    Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch),
+                    Query::new_leader_selected(),
                     aggregation_parameter,
                 )
                 .await;
@@ -339,26 +340,9 @@ where
                 }
             };
 
-            let batch_id = *collection_1.partial_batch_selector().batch_id();
-
-            // Collect again to verify that collections can be repeated.
-            let collection_2 = collect_generic(
-                &collector,
-                Query::new_leader_selected(LeaderSelectedQuery::ByBatchId { batch_id }),
-                aggregation_parameter,
-            )
-            .await
-            .unwrap();
-
-            assert_eq!(collection_1.report_count(), collection_2.report_count());
-            assert_eq!(
-                collection_1.aggregate_result(),
-                collection_2.aggregate_result()
-            );
-
             (
-                collection_2.report_count(),
-                collection_2.aggregate_result().clone(),
+                collection.report_count(),
+                collection.aggregate_result().clone(),
             )
         }
     };
@@ -588,58 +572,3 @@ pub async fn submit_measurements_and_verify_aggregate(
         _ => panic!("Unsupported VdafInstance: {:?}", task_parameters.vdaf),
     }
 }
-
-pub async fn submit_measurements_and_verify_aggregate_varying_aggregation_parameter(
-    test_name: &str,
-    task_parameters: &TaskParameters,
-    aggregation_parameters: &[dummy::AggregationParam],
-    (leader_port, helper_port): (u16, u16),
-    client_backend: &ClientBackend<'_>,
-) {
-    // We generate exactly one batch's worth of measurement uploads.
-    let total_measurements: usize = task_parameters.min_batch_size.try_into().unwrap();
-
-    match &task_parameters.vdaf {
-        VdafInstance::Fake { rounds } => {
-            let vdaf = dummy::Vdaf::new(*rounds);
-            let client_implementation = client_backend
-                .build(
-                    test_name,
-                    task_parameters,
-                    (leader_port, helper_port),
-                    vdaf.clone(),
-                )
-                .await
-                .unwrap();
-
-            let measurements = iter::repeat_with(random::<u8>)
-                .take(total_measurements)
-                .collect::<Vec<_>>();
-
-            let before_timestamp =
-                submit_measurements_generic(&measurements, &client_implementation).await;
-
-            for aggregation_parameter in aggregation_parameters {
-                let aggregate_result = measurements.iter().map(|m| u64::from(*m)).sum::<u64>()
-                    % (u64::from(u8::MAX) + 1)
-                    + u64::from(aggregation_parameter.0);
-
-                let test_case = AggregationTestCase {
-                    measurements: measurements.clone(),
-                    aggregation_parameter: *aggregation_parameter,
-                    aggregate_result,
-                };
-
-                verify_aggregate_generic(
-                    task_parameters,
-                    leader_port,
-                    vdaf.clone(),
-                    &test_case,
-                    before_timestamp,
-                )
-                .await;
-            }
-        }
-        _ => panic!("Unsupported VdafInstance: {:?}", task_parameters.vdaf),
-    }
-}
diff --git a/integration_tests/tests/integration/janus.rs b/integration_tests/tests/integration/janus.rs
index 59d22626f..015d12c1f 100644
--- a/integration_tests/tests/integration/janus.rs
+++ b/integration_tests/tests/integration/janus.rs
@@ -1,9 +1,7 @@
 use crate::{
     common::{
         build_test_task, collect_aggregate_result_generic,
-        submit_measurements_and_verify_aggregate,
-        submit_measurements_and_verify_aggregate_varying_aggregation_parameter,
-        submit_measurements_generic, TestContext,
+        submit_measurements_and_verify_aggregate, submit_measurements_generic, TestContext,
     },
     initialize_rustls,
 };
@@ -23,7 +21,7 @@ use prio::{
         distributions::PureDpDiscreteLaplace, DifferentialPrivacyStrategy, PureDpBudget, Rational,
     },
     field::{Field128, FieldElementWithInteger},
-    vdaf::{dummy, prio3::Prio3},
+    vdaf::prio3::Prio3,
 };
 use std::{iter, time::Duration};
 
@@ -397,69 +395,6 @@ async fn janus_in_process_customized_sum_vec() {
     .await;
 }
 
-/// This test exercises a 1-round VDAF with an aggregation parameter.
-#[tokio::test(flavor = "multi_thread")]
-#[ignore = "leader-selected with agg param not yet supported (#225)"]
-async fn janus_in_process_one_round_with_agg_param_leader_selected() {
-    install_test_trace_subscriber();
-    initialize_rustls();
-
-    let janus_pair = JanusInProcessPair::new(
-        TaskBuilder::new(
-            BatchMode::LeaderSelected {
-                max_batch_size: Some(50),
-                batch_time_window_size: None,
-            },
-            VdafInstance::Fake { rounds: 1 },
-        )
-        .with_max_batch_query_count(3),
-    )
-    .await;
-
-    submit_measurements_and_verify_aggregate_varying_aggregation_parameter(
-        "janus_in_process_one_round_with_agg_param_leader_selected",
-        &janus_pair.task_parameters,
-        &[
-            dummy::AggregationParam(10),
-            // TODO(#225): Querying a single batch multiple times doesn't work yet, failing with
-            // "invalid number of reports (0)"
-            // dummy::AggregationParam(11),
-            // dummy::AggregationParam(12),
-        ],
-        (janus_pair.leader.port(), janus_pair.helper.port()),
-        &ClientBackend::InProcess,
-    )
-    .await;
-}
-
-/// This test exercises a 1-round VDAF with an aggregation parameter.
-#[tokio::test(flavor = "multi_thread")]
-async fn janus_in_process_one_round_with_agg_param_time_interval() {
-    install_test_trace_subscriber();
-    initialize_rustls();
-
-    let janus_pair = JanusInProcessPair::new(
-        TaskBuilder::new(BatchMode::TimeInterval, VdafInstance::Fake { rounds: 1 })
-            .with_max_batch_query_count(3),
-    )
-    .await;
-
-    submit_measurements_and_verify_aggregate_varying_aggregation_parameter(
-        "janus_in_process_one_round_with_agg_param_time_interval",
-        &janus_pair.task_parameters,
-        &[
-            dummy::AggregationParam(10),
-            // TODO(#225): Querying a single batch multiple times doesn't work yet, failing with
-            // "invalid number of reports (0)"
-            // dummy::AggregationParam(11),
-            // dummy::AggregationParam(12),
-        ],
-        (janus_pair.leader.port(), janus_pair.helper.port()),
-        &ClientBackend::InProcess,
-    )
-    .await;
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn janus_in_process_histogram_dp_noise() {
     static TEST_NAME: &str = "janus_in_process_histogram_dp_noise";
diff --git a/integration_tests/tests/integration/simulation/arbitrary.rs b/integration_tests/tests/integration/simulation/arbitrary.rs
index 1ed34cf6d..84be59344 100644
--- a/integration_tests/tests/integration/simulation/arbitrary.rs
+++ b/integration_tests/tests/integration/simulation/arbitrary.rs
@@ -289,22 +289,6 @@ fn arbitrary_collector_start_op_time_interval(g: &mut Gen, context: &Context) ->
     }
 }
 
-fn arbitrary_collector_start_op_leader_selected(g: &mut Gen, context: &Context) -> Op {
-    if context.polled_collection_job_ids.is_empty() || bool::arbitrary(g) {
-        Op::CollectorStart {
-            collection_job_id: random(),
-            query: super::model::Query::LeaderSelectedCurrentBatch,
-        }
-    } else {
-        Op::CollectorStart {
-            collection_job_id: random(),
-            query: super::model::Query::LeaderSelectedByBatchId(
-                *g.choose(&context.polled_collection_job_ids).unwrap(),
-            ),
-        }
-    }
-}
-
 /// Generate a collect poll operation.
 fn arbitrary_collector_poll_op(g: &mut Gen, context: &Context) -> Op {
     Op::CollectorPoll {
@@ -478,7 +462,10 @@ fn arbitrary_op_leader_selected(g: &mut Gen, context: &Context, choices: &[OpKin
         OpKind::CollectionJobDriver => Op::CollectionJobDriver,
         OpKind::CollectionJobDriverRequestError => Op::CollectionJobDriverRequestError,
         OpKind::CollectionJobDriverResponseError => Op::CollectionJobDriverResponseError,
-        OpKind::CollectorStart => arbitrary_collector_start_op_leader_selected(g, context),
+        OpKind::CollectorStart => Op::CollectorStart {
+            collection_job_id: random(),
+            query: super::model::Query::LeaderSelected,
+        },
         OpKind::CollectorPoll => arbitrary_collector_poll_op(g, context),
     }
 }
diff --git a/integration_tests/tests/integration/simulation/model.rs b/integration_tests/tests/integration/simulation/model.rs
index f32cf06e3..ab1ec302f 100644
--- a/integration_tests/tests/integration/simulation/model.rs
+++ b/integration_tests/tests/integration/simulation/model.rs
@@ -117,9 +117,6 @@ pub(super) enum Op {
 pub(super) enum Query {
     /// A time interval query, parameterized with a batch interval.
     TimeInterval(Interval),
-    /// A current batch query.
-    LeaderSelectedCurrentBatch,
-    /// A "by batch ID" query. The batch ID will be taken from a previous collection result, with
-    /// the given collection job ID.
-    LeaderSelectedByBatchId(CollectionJobId),
+    /// A leader-selected query.
+    LeaderSelected,
 }
diff --git a/integration_tests/tests/integration/simulation/reproduction.rs b/integration_tests/tests/integration/simulation/reproduction.rs
index 6d1870550..b11495c44 100644
--- a/integration_tests/tests/integration/simulation/reproduction.rs
+++ b/integration_tests/tests/integration/simulation/reproduction.rs
@@ -121,7 +121,7 @@ fn successful_collection_leader_selected() {
             Op::LeaderGarbageCollector,
             Op::CollectorStart {
                 collection_job_id,
-                query: Query::LeaderSelectedCurrentBatch,
+                query: Query::LeaderSelected,
             },
             Op::CollectionJobDriver,
             Op::CollectorPoll { collection_job_id },
@@ -133,7 +133,7 @@ fn successful_collection_leader_selected() {
             Op::AggregationJobDriver,
             Op::CollectorStart {
                 collection_job_id,
-                query: Query::LeaderSelectedCurrentBatch,
+                query: Query::LeaderSelected,
             },
             Op::CollectionJobDriver,
             Op::CollectorPoll { collection_job_id },
@@ -198,7 +198,7 @@ fn repro_slow_uploads_with_max_batch_size() {
             Op::AggregationJobDriver,
             Op::CollectorStart {
                 collection_job_id,
-                query: Query::LeaderSelectedCurrentBatch,
+                query: Query::LeaderSelected,
             },
             Op::CollectionJobDriver,
             Op::CollectorPoll { collection_job_id },
diff --git a/integration_tests/tests/integration/simulation/run.rs b/integration_tests/tests/integration/simulation/run.rs
index 34afd6085..2dfc4f56e 100644
--- a/integration_tests/tests/integration/simulation/run.rs
+++ b/integration_tests/tests/integration/simulation/run.rs
@@ -22,7 +22,7 @@ use janus_core::{
 };
 use janus_messages::{
     batch_mode::{LeaderSelected, TimeInterval},
-    CollectionJobId, Duration, LeaderSelectedQuery, Time,
+    CollectionJobId, Duration, Time,
 };
 use opentelemetry::metrics::Meter;
 use prio::vdaf::prio3::{optimal_chunk_length, Prio3, Prio3Histogram};
@@ -411,9 +411,8 @@ impl Simulation {
                     Err(error) => info!(?error, "collector error"),
                 }
             }
-            Query::LeaderSelectedCurrentBatch => {
-                let query =
-                    janus_messages::Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch);
+            Query::LeaderSelected => {
+                let query = janus_messages::Query::new_leader_selected();
                 match self
                     .components
                     .collector
@@ -428,46 +427,6 @@ impl Simulation {
                     Err(error) => info!(?error, "collector error"),
                 }
             }
-            Query::LeaderSelectedByBatchId(previous_collection_job_id) => {
-                if let Some(collection) = self
-                    .state
-                    .aggregate_results_leader_selected
-                    .get(previous_collection_job_id)
-                {
-                    let query = janus_messages::Query::new_leader_selected(
-                        LeaderSelectedQuery::ByBatchId {
-                            batch_id: *collection.partial_batch_selector().batch_id(),
-                        },
-                    );
-                    match self
-                        .components
-                        .collector
-                        .start_collection_with_id(*collection_job_id, query, &())
-                        .await
-                    {
-                        Ok(collection_job) => {
-                            self.state
-                                .collection_jobs_leader_selected
-                                .insert(*collection_job_id, collection_job);
-
-                            // Store a copy of the collection results from the previous collection
-                            // job under this new collection job as well. When we get results from
-                            // pollng the "by batch ID" job, we will then compare results from the
-                            // two jobs to ensure they are the same.
-                            self.state.aggregate_results_leader_selected.insert(
-                                *collection_job_id,
-                                Collection::new(
-                                    collection.partial_batch_selector().clone(),
-                                    collection.report_count(),
-                                    *collection.interval(),
-                                    collection.aggregate_result().clone(),
-                                ),
-                            );
-                        }
-                        Err(error) => info!(?error, "collector error"),
-                    }
-                }
-            }
         }
         ControlFlow::Continue(())
     }
diff --git a/interop_binaries/src/commands/janus_interop_aggregator.rs b/interop_binaries/src/commands/janus_interop_aggregator.rs
index a355fcf84..3989e6134 100644
--- a/interop_binaries/src/commands/janus_interop_aggregator.rs
+++ b/interop_binaries/src/commands/janus_interop_aggregator.rs
@@ -107,7 +107,6 @@ async fn handle_add_task(
         batch_mode,
         vdaf,
         vdaf_verify_key,
-        request.max_batch_query_count,
         request.task_expiration.map(Time::from_seconds_since_epoch),
         None,
         request.min_batch_size,
diff --git a/interop_binaries/src/commands/janus_interop_collector.rs b/interop_binaries/src/commands/janus_interop_collector.rs
index d9044fd64..edc0dcef4 100644
--- a/interop_binaries/src/commands/janus_interop_collector.rs
+++ b/interop_binaries/src/commands/janus_interop_collector.rs
@@ -18,8 +18,8 @@ use janus_core::vdaf::new_prio3_sum_vec_field64_multiproof_hmacsha256_aes128;
 use janus_core::vdaf::Prio3FixedPointBoundedL2VecSumBitSize;
 use janus_core::{auth_tokens::AuthenticationToken, hpke::HpkeKeypair, vdaf::VdafInstance};
 use janus_messages::{
-    batch_mode::BatchMode, BatchId, Duration, HpkeConfig, Interval, LeaderSelectedQuery,
-    PartialBatchSelector, Query, TaskId, Time,
+    batch_mode::BatchMode, BatchId, Duration, HpkeConfig, Interval, PartialBatchSelector, Query,
+    TaskId, Time,
 };
 #[cfg(feature = "fpvec_bounded_l2")]
 use prio::vdaf::prio3::Prio3FixedPointBoundedL2VecSum;
@@ -68,8 +68,6 @@ struct RequestQuery {
     batch_mode: u8,
     batch_interval_start: Option<u64>,
     batch_interval_duration: Option<u64>,
-    subtype: Option<u8>,
-    batch_id: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -241,7 +239,7 @@ where
 
 enum ParsedQuery {
     TimeInterval(Interval),
-    LeaderSelected(LeaderSelectedQuery),
+    LeaderSelected,
 }
 
 async fn handle_collection_start(
@@ -281,18 +279,7 @@ async fn handle_collection_start(
                 Interval::new(start, duration).context("invalid batch interval specification")?;
             ParsedQuery::TimeInterval(interval)
         }
-        2 => match request.query.subtype {
-            Some(0) => {
-                let batch_id_bytes = URL_SAFE_NO_PAD
-                    .decode(request.query.batch_id.context("\"batch_id\" was missing")?)?;
-                let batch_id =
-                    BatchId::get_decoded(&batch_id_bytes).context("invalid length of BatchId")?;
-                ParsedQuery::LeaderSelected(LeaderSelectedQuery::ByBatchId { batch_id })
-            }
-            Some(1) => ParsedQuery::LeaderSelected(LeaderSelectedQuery::CurrentBatch),
-            None => return Err(anyhow::anyhow!("\"subtype\" was missing")),
-            _ => return Err(anyhow::anyhow!("unrecognized \"subtype\" in query")),
-        },
+        2 => ParsedQuery::LeaderSelected,
         _ => {
             return Err(anyhow::anyhow!(
                 "unsupported batch mode: {}",
@@ -302,136 +289,47 @@ async fn handle_collection_start(
     };
 
     let vdaf_instance = task_state.vdaf.clone().into();
-    let task_handle = match (query, vdaf_instance) {
-        (ParsedQuery::TimeInterval(batch_interval), VdafInstance::Prio3Count {}) => {
-            let vdaf = Prio3::new_count(2).context("failed to construct Prio3Count VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_time_interval(batch_interval),
-                vdaf,
-                &agg_param,
-                |_| None,
-                |result| AggregationResult::Number(NumberAsString((*result).into())),
-            )
-            .await?
-        }
-
-        (ParsedQuery::TimeInterval(batch_interval), VdafInstance::Prio3Sum { bits }) => {
-            let vdaf = Prio3::new_sum(2, bits).context("failed to construct Prio3Sum VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_time_interval(batch_interval),
-                vdaf,
-                &agg_param,
-                |_| None,
-                |result| AggregationResult::Number(NumberAsString(*result)),
-            )
-            .await?
-        }
-
-        (
-            ParsedQuery::TimeInterval(batch_interval),
-            VdafInstance::Prio3SumVec {
-                bits,
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = Prio3::new_sum_vec(2, bits, length, chunk_length)
-                .context("failed to construct Prio3SumVec VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_time_interval(batch_interval),
-                vdaf,
-                &agg_param,
-                |_| None,
-                |result| {
-                    let converted = result.iter().cloned().map(NumberAsString).collect();
-                    AggregationResult::NumberVec(converted)
-                },
-            )
-            .await?
-        }
+    let task_handle =
+        match (query, vdaf_instance) {
+            (ParsedQuery::TimeInterval(batch_interval), VdafInstance::Prio3Count {}) => {
+                let vdaf = Prio3::new_count(2).context("failed to construct Prio3Count VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_time_interval(batch_interval),
+                    vdaf,
+                    &agg_param,
+                    |_| None,
+                    |result| AggregationResult::Number(NumberAsString((*result).into())),
+                )
+                .await?
+            }
 
-        (
-            ParsedQuery::TimeInterval(batch_interval),
-            VdafInstance::Prio3SumVecField64MultiproofHmacSha256Aes128 {
-                proofs,
-                bits,
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = new_prio3_sum_vec_field64_multiproof_hmacsha256_aes128::<ParallelSum<_, _>>(
-                proofs,
-                bits,
-                length,
-                chunk_length,
-            )
-            .context("failed to construct Prio3SumVecField64MultiproofHmacSha256Aes128 VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_time_interval(batch_interval),
-                vdaf,
-                &agg_param,
-                |_| None,
-                |result: &Vec<u64>| {
-                    let converted = result
-                        .iter()
-                        .cloned()
-                        .map(u128::from)
-                        .map(NumberAsString)
-                        .collect();
-                    AggregationResult::NumberVec(converted)
-                },
-            )
-            .await?
-        }
+            (ParsedQuery::TimeInterval(batch_interval), VdafInstance::Prio3Sum { bits }) => {
+                let vdaf = Prio3::new_sum(2, bits).context("failed to construct Prio3Sum VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_time_interval(batch_interval),
+                    vdaf,
+                    &agg_param,
+                    |_| None,
+                    |result| AggregationResult::Number(NumberAsString(*result)),
+                )
+                .await?
+            }
 
-        (
-            ParsedQuery::TimeInterval(batch_interval),
-            VdafInstance::Prio3Histogram {
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = Prio3::new_histogram(2, length, chunk_length)
-                .context("failed to construct Prio3Histogram VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_time_interval(batch_interval),
-                vdaf,
-                &agg_param,
-                |_| None,
-                |result| {
-                    let converted = result.iter().cloned().map(NumberAsString).collect();
-                    AggregationResult::NumberVec(converted)
+            (
+                ParsedQuery::TimeInterval(batch_interval),
+                VdafInstance::Prio3SumVec {
+                    bits,
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
                 },
-            )
-            .await?
-        }
-
-        #[cfg(feature = "fpvec_bounded_l2")]
-        (
-            ParsedQuery::TimeInterval(batch_interval),
-            janus_core::vdaf::VdafInstance::Prio3FixedPointBoundedL2VecSum {
-                bitsize,
-                dp_strategy: _,
-                length,
-            },
-        ) => match bitsize {
-            Prio3FixedPointBoundedL2VecSumBitSize::BitSize16 => {
-                let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI16<U15>> =
-                    Prio3::new_fixedpoint_boundedl2_vec_sum(2, length)
-                        .context("failed to construct Prio3FixedPoint16BitBoundedL2VecSum VDAF")?;
+            ) => {
+                let vdaf = Prio3::new_sum_vec(2, bits, length, chunk_length)
+                    .context("failed to construct Prio3SumVec VDAF")?;
                 handle_collect_generic(
                     http_client,
                     task_state,
@@ -441,15 +339,56 @@ async fn handle_collection_start(
                     |_| None,
                     |result| {
                         let converted = result.iter().cloned().map(NumberAsString).collect();
-                        AggregationResult::FloatVec(converted)
+                        AggregationResult::NumberVec(converted)
                     },
                 )
                 .await?
             }
-            Prio3FixedPointBoundedL2VecSumBitSize::BitSize32 => {
-                let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI32<U31>> =
-                    Prio3::new_fixedpoint_boundedl2_vec_sum(2, length)
-                        .context("failed to construct Prio3FixedPoint32BitBoundedL2VecSum VDAF")?;
+
+            (
+                ParsedQuery::TimeInterval(batch_interval),
+                VdafInstance::Prio3SumVecField64MultiproofHmacSha256Aes128 {
+                    proofs,
+                    bits,
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
+                },
+            ) => {
+                let vdaf = new_prio3_sum_vec_field64_multiproof_hmacsha256_aes128::<
+                    ParallelSum<_, _>,
+                >(proofs, bits, length, chunk_length)
+                .context("failed to construct Prio3SumVecField64MultiproofHmacSha256Aes128 VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_time_interval(batch_interval),
+                    vdaf,
+                    &agg_param,
+                    |_| None,
+                    |result: &Vec<u64>| {
+                        let converted = result
+                            .iter()
+                            .cloned()
+                            .map(u128::from)
+                            .map(NumberAsString)
+                            .collect();
+                        AggregationResult::NumberVec(converted)
+                    },
+                )
+                .await?
+            }
+
+            (
+                ParsedQuery::TimeInterval(batch_interval),
+                VdafInstance::Prio3Histogram {
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
+                },
+            ) => {
+                let vdaf = Prio3::new_histogram(2, length, chunk_length)
+                    .context("failed to construct Prio3Histogram VDAF")?;
                 handle_collect_generic(
                     http_client,
                     task_state,
@@ -459,180 +398,227 @@ async fn handle_collection_start(
                     |_| None,
                     |result| {
                         let converted = result.iter().cloned().map(NumberAsString).collect();
-                        AggregationResult::FloatVec(converted)
+                        AggregationResult::NumberVec(converted)
                     },
                 )
                 .await?
             }
-        },
 
-        (ParsedQuery::LeaderSelected(leader_selected_query), VdafInstance::Prio3Count {}) => {
-            let vdaf = Prio3::new_count(2).context("failed to construct Prio3Count VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_leader_selected(leader_selected_query),
-                vdaf,
-                &agg_param,
-                |selector| Some(*selector.batch_id()),
-                |result| AggregationResult::Number(NumberAsString((*result).into())),
-            )
-            .await?
-        }
+            #[cfg(feature = "fpvec_bounded_l2")]
+            (
+                ParsedQuery::TimeInterval(batch_interval),
+                janus_core::vdaf::VdafInstance::Prio3FixedPointBoundedL2VecSum {
+                    bitsize,
+                    dp_strategy: _,
+                    length,
+                },
+            ) => match bitsize {
+                Prio3FixedPointBoundedL2VecSumBitSize::BitSize16 => {
+                    let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI16<U15>> =
+                        Prio3::new_fixedpoint_boundedl2_vec_sum(2, length).context(
+                            "failed to construct Prio3FixedPoint16BitBoundedL2VecSum VDAF",
+                        )?;
+                    handle_collect_generic(
+                        http_client,
+                        task_state,
+                        Query::new_time_interval(batch_interval),
+                        vdaf,
+                        &agg_param,
+                        |_| None,
+                        |result| {
+                            let converted = result.iter().cloned().map(NumberAsString).collect();
+                            AggregationResult::FloatVec(converted)
+                        },
+                    )
+                    .await?
+                }
+                Prio3FixedPointBoundedL2VecSumBitSize::BitSize32 => {
+                    let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI32<U31>> =
+                        Prio3::new_fixedpoint_boundedl2_vec_sum(2, length).context(
+                            "failed to construct Prio3FixedPoint32BitBoundedL2VecSum VDAF",
+                        )?;
+                    handle_collect_generic(
+                        http_client,
+                        task_state,
+                        Query::new_time_interval(batch_interval),
+                        vdaf,
+                        &agg_param,
+                        |_| None,
+                        |result| {
+                            let converted = result.iter().cloned().map(NumberAsString).collect();
+                            AggregationResult::FloatVec(converted)
+                        },
+                    )
+                    .await?
+                }
+            },
 
-        #[cfg(feature = "fpvec_bounded_l2")]
-        (
-            ParsedQuery::LeaderSelected(leader_selected_query),
-            janus_core::vdaf::VdafInstance::Prio3FixedPointBoundedL2VecSum {
-                bitsize,
-                dp_strategy: _,
-                length,
+            (ParsedQuery::LeaderSelected, VdafInstance::Prio3Count {}) => {
+                let vdaf = Prio3::new_count(2).context("failed to construct Prio3Count VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_leader_selected(),
+                    vdaf,
+                    &agg_param,
+                    |selector| Some(*selector.batch_id()),
+                    |result| AggregationResult::Number(NumberAsString((*result).into())),
+                )
+                .await?
+            }
+
+            #[cfg(feature = "fpvec_bounded_l2")]
+            (
+                ParsedQuery::LeaderSelected,
+                janus_core::vdaf::VdafInstance::Prio3FixedPointBoundedL2VecSum {
+                    bitsize,
+                    dp_strategy: _,
+                    length,
+                },
+            ) => match bitsize {
+                Prio3FixedPointBoundedL2VecSumBitSize::BitSize16 => {
+                    let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI16<U15>> =
+                        Prio3::new_fixedpoint_boundedl2_vec_sum(2, length).context(
+                            "failed to construct Prio3FixedPoint16BitBoundedL2VecSum VDAF",
+                        )?;
+                    handle_collect_generic(
+                        http_client,
+                        task_state,
+                        Query::new_leader_selected(),
+                        vdaf,
+                        &agg_param,
+                        |selector| Some(*selector.batch_id()),
+                        |result| {
+                            let converted = result.iter().cloned().map(NumberAsString).collect();
+                            AggregationResult::FloatVec(converted)
+                        },
+                    )
+                    .await?
+                }
+                Prio3FixedPointBoundedL2VecSumBitSize::BitSize32 => {
+                    let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI32<U31>> =
+                        Prio3::new_fixedpoint_boundedl2_vec_sum(2, length).context(
+                            "failed to construct Prio3FixedPoint32BitBoundedL2VecSum VDAF",
+                        )?;
+                    handle_collect_generic(
+                        http_client,
+                        task_state,
+                        Query::new_leader_selected(),
+                        vdaf,
+                        &agg_param,
+                        |selector| Some(*selector.batch_id()),
+                        |result| {
+                            let converted = result.iter().cloned().map(NumberAsString).collect();
+                            AggregationResult::FloatVec(converted)
+                        },
+                    )
+                    .await?
+                }
             },
-        ) => match bitsize {
-            Prio3FixedPointBoundedL2VecSumBitSize::BitSize16 => {
-                let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI16<U15>> =
-                    Prio3::new_fixedpoint_boundedl2_vec_sum(2, length)
-                        .context("failed to construct Prio3FixedPoint16BitBoundedL2VecSum VDAF")?;
+
+            (ParsedQuery::LeaderSelected, VdafInstance::Prio3Sum { bits }) => {
+                let vdaf = Prio3::new_sum(2, bits).context("failed to construct Prio3Sum VDAF")?;
                 handle_collect_generic(
                     http_client,
                     task_state,
-                    Query::new_leader_selected(leader_selected_query),
+                    Query::new_leader_selected(),
                     vdaf,
                     &agg_param,
                     |selector| Some(*selector.batch_id()),
-                    |result| {
-                        let converted = result.iter().cloned().map(NumberAsString).collect();
-                        AggregationResult::FloatVec(converted)
-                    },
+                    |result| AggregationResult::Number(NumberAsString(*result)),
                 )
                 .await?
             }
-            Prio3FixedPointBoundedL2VecSumBitSize::BitSize32 => {
-                let vdaf: Prio3FixedPointBoundedL2VecSum<FixedI32<U31>> =
-                    Prio3::new_fixedpoint_boundedl2_vec_sum(2, length)
-                        .context("failed to construct Prio3FixedPoint32BitBoundedL2VecSum VDAF")?;
+
+            (
+                ParsedQuery::LeaderSelected,
+                VdafInstance::Prio3SumVec {
+                    bits,
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
+                },
+            ) => {
+                let vdaf = Prio3::new_sum_vec(2, bits, length, chunk_length)
+                    .context("failed to construct Prio3SumVec VDAF")?;
                 handle_collect_generic(
                     http_client,
                     task_state,
-                    Query::new_leader_selected(leader_selected_query),
+                    Query::new_leader_selected(),
                     vdaf,
                     &agg_param,
                     |selector| Some(*selector.batch_id()),
                     |result| {
                         let converted = result.iter().cloned().map(NumberAsString).collect();
-                        AggregationResult::FloatVec(converted)
+                        AggregationResult::NumberVec(converted)
                     },
                 )
                 .await?
             }
-        },
-
-        (ParsedQuery::LeaderSelected(leader_selected_query), VdafInstance::Prio3Sum { bits }) => {
-            let vdaf = Prio3::new_sum(2, bits).context("failed to construct Prio3Sum VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_leader_selected(leader_selected_query),
-                vdaf,
-                &agg_param,
-                |selector| Some(*selector.batch_id()),
-                |result| AggregationResult::Number(NumberAsString(*result)),
-            )
-            .await?
-        }
-
-        (
-            ParsedQuery::LeaderSelected(leader_selected_query),
-            VdafInstance::Prio3SumVec {
-                bits,
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = Prio3::new_sum_vec(2, bits, length, chunk_length)
-                .context("failed to construct Prio3SumVec VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_leader_selected(leader_selected_query),
-                vdaf,
-                &agg_param,
-                |selector| Some(*selector.batch_id()),
-                |result| {
-                    let converted = result.iter().cloned().map(NumberAsString).collect();
-                    AggregationResult::NumberVec(converted)
-                },
-            )
-            .await?
-        }
 
-        (
-            ParsedQuery::LeaderSelected(leader_selected_query),
-            VdafInstance::Prio3SumVecField64MultiproofHmacSha256Aes128 {
-                proofs,
-                bits,
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = new_prio3_sum_vec_field64_multiproof_hmacsha256_aes128::<ParallelSum<_, _>>(
-                proofs,
-                bits,
-                length,
-                chunk_length,
-            )
-            .context("failed to construct Prio3SumVecField64MultiproofHmacSha256Aes128 VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_leader_selected(leader_selected_query),
-                vdaf,
-                &agg_param,
-                |selector| Some(*selector.batch_id()),
-                |result: &Vec<u64>| {
-                    let converted = result
-                        .iter()
-                        .cloned()
-                        .map(u128::from)
-                        .map(NumberAsString)
-                        .collect();
-                    AggregationResult::NumberVec(converted)
+            (
+                ParsedQuery::LeaderSelected,
+                VdafInstance::Prio3SumVecField64MultiproofHmacSha256Aes128 {
+                    proofs,
+                    bits,
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
                 },
-            )
-            .await?
-        }
+            ) => {
+                let vdaf = new_prio3_sum_vec_field64_multiproof_hmacsha256_aes128::<
+                    ParallelSum<_, _>,
+                >(proofs, bits, length, chunk_length)
+                .context("failed to construct Prio3SumVecField64MultiproofHmacSha256Aes128 VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_leader_selected(),
+                    vdaf,
+                    &agg_param,
+                    |selector| Some(*selector.batch_id()),
+                    |result: &Vec<u64>| {
+                        let converted = result
+                            .iter()
+                            .cloned()
+                            .map(u128::from)
+                            .map(NumberAsString)
+                            .collect();
+                        AggregationResult::NumberVec(converted)
+                    },
+                )
+                .await?
+            }
 
-        (
-            ParsedQuery::LeaderSelected(leader_selected_query),
-            VdafInstance::Prio3Histogram {
-                length,
-                chunk_length,
-                dp_strategy: _,
-            },
-        ) => {
-            let vdaf = Prio3::new_histogram(2, length, chunk_length)
-                .context("failed to construct Prio3Histogram VDAF")?;
-            handle_collect_generic(
-                http_client,
-                task_state,
-                Query::new_leader_selected(leader_selected_query),
-                vdaf,
-                &agg_param,
-                |selector| Some(*selector.batch_id()),
-                |result| {
-                    let converted = result.iter().cloned().map(NumberAsString).collect();
-                    AggregationResult::NumberVec(converted)
+            (
+                ParsedQuery::LeaderSelected,
+                VdafInstance::Prio3Histogram {
+                    length,
+                    chunk_length,
+                    dp_strategy: _,
                 },
-            )
-            .await?
-        }
+            ) => {
+                let vdaf = Prio3::new_histogram(2, length, chunk_length)
+                    .context("failed to construct Prio3Histogram VDAF")?;
+                handle_collect_generic(
+                    http_client,
+                    task_state,
+                    Query::new_leader_selected(),
+                    vdaf,
+                    &agg_param,
+                    |selector| Some(*selector.batch_id()),
+                    |result| {
+                        let converted = result.iter().cloned().map(NumberAsString).collect();
+                        AggregationResult::NumberVec(converted)
+                    },
+                )
+                .await?
+            }
 
-        (_, vdaf_instance) => {
-            panic!("Unsupported VDAF: {vdaf_instance:?}")
-        }
-    };
+            (_, vdaf_instance) => {
+                panic!("Unsupported VDAF: {vdaf_instance:?}")
+            }
+        };
 
     let mut collection_jobs_guard = collection_jobs.lock().await;
     Ok(loop {
diff --git a/interop_binaries/src/lib.rs b/interop_binaries/src/lib.rs
index 111f742a9..9265b3a08 100644
--- a/interop_binaries/src/lib.rs
+++ b/interop_binaries/src/lib.rs
@@ -295,7 +295,6 @@ pub struct AggregatorAddTaskRequest {
     pub collector_authentication_token: Option<String>,
     pub role: AggregatorRole,
     pub vdaf_verify_key: String, // in unpadded base64url
-    pub max_batch_query_count: u64,
     pub batch_mode: u8,
     pub min_batch_size: u64,
     pub max_batch_size: Option<u64>,
@@ -328,7 +327,6 @@ impl AggregatorAddTaskRequest {
             },
             role: role.try_into().unwrap(),
             vdaf_verify_key: URL_SAFE_NO_PAD.encode(task.opaque_vdaf_verify_key().as_ref()),
-            max_batch_query_count: task.max_batch_query_count(),
             batch_mode,
             min_batch_size: task.min_batch_size(),
             max_batch_size,
diff --git a/interop_binaries/tests/end_to_end.rs b/interop_binaries/tests/end_to_end.rs
index 661a35229..04c31e4c5 100644
--- a/interop_binaries/tests/end_to_end.rs
+++ b/interop_binaries/tests/end_to_end.rs
@@ -291,7 +291,6 @@ async fn run(
         "collector_authentication_token": collector_auth_token,
         "role": "leader",
         "vdaf_verify_key": vdaf_verify_key_encoded,
-        "max_batch_query_count": 1,
         "batch_mode": batch_mode_json,
         "min_batch_size": measurements.len(),
         "time_precision": TIME_PRECISION,
@@ -343,7 +342,6 @@ async fn run(
         "leader_authentication_token": aggregator_auth_token,
         "role": "helper",
         "vdaf_verify_key": vdaf_verify_key_encoded,
-        "max_batch_query_count": 1,
         "batch_mode": batch_mode_json,
         "min_batch_size": measurements.len(),
         "time_precision": TIME_PRECISION,
diff --git a/messages/src/batch_mode.rs b/messages/src/batch_mode.rs
index b52e9b3d0..b94c68dbd 100644
--- a/messages/src/batch_mode.rs
+++ b/messages/src/batch_mode.rs
@@ -1,6 +1,4 @@
-use crate::{Collection, LeaderSelectedQuery, Query};
-
-use super::{BatchId, Interval};
+use crate::{BatchId, Collection, Interval, Query};
 use anyhow::anyhow;
 use num_enum::TryFromPrimitive;
 use prio::codec::{CodecError, Decode, Encode};
@@ -93,7 +91,7 @@ impl BatchMode for LeaderSelected {
 
     type BatchIdentifier = BatchId;
     type PartialBatchIdentifier = BatchId;
-    type QueryBody = LeaderSelectedQuery;
+    type QueryBody = ();
 
     fn partial_batch_identifier(
         batch_identifier: &Self::BatchIdentifier,
diff --git a/messages/src/lib.rs b/messages/src/lib.rs
index 337dd0366..3c085e285 100644
--- a/messages/src/lib.rs
+++ b/messages/src/lib.rs
@@ -1435,48 +1435,6 @@ impl Decode for Report {
     }
 }
 
-/// DAP protocol message representing a leader-selected query.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum LeaderSelectedQuery {
-    ByBatchId { batch_id: BatchId },
-    CurrentBatch,
-}
-
-impl Encode for LeaderSelectedQuery {
-    fn encode(&self, bytes: &mut Vec<u8>) -> Result<(), CodecError> {
-        match self {
-            LeaderSelectedQuery::ByBatchId { batch_id } => {
-                0u8.encode(bytes)?;
-                batch_id.encode(bytes)
-            }
-            LeaderSelectedQuery::CurrentBatch => 1u8.encode(bytes),
-        }
-    }
-
-    fn encoded_len(&self) -> Option<usize> {
-        match self {
-            LeaderSelectedQuery::ByBatchId { batch_id } => Some(1 + batch_id.encoded_len()?),
-            LeaderSelectedQuery::CurrentBatch => Some(1),
-        }
-    }
-}
-
-impl Decode for LeaderSelectedQuery {
-    fn decode(bytes: &mut Cursor<&[u8]>) -> Result<Self, CodecError> {
-        let query_type = u8::decode(bytes)?;
-        match query_type {
-            0 => {
-                let batch_id = BatchId::decode(bytes)?;
-                Ok(LeaderSelectedQuery::ByBatchId { batch_id })
-            }
-            1 => Ok(LeaderSelectedQuery::CurrentBatch),
-            _ => Err(CodecError::Other(
-                anyhow!("unexpected LeaderSelectedQuery type value {}", query_type).into(),
-            )),
-        }
-    }
-}
-
 /// Represents a query for a specific batch identifier, received from a Collector as part of the
 /// collection flow.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -1497,8 +1455,7 @@ impl<B: BatchMode> Query<B> {
     /// Gets the query body included in this query.
     ///
     /// This method would typically be used for code which is generic over the batch mode. Batch
-    /// mode-specific code will typically call one of [`Self::batch_interval`] or
-    /// [`Self::leader_selected_query`].
+    /// mode-specific code will typically call [`Self::batch_interval`].
     pub fn query_body(&self) -> &B::QueryBody {
         &self.query_body
     }
@@ -1518,13 +1475,8 @@ impl Query<TimeInterval> {
 
 impl Query<LeaderSelected> {
     /// Constructs a new query for a leader-selected task.
-    pub fn new_leader_selected(leader_selected_query: LeaderSelectedQuery) -> Self {
-        Self::new(leader_selected_query)
-    }
-
-    /// Gets the leader-selected query associated with this query.
-    pub fn leader_selected_query(&self) -> &LeaderSelectedQuery {
-        self.query_body()
+    pub fn new_leader_selected() -> Self {
+        Self::new(())
     }
 }
 
diff --git a/messages/src/problem_type.rs b/messages/src/problem_type.rs
index b202e418d..1b0576eb9 100644
--- a/messages/src/problem_type.rs
+++ b/messages/src/problem_type.rs
@@ -15,7 +15,7 @@ pub enum DapProblemType {
     ReportTooEarly,
     BatchInvalid,
     InvalidBatchSize,
-    BatchQueriedTooManyTimes,
+    BatchQueriedMultipleTimes,
     BatchMismatch,
     UnauthorizedRequest,
     BatchOverlap,
@@ -38,8 +38,8 @@ impl DapProblemType {
             DapProblemType::ReportTooEarly => "urn:ietf:params:ppm:dap:error:reportTooEarly",
             DapProblemType::BatchInvalid => "urn:ietf:params:ppm:dap:error:batchInvalid",
             DapProblemType::InvalidBatchSize => "urn:ietf:params:ppm:dap:error:invalidBatchSize",
-            DapProblemType::BatchQueriedTooManyTimes => {
-                "urn:ietf:params:ppm:dap:error:batchQueriedTooManyTimes"
+            DapProblemType::BatchQueriedMultipleTimes => {
+                "urn:ietf:params:ppm:dap:error:batchQueriedMultipleTimes"
             }
             DapProblemType::BatchMismatch => "urn:ietf:params:ppm:dap:error:batchMismatch",
             DapProblemType::UnauthorizedRequest => {
@@ -79,8 +79,8 @@ impl DapProblemType {
             DapProblemType::InvalidBatchSize => {
                 "The number of reports included in the batch is invalid."
             }
-            DapProblemType::BatchQueriedTooManyTimes => {
-                "The batch described by the query has been queried too many times."
+            DapProblemType::BatchQueriedMultipleTimes => {
+                "The batch described by the query has been queried already."
             }
             DapProblemType::BatchMismatch => {
                 "Leader and helper disagree on reports aggregated in a batch."
@@ -119,8 +119,8 @@ impl FromStr for DapProblemType {
             "urn:ietf:params:ppm:dap:error:invalidBatchSize" => {
                 Ok(DapProblemType::InvalidBatchSize)
             }
-            "urn:ietf:params:ppm:dap:error:batchQueriedTooManyTimes" => {
-                Ok(DapProblemType::BatchQueriedTooManyTimes)
+            "urn:ietf:params:ppm:dap:error:batchQueriedMultipleTimes" => {
+                Ok(DapProblemType::BatchQueriedMultipleTimes)
             }
             "urn:ietf:params:ppm:dap:error:batchMismatch" => Ok(DapProblemType::BatchMismatch),
             "urn:ietf:params:ppm:dap:error:unauthorizedRequest" => {
diff --git a/messages/src/taskprov.rs b/messages/src/taskprov.rs
index ff5db224c..d655c17a9 100644
--- a/messages/src/taskprov.rs
+++ b/messages/src/taskprov.rs
@@ -133,9 +133,6 @@ impl Decode for TaskConfig {
 pub struct QueryConfig {
     /// Used by clients to truncate report timestamps.
     time_precision: Duration,
-    /// The maximum number of times a batch of reports may be queried by the
-    /// collector
-    max_batch_query_count: u16,
     /// The smallest number of reports that a batch can include.
     min_batch_size: u32,
     /// The batch mode along with associated parameters.
@@ -143,15 +140,9 @@ pub struct QueryConfig {
 }
 
 impl QueryConfig {
-    pub fn new(
-        time_precision: Duration,
-        max_batch_query_count: u16,
-        min_batch_size: u32,
-        query: Query,
-    ) -> Self {
+    pub fn new(time_precision: Duration, min_batch_size: u32, query: Query) -> Self {
         Self {
             time_precision,
-            max_batch_query_count,
             min_batch_size,
             query,
         }
@@ -161,10 +152,6 @@ impl QueryConfig {
         &self.time_precision
     }
 
-    pub fn max_batch_query_count(&self) -> u16 {
-        self.max_batch_query_count
-    }
-
     pub fn min_batch_size(&self) -> u32 {
         self.min_batch_size
     }
@@ -177,7 +164,6 @@ impl QueryConfig {
 impl Encode for QueryConfig {
     fn encode(&self, bytes: &mut Vec<u8>) -> Result<(), CodecError> {
         self.time_precision.encode(bytes)?;
-        self.max_batch_query_count.encode(bytes)?;
         self.min_batch_size.encode(bytes)?;
         self.query.encode(bytes)?;
         Ok(())
@@ -186,7 +172,6 @@ impl Encode for QueryConfig {
     fn encoded_len(&self) -> Option<usize> {
         Some(
             self.time_precision.encoded_len()?
-                + self.max_batch_query_count.encoded_len()?
                 + self.min_batch_size.encoded_len()?
                 + self.query.encoded_len()?,
         )
@@ -196,13 +181,11 @@ impl Encode for QueryConfig {
 impl Decode for QueryConfig {
     fn decode(bytes: &mut Cursor<&[u8]>) -> Result<Self, CodecError> {
         let time_precision = Duration::decode(bytes)?;
-        let max_batch_query_count = u16::decode(bytes)?;
         let min_batch_size = u32::decode(bytes)?;
         let query = Query::decode(bytes)?;
 
         Ok(Self {
             time_precision,
-            max_batch_query_count,
             min_batch_size,
             query,
         })
@@ -836,15 +819,9 @@ mod tests {
     fn roundtrip_query_config() {
         roundtrip_encoding(&[
             (
-                QueryConfig::new(
-                    Duration::from_seconds(0x3C),
-                    0x40,
-                    0x24,
-                    Query::TimeInterval,
-                ),
+                QueryConfig::new(Duration::from_seconds(0x3C), 0x24, Query::TimeInterval),
                 concat!(
                     "000000000000003C", // time_precision
-                    "0040",             // max_batch_query_count
                     "00000024",         // min_batch_size
                     "01",               // batch_mode
                 ),
@@ -852,7 +829,6 @@ mod tests {
             (
                 QueryConfig::new(
                     Duration::from_seconds(u64::MIN),
-                    u16::MIN,
                     u32::MIN,
                     Query::LeaderSelected {
                         max_batch_size: u32::MIN,
@@ -860,7 +836,6 @@ mod tests {
                 ),
                 concat!(
                     "0000000000000000", // time_precision
-                    "0000",             // max_batch_query_count
                     "00000000",         // min_batch_size
                     "02",               // batch_mode
                     "00000000",         // max_batch_size
@@ -869,7 +844,6 @@ mod tests {
             (
                 QueryConfig::new(
                     Duration::from_seconds(0x3C),
-                    0x40,
                     0x24,
                     Query::LeaderSelected {
                         max_batch_size: 0xFAFA,
@@ -877,7 +851,6 @@ mod tests {
                 ),
                 concat!(
                     "000000000000003C", // time_precision
-                    "0040",             // max_batch_query_count
                     "00000024",         // min_batch_size
                     "02",               // batch_mode
                     "0000FAFA",         // max_batch_size
@@ -886,7 +859,6 @@ mod tests {
             (
                 QueryConfig::new(
                     Duration::from_seconds(u64::MAX),
-                    u16::MAX,
                     u32::MAX,
                     Query::LeaderSelected {
                         max_batch_size: u32::MAX,
@@ -894,7 +866,6 @@ mod tests {
                 ),
                 concat!(
                     "FFFFFFFFFFFFFFFF", // time_precision
-                    "FFFF",             // max_batch_query_count
                     "FFFFFFFF",         // min_batch_size
                     "02",               // batch_mode
                     "FFFFFFFF",         // max_batch_size
@@ -952,7 +923,6 @@ mod tests {
                     Url::try_from("https://another.example.com/".as_ref()).unwrap(),
                     QueryConfig::new(
                         Duration::from_seconds(0xAAAA),
-                        0xBBBB,
                         0xCCCC,
                         Query::LeaderSelected {
                             max_batch_size: 0xDDDD,
@@ -981,9 +951,8 @@ mod tests {
                     ),
                     concat!(
                         // query_config
-                        "0013",             // query_config length
+                        "0011",             // query_config length
                         "000000000000AAAA", // time_precision
-                        "BBBB",             // max_batch_query_count
                         "0000CCCC",         // min_batch_size
                         "02",               // batch_mode
                         "0000DDDD",         // max_batch_size
@@ -1009,12 +978,7 @@ mod tests {
                     "f".as_bytes().to_vec(),
                     Url::try_from("https://example.com/".as_ref()).unwrap(),
                     Url::try_from("https://another.example.com/".as_ref()).unwrap(),
-                    QueryConfig::new(
-                        Duration::from_seconds(0xAAAA),
-                        0xBBBB,
-                        0xCCCC,
-                        Query::TimeInterval,
-                    ),
+                    QueryConfig::new(Duration::from_seconds(0xAAAA), 0xCCCC, Query::TimeInterval),
                     Time::from_seconds_since_epoch(0xEEEE),
                     VdafConfig::new(
                         DpConfig::new(DpMechanism::None),
@@ -1044,9 +1008,8 @@ mod tests {
                     ),
                     concat!(
                         // query_config
-                        "000F",             // query_config length
+                        "000D",             // query_config length
                         "000000000000AAAA", // time_precision
-                        "BBBB",             // max_batch_query_count
                         "0000CCCC",         // min_batch_size
                         "01",               // batch_mode
                     ),
@@ -1090,9 +1053,8 @@ mod tests {
                     ),
                     concat!(
                         // query_config
-                        "000F",             // query_config length
+                        "000D",             // query_config length
                         "000000000000AAAA", // time_precision
-                        "BBBB",             // max_batch_query_count
                         "0000CCCC",         // min_batch_size
                         "01",               // batch_mode
                     ),
diff --git a/messages/src/tests/collection.rs b/messages/src/tests/collection.rs
index e59c7c9bd..00db586ce 100644
--- a/messages/src/tests/collection.rs
+++ b/messages/src/tests/collection.rs
@@ -1,8 +1,7 @@
 use crate::{
     roundtrip_encoding, AggregateShare, AggregateShareAad, AggregateShareReq, BatchId,
     BatchSelector, Collection, CollectionReq, Duration, HpkeCiphertext, HpkeConfigId, Interval,
-    LeaderSelected, LeaderSelectedQuery, PartialBatchSelector, Query, ReportIdChecksum, TaskId,
-    Time, TimeInterval,
+    LeaderSelected, PartialBatchSelector, Query, ReportIdChecksum, TaskId, Time, TimeInterval,
 };
 use prio::codec::Decode;
 
@@ -72,21 +71,12 @@ fn roundtrip_collection_req() {
     roundtrip_encoding(&[
         (
             CollectionReq::<LeaderSelected> {
-                query: Query {
-                    query_body: LeaderSelectedQuery::ByBatchId {
-                        batch_id: BatchId::from([10u8; 32]),
-                    },
-                },
+                query: Query { query_body: () },
                 aggregation_parameter: Vec::new(),
             },
             concat!(
                 concat!(
                     "02", // batch_mode
-                    concat!(
-                        // query_body
-                        "00", // batch_mode
-                        "0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A", // batch_id
-                    ),
                 ),
                 concat!(
                     // aggregation_parameter
@@ -97,18 +87,12 @@ fn roundtrip_collection_req() {
         ),
         (
             CollectionReq::<LeaderSelected> {
-                query: Query::<LeaderSelected> {
-                    query_body: LeaderSelectedQuery::CurrentBatch,
-                },
+                query: Query { query_body: () },
                 aggregation_parameter: Vec::from("012345"),
             },
             concat!(
                 concat!(
                     "02", // batch_mode
-                    concat!(
-                        // query_body
-                        "01", // batch_mode
-                    ),
                 ),
                 concat!(
                     // aggregation_parameter
diff --git a/messages/src/tests/query.rs b/messages/src/tests/query.rs
index ed3c026eb..68e11a4a6 100644
--- a/messages/src/tests/query.rs
+++ b/messages/src/tests/query.rs
@@ -1,6 +1,6 @@
 use crate::{
-    batch_mode, roundtrip_encoding, BatchId, Duration, Interval, LeaderSelected,
-    LeaderSelectedQuery, Query, TaskId, Time, TimeInterval,
+    batch_mode, roundtrip_encoding, BatchId, Duration, Interval, LeaderSelected, Query, TaskId,
+    Time, TimeInterval,
 };
 
 #[test]
@@ -24,27 +24,6 @@ fn roundtrip_batch_id() {
     ])
 }
 
-#[test]
-fn roundtrip_leader_selected_query() {
-    roundtrip_encoding(&[
-        (
-            LeaderSelectedQuery::ByBatchId {
-                batch_id: BatchId::from([10u8; 32]),
-            },
-            concat!(
-                "00",                                                               // batch_mode
-                "0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A", // batch_id
-            ),
-        ),
-        (
-            LeaderSelectedQuery::CurrentBatch,
-            concat!(
-                "01", // batch_mode
-            ),
-        ),
-    ])
-}
-
 #[test]
 fn roundtrip_query() {
     // TimeInterval.
@@ -86,35 +65,12 @@ fn roundtrip_query() {
     ]);
 
     // LeaderSelected.
-    roundtrip_encoding(&[
-        (
-            Query::<LeaderSelected> {
-                query_body: LeaderSelectedQuery::ByBatchId {
-                    batch_id: BatchId::from([10u8; 32]),
-                },
-            },
-            concat!(
-                "02", // batch_mode
-                concat!(
-                    // query_body
-                    "00", // batch_mode
-                    "0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A", // batch_id
-                ),
-            ),
-        ),
-        (
-            Query::<LeaderSelected> {
-                query_body: LeaderSelectedQuery::CurrentBatch,
-            },
-            concat!(
+    roundtrip_encoding(&[(
+        Query::<LeaderSelected> { query_body: () },
+        concat!(
                 "02", // batch_mode
-                concat!(
-                    // query_body
-                    "01", // batch_mode
-                ),
             ),
-        ),
-    ])
+    )])
 }
 
 #[test]
diff --git a/tools/src/bin/collect.rs b/tools/src/bin/collect.rs
index 677cdb4e2..11e45d203 100644
--- a/tools/src/bin/collect.rs
+++ b/tools/src/bin/collect.rs
@@ -3,7 +3,7 @@ use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
 use clap::{
     builder::{NonEmptyStringValueParser, StringValueParser, TypedValueParser},
     error::ErrorKind,
-    ArgAction, Args, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum,
+    Args, CommandFactory, FromArgMatches, Parser, Subcommand, ValueEnum,
 };
 #[cfg(feature = "fpvec_bounded_l2")]
 use fixed::types::extra::{U15, U31};
@@ -16,8 +16,7 @@ use janus_collector::{
 use janus_core::hpke::{HpkeKeypair, HpkePrivateKey};
 use janus_messages::{
     batch_mode::{BatchMode, LeaderSelected, TimeInterval},
-    BatchId, CollectionJobId, Duration, HpkeConfig, Interval, LeaderSelectedQuery,
-    PartialBatchSelector, Query, TaskId, Time,
+    CollectionJobId, Duration, HpkeConfig, Interval, PartialBatchSelector, Query, TaskId, Time,
 };
 #[cfg(feature = "fpvec_bounded_l2")]
 use prio::vdaf::prio3::Prio3FixedPointBoundedL2VecSum;
@@ -177,7 +176,6 @@ struct AuthenticationOptions {
 }
 
 #[derive(Debug, Args, PartialEq, Eq)]
-#[group(required = true)]
 struct QueryOptions {
     /// Start of the collection batch interval, as the number of seconds since the Unix epoch
     #[clap(
@@ -186,6 +184,7 @@ struct QueryOptions {
         help_heading = "Collect Request Parameters (Time Interval)"
     )]
     batch_interval_start: Option<u64>,
+
     /// Duration of the collection batch interval, in seconds
     #[clap(
         long,
@@ -193,22 +192,6 @@ struct QueryOptions {
         help_heading = "Collect Request Parameters (Time Interval)"
     )]
     batch_interval_duration: Option<u64>,
-
-    /// Batch identifier, encoded with base64url
-    #[clap(
-        long,
-        conflicts_with_all = ["batch_interval_start", "batch_interval_duration", "current_batch"],
-        help_heading = "Collect Request Parameters (Leader Selected)",
-    )]
-    batch_id: Option<BatchId>,
-    /// Have the aggregator select a batch that has not yet been collected
-    #[clap(
-        long,
-        action = ArgAction::SetTrue,
-        conflicts_with_all = ["batch_interval_start", "batch_interval_duration", "batch_id"],
-        help_heading = "Collect Request Parameters (Leader Selected)",
-    )]
-    current_batch: bool,
 }
 
 #[derive(Debug, Args, PartialEq, Eq)]
@@ -445,10 +428,8 @@ macro_rules! options_query_dispatch {
         match (
             &$options.query.batch_interval_start,
             &$options.query.batch_interval_duration,
-            &$options.query.batch_id,
-            $options.query.current_batch,
         ) {
-            (Some(batch_interval_start), Some(batch_interval_duration), None, false) => {
+            (Some(batch_interval_start), Some(batch_interval_duration)) => {
                 let $query = Query::new_time_interval(
                     Interval::new(
                         Time::from_seconds_since_epoch(*batch_interval_start),
@@ -458,14 +439,8 @@ macro_rules! options_query_dispatch {
                 );
                 $body
             }
-            (None, None, Some(batch_id), false) => {
-                let $query = Query::new_leader_selected(LeaderSelectedQuery::ByBatchId {
-                    batch_id: *batch_id,
-                });
-                $body
-            }
-            (None, None, None, true) => {
-                let $query = Query::new_leader_selected(LeaderSelectedQuery::CurrentBatch);
+            (None, None) => {
+                let $query = Query::new_leader_selected();
                 $body
             }
             _ => unreachable!("clap argument parsing shouldn't allow this to be possible"),
@@ -732,7 +707,7 @@ mod tests {
         auth_tokens::{BearerToken, DapAuthToken},
         hpke::HpkeKeypair,
     };
-    use janus_messages::{BatchId, TaskId};
+    use janus_messages::TaskId;
     use prio::codec::Encode;
     use rand::random;
     use reqwest::Url;
@@ -786,8 +761,6 @@ mod tests {
             query: QueryOptions {
                 batch_interval_start: Some(1_000_000),
                 batch_interval_duration: Some(1_000),
-                batch_id: None,
-                current_batch: false,
             },
         };
         let task_id_encoded = URL_SAFE_NO_PAD.encode(task_id.get_encoded().unwrap());
@@ -1000,7 +973,7 @@ mod tests {
         let encoded_private_key = URL_SAFE_NO_PAD.encode(hpke_keypair.private_key().as_ref());
         let auth_token = AuthenticationToken::DapAuth(random());
 
-        // Check parsing arguments for a current batch query.
+        // Check parsing arguments for a leader-selected query.
         let expected = Options {
             subcommand: None,
             task_id,
@@ -1021,8 +994,6 @@ mod tests {
             query: QueryOptions {
                 batch_interval_start: None,
                 batch_interval_duration: None,
-                batch_id: None,
-                current_batch: true,
             },
         };
         let correct_arguments = [
@@ -1035,57 +1006,15 @@ mod tests {
             &format!("--hpke-private-key={encoded_private_key}"),
             "--vdaf",
             "count",
-            "--current-batch",
-        ];
-        match Options::try_parse_from(correct_arguments) {
-            Ok(got) => assert_eq!(got, expected),
-            Err(e) => panic!("{}\narguments were {:?}", e, correct_arguments),
-        }
-
-        // Check parsing arguments for a by-batch-id query.
-        let batch_id: BatchId = random();
-        let batch_id_encoded = URL_SAFE_NO_PAD.encode(batch_id.as_ref());
-        let expected = Options {
-            subcommand: None,
-            task_id,
-            leader: leader.clone(),
-            authentication: AuthenticationOptions {
-                dap_auth_token: Some(auth_token.clone()),
-                authorization_bearer_token: None,
-            },
-            hpke_config: HpkeConfigOptions {
-                hpke_config: Some(hpke_keypair.config().clone()),
-                hpke_private_key: Some(hpke_keypair.private_key().clone()),
-                collector_credential_file: None,
-                collector_credential: None,
-            },
-            vdaf: VdafType::Count,
-            length: None,
-            bits: None,
-            query: QueryOptions {
-                batch_interval_start: None,
-                batch_interval_duration: None,
-                batch_id: Some(batch_id),
-                current_batch: false,
-            },
-        };
-        let correct_arguments = [
-            "collect",
-            &format!("--task-id={task_id_encoded}"),
-            "--leader",
-            leader.as_str(),
-            &format!("--dap-auth-token={}", auth_token.as_str()),
-            &format!("--hpke-config={encoded_hpke_config}"),
-            &format!("--hpke-private-key={encoded_private_key}"),
-            "--vdaf",
-            "count",
-            &format!("--batch-id={batch_id_encoded}"),
         ];
         match Options::try_parse_from(correct_arguments) {
             Ok(got) => assert_eq!(got, expected),
             Err(e) => panic!("{}\narguments were {:?}", e, correct_arguments),
         }
 
+        // Check that clap enforces all the constraints we need on combinations of query arguments.
+        // This allows us to treat a default match branch as `unreachable!()` when unpacking the
+        // argument matches.
         let base_arguments = Vec::from([
             "collect".to_string(),
             format!("--task-id={task_id_encoded}"),
@@ -1097,20 +1026,7 @@ mod tests {
             "--vdaf=count".to_string(),
         ]);
 
-        let mut good_arguments = base_arguments.clone();
-        good_arguments.push("--current-batch".to_string());
-        Options::try_parse_from(good_arguments).unwrap();
-
-        // Check that clap enforces all the constraints we need on combinations of query arguments.
-        // This allows us to treat a default match branch as `unreachable!()` when unpacking the
-        // argument matches.
-
-        assert_eq!(
-            Options::try_parse_from(base_arguments.clone())
-                .unwrap_err()
-                .kind(),
-            ErrorKind::MissingRequiredArgument
-        );
+        Options::try_parse_from(base_arguments.clone()).unwrap();
 
         let mut bad_arguments = base_arguments.clone();
         bad_arguments.push("--batch-interval-start=1".to_string());
@@ -1125,67 +1041,6 @@ mod tests {
             Options::try_parse_from(bad_arguments).unwrap_err().kind(),
             ErrorKind::MissingRequiredArgument
         );
-
-        let mut bad_arguments = base_arguments.clone();
-        bad_arguments.extend([
-            "--batch-interval-start=1".to_string(),
-            "--batch-interval-duration=1".to_string(),
-            "--batch-id=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
-
-        let mut bad_arguments = base_arguments.clone();
-        bad_arguments.extend([
-            "--batch-interval-start=1".to_string(),
-            "--batch-id=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
-
-        let mut bad_arguments = base_arguments.clone();
-        bad_arguments.extend([
-            "--batch-interval-duration=1".to_string(),
-            "--batch-id=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
-
-        let mut bad_arguments = base_arguments.clone();
-        bad_arguments.extend([
-            "--batch-interval-start=1".to_string(),
-            "--current-batch".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
-
-        let mut bad_arguments = base_arguments.clone();
-        bad_arguments.extend([
-            "--batch-interval-duration=1".to_string(),
-            "--current-batch".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
-
-        let mut bad_arguments = base_arguments;
-        bad_arguments.extend([
-            "--batch-id=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_string(),
-            "--current-batch".to_string(),
-        ]);
-        assert_eq!(
-            Options::try_parse_from(bad_arguments).unwrap_err().kind(),
-            ErrorKind::ArgumentConflict
-        );
     }
 
     #[test]
@@ -1397,7 +1252,6 @@ mod tests {
             format!("--dap-auth-token={}", auth_token.as_str()),
             "--vdaf".to_string(),
             "count".to_string(),
-            "--current-batch".to_string(),
         ]);
 
         let mut correct_arguments = base_arguments.clone();
@@ -1481,8 +1335,6 @@ mod tests {
             query: QueryOptions {
                 batch_interval_start: Some(1_000_000),
                 batch_interval_duration: Some(1_000),
-                batch_id: None,
-                current_batch: false,
             },
         };
         let task_id_encoded = URL_SAFE_NO_PAD.encode(task_id.get_encoded().unwrap());
@@ -1566,8 +1418,6 @@ mod tests {
             query: QueryOptions {
                 batch_interval_start: Some(1_000_000),
                 batch_interval_duration: Some(1_000),
-                batch_id: None,
-                current_batch: false,
             },
         };
         let task_id_encoded = URL_SAFE_NO_PAD.encode(task_id.get_encoded().unwrap());
diff --git a/tools/tests/cmd/collect.trycmd b/tools/tests/cmd/collect.trycmd
index 702943250..5c6e7a7f4 100644
--- a/tools/tests/cmd/collect.trycmd
+++ b/tools/tests/cmd/collect.trycmd
@@ -4,7 +4,7 @@ Command-line DAP-PPM collector from ISRG's Divvi Up
 
 The default subcommand is "run", which will create a collection job and poll it to completion
 
-Usage: collect [OPTIONS] --task-id <TASK_ID> --leader <LEADER> --vdaf <VDAF> <--hpke-config <HPKE_CONFIG>|--hpke-private-key <HPKE_PRIVATE_KEY>|--collector-credential-file <COLLECTOR_CREDENTIAL_FILE>|--collector-credential <COLLECTOR_CREDENTIAL>> <--batch-interval-start <BATCH_INTERVAL_START>|--batch-interval-duration <BATCH_INTERVAL_DURATION>|--batch-id <BATCH_ID>|--current-batch> [COMMAND]
+Usage: collect [OPTIONS] --task-id <TASK_ID> --leader <LEADER> --vdaf <VDAF> <--hpke-config <HPKE_CONFIG>|--hpke-private-key <HPKE_PRIVATE_KEY>|--collector-credential-file <COLLECTOR_CREDENTIAL_FILE>|--collector-credential <COLLECTOR_CREDENTIAL>> [COMMAND]
 
 Commands:
   run       Create a new collection job and poll it to completion
@@ -83,11 +83,4 @@ Collect Request Parameters (Time Interval):
       --batch-interval-duration <BATCH_INTERVAL_DURATION>
           Duration of the collection batch interval, in seconds
 
-Collect Request Parameters (Leader Selected):
-      --batch-id <BATCH_ID>
-          Batch identifier, encoded with base64url
-
-      --current-batch
-          Have the aggregator select a batch that has not yet been collected
-
 ```