diff --git a/examples/c/ADM_deploy_adhoc_storage.c b/examples/c/ADM_deploy_adhoc_storage.c
index 7985be8734acd0ddbaf64a6dabecfc2570f193ba..e74254313c8742a7d6970c7246954dbcb3e3b0a5 100644
--- a/examples/c/ADM_deploy_adhoc_storage.c
+++ b/examples/c/ADM_deploy_adhoc_storage.c
@@ -42,28 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-    ADM_job_t job;
-
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -71,21 +49,9 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
 
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -98,7 +64,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_deploy_adhoc_storage(server, job, adhoc_storage);
+    ret = ADM_deploy_adhoc_storage(server, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
diff --git a/examples/c/ADM_register_adhoc_storage.c b/examples/c/ADM_register_adhoc_storage.c
index 2964ae5147ed9915add3d15a0c8ae1a489e144dc..1469db2bb91319899d8f4228d3d22a67433bd6d5 100644
--- a/examples/c/ADM_register_adhoc_storage.c
+++ b/examples/c/ADM_register_adhoc_storage.c
@@ -42,9 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-
-    ADM_job_t job;
-
     ADM_dataset_t inputs[NINPUTS];
 
     for(int i = 0; i < NINPUTS; ++i) {
@@ -76,17 +73,9 @@ main(int argc, char* argv[]) {
             ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
     assert(reqs);
 
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
 
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
diff --git a/examples/c/ADM_remove_adhoc_storage.c b/examples/c/ADM_remove_adhoc_storage.c
index b84208d723776eb4d0271bb183a418deea496995..d79d6ed7e69ea300dbf00ededb77b1704d190ebc 100644
--- a/examples/c/ADM_remove_adhoc_storage.c
+++ b/examples/c/ADM_remove_adhoc_storage.c
@@ -42,28 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-
-    ADM_job_t job;
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -71,20 +49,8 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -97,7 +63,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_remove_adhoc_storage(server, job, adhoc_storage);
+    ret = ADM_remove_adhoc_storage(server, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
diff --git a/examples/c/ADM_update_adhoc_storage.c b/examples/c/ADM_update_adhoc_storage.c
index c8dbaf74bd35fe7f7856db531a25a67d96068693..c5dd62b2b4b2e837f4ac595656157bdd697bd641 100644
--- a/examples/c/ADM_update_adhoc_storage.c
+++ b/examples/c/ADM_update_adhoc_storage.c
@@ -42,27 +42,6 @@ main(int argc, char* argv[]) {
     int exit_status = EXIT_SUCCESS;
     ADM_server_t server = ADM_server_create("tcp", argv[1]);
 
-    ADM_job_t job;
-    ADM_dataset_t inputs[NINPUTS];
-
-    for(int i = 0; i < NINPUTS; ++i) {
-        const char* pattern = "input-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        inputs[i] = ADM_dataset_create(id);
-    }
-
-    ADM_dataset_t outputs[NOUTPUTS];
-
-    for(int i = 0; i < NOUTPUTS; ++i) {
-        const char* pattern = "output-dataset-%d";
-        size_t n = snprintf(NULL, 0, pattern, i);
-        char* id = (char*) alloca(n + 1);
-        snprintf(id, n + 1, pattern, i);
-        outputs[i] = ADM_dataset_create(id);
-    }
-
     ADM_adhoc_context_t ctx = ADM_adhoc_context_create(
             ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, 42, 100, false);
     assert(ctx);
@@ -70,20 +49,8 @@ main(int argc, char* argv[]) {
     ADM_storage_t st = ADM_storage_create("foobar", ADM_STORAGE_GEKKOFS, ctx);
     assert(st);
 
-    ADM_job_requirements_t reqs =
-            ADM_job_requirements_create(inputs, NINPUTS, outputs, NOUTPUTS, st);
-    assert(reqs);
-
-    ADM_return_t ret = ADM_register_job(server, reqs, &job);
-
-    if(ret != ADM_SUCCESS) {
-        fprintf(stdout, "ADM_register_job() remote procedure not completed "
-                        "successfully\n");
-        exit_status = EXIT_FAILURE;
-    }
-
     ADM_storage_t adhoc_storage;
-    ret = ADM_register_adhoc_storage(server, job, ctx, &adhoc_storage);
+    ADM_return_t ret = ADM_register_adhoc_storage(server, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
@@ -96,7 +63,7 @@ main(int argc, char* argv[]) {
     fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "
                     "successfully\n");
 
-    ret = ADM_update_adhoc_storage(server, job, ctx, adhoc_storage);
+    ret = ADM_update_adhoc_storage(server, ctx, adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stdout,
diff --git a/examples/cxx/ADM_deploy_adhoc_storage.cpp b/examples/cxx/ADM_deploy_adhoc_storage.cpp
index f5badb35a4a58dd13f0f102ced1e4985f20ad2b6..c23cffd3a506ec9c8710703b2ddc81cf6e363d2e 100644
--- a/examples/cxx/ADM_deploy_adhoc_storage.cpp
+++ b/examples/cxx/ADM_deploy_adhoc_storage.cpp
@@ -38,12 +38,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::deploy_adhoc_storage(server, job, adhoc_storage);
+        ret = admire::deploy_adhoc_storage(server, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_deploy_adhoc_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_register_adhoc_storage.cpp b/examples/cxx/ADM_register_adhoc_storage.cpp
index 2a61716940c33a1a3bf0ee1f9ef3519a35205094..50fe30bdb4a498f188922c5cc958fc1cc77b2e82 100644
--- a/examples/cxx/ADM_register_adhoc_storage.cpp
+++ b/examples/cxx/ADM_register_adhoc_storage.cpp
@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_adhoc_context_t ctx{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::register_adhoc_storage(server, job, ctx, &adhoc_storage);
+        ret = admire::register_adhoc_storage(server, ctx, &adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_register_adhoc_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_register_pfs_storage.cpp b/examples/cxx/ADM_register_pfs_storage.cpp
index dc0c83148ece3d238f76f06fdb50f857284ac5a8..6b0c28dbb90e4dbf339be33e39076898a2d0ea23 100644
--- a/examples/cxx/ADM_register_pfs_storage.cpp
+++ b/examples/cxx/ADM_register_pfs_storage.cpp
@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_pfs_context_t ctx{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::register_pfs_storage(server, job, ctx, &pfs_storage);
+        ret = admire::register_pfs_storage(server, ctx, &pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_register_pfs_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_remove_adhoc_storage.cpp b/examples/cxx/ADM_remove_adhoc_storage.cpp
index 9d6f2aea1ea0297567611eb6186072e33c296b92..c803204545a7369c788cf5608d886d4a0d978b8e 100644
--- a/examples/cxx/ADM_remove_adhoc_storage.cpp
+++ b/examples/cxx/ADM_remove_adhoc_storage.cpp
@@ -38,12 +38,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::remove_adhoc_storage(server, job, adhoc_storage);
+        ret = admire::remove_adhoc_storage(server, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_remove_adhoc_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_remove_pfs_storage.cpp b/examples/cxx/ADM_remove_pfs_storage.cpp
index ad05f50b3c8ca081c4ec5eb04cdd4ef8b80c2087..c4ae0588f2ae8e9af833cdf5ea8545105f1a7eb7 100644
--- a/examples/cxx/ADM_remove_pfs_storage.cpp
+++ b/examples/cxx/ADM_remove_pfs_storage.cpp
@@ -37,12 +37,11 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::remove_pfs_storage(server, job, pfs_storage);
+        ret = admire::remove_pfs_storage(server, pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_remove_pfs_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_update_adhoc_storage.cpp b/examples/cxx/ADM_update_adhoc_storage.cpp
index 8b9debd3851ab123ec71f74e01c604480ca9031e..fec1c4b57b5b55428bd38bee57b331bc30128214 100644
--- a/examples/cxx/ADM_update_adhoc_storage.cpp
+++ b/examples/cxx/ADM_update_adhoc_storage.cpp
@@ -38,13 +38,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_adhoc_context_t ctx{};
     ADM_storage_t adhoc_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::update_adhoc_storage(server, job, ctx, adhoc_storage);
+        ret = admire::update_adhoc_storage(server, ctx, adhoc_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_update_adhoc_storage() failed: {}\n",
                    e.what());
diff --git a/examples/cxx/ADM_update_pfs_storage.cpp b/examples/cxx/ADM_update_pfs_storage.cpp
index e09173d58749df4f51c427c86b4124e9e520353f..5e3b5ab3cedd41a059a98615abb0b1e64619e8ed 100644
--- a/examples/cxx/ADM_update_pfs_storage.cpp
+++ b/examples/cxx/ADM_update_pfs_storage.cpp
@@ -37,13 +37,12 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_job_t job{};
     ADM_pfs_context_t ctx{};
     ADM_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {
-        ret = admire::update_pfs_storage(server, job, ctx, pfs_storage);
+        ret = admire::update_pfs_storage(server, ctx, pfs_storage);
     } catch(const std::exception& e) {
         fmt::print(stderr, "FATAL: ADM_update_pfs_storage() failed: {}\n",
                    e.what());
diff --git a/src/lib/admire.cpp b/src/lib/admire.cpp
index 8854823daf5d8da0ba259dd169656a8789258b6b..c5b168552201a9e94bc37e0be8898269f0e7b550 100644
--- a/src/lib/admire.cpp
+++ b/src/lib/admire.cpp
@@ -214,10 +214,10 @@ remove_job(const server& srv, const job& job) {
 }
 
 ADM_return_t
-register_adhoc_storage(const server& srv, ADM_job_t job,
-                       ADM_adhoc_context_t ctx, ADM_storage_t* adhoc_storage) {
+register_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
+                       ADM_storage_t* adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) adhoc_storage;
 
@@ -242,10 +242,10 @@ register_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
+update_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
                      ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) adhoc_storage;
 
@@ -270,10 +270,9 @@ update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
 }
 
 ADM_return_t
-remove_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage) {
+remove_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) adhoc_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};
@@ -297,10 +296,9 @@ remove_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-deploy_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage) {
+deploy_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage) {
+
     (void) srv;
-    (void) job;
     (void) adhoc_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};
@@ -324,10 +322,9 @@ deploy_adhoc_storage(const server& srv, ADM_job_t job,
 }
 
 ADM_return_t
-register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+register_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                      ADM_storage_t* pfs_storage) {
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) pfs_storage;
 
@@ -352,10 +349,9 @@ register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
 }
 
 ADM_return_t
-update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+update_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                    ADM_storage_t pfs_storage) {
     (void) srv;
-    (void) job;
     (void) ctx;
     (void) pfs_storage;
 
@@ -380,10 +376,8 @@ update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
 }
 
 ADM_return_t
-remove_pfs_storage(const server& srv, ADM_job_t job,
-                   ADM_storage_t pfs_storage) {
+remove_pfs_storage(const server& srv, ADM_storage_t pfs_storage) {
     (void) srv;
-    (void) job;
     (void) pfs_storage;
 
     scord::network::rpc_client rpc_client{srv.protocol(), rpc_registration_cb};
diff --git a/src/lib/admire.h b/src/lib/admire.h
index 9a67b4491c3fed06a58567307470328198679885..1404ec4d3338cc4700809421346d0caab6e34503 100644
--- a/src/lib/admire.h
+++ b/src/lib/admire.h
@@ -87,7 +87,6 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job);
  * Register an adhoc storage system.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The EXECUTION_CONTEXT for the adhoc storage system.
  * @param[out] adhoc_storage An ADM_STORAGE referring to the newly-created
  * adhoc storage instance.
@@ -95,15 +94,13 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job);
  * successfully.
  */
 ADM_return_t
-ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                           ADM_adhoc_context_t ctx,
+ADM_register_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
                            ADM_storage_t* adhoc_storage);
 
 /**
  * Update an already-registered adhoc storage system.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The updated EXECUTION_CONTEXT for the adhoc storage system.
  * @param[in] adhoc_storage An ADM_STORAGE referring to the adhoc storage
  * instance of interest.
@@ -111,8 +108,8 @@ ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_adhoc_context_t ctx, ADM_storage_t adhoc_storage);
+ADM_update_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
+                         ADM_storage_t adhoc_storage);
 
 /**
  * Remove an already-registered adhoc storage system.
@@ -125,8 +122,7 @@ ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage);
+ADM_remove_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Initiate the deployment of an adhoc storage system instance.
@@ -138,14 +134,12 @@ ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * @return Returns ADM_SUCCESS if the remote procedure has completed
  */
 ADM_return_t
-ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage);
+ADM_deploy_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Register a PFS storage tier.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The EXECUTION_CONTEXT for the PFS.
  * @param[out] adhoc_storage An ADM_STORAGE referring to the newly-created
  * PFS instance.
@@ -153,14 +147,13 @@ ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_pfs_context_t ctx, ADM_storage_t* pfs_storage);
+ADM_register_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                         ADM_storage_t* pfs_storage);
 
 /**
  * Update an already-registered PFS storage tier.
  *
  * @param[in] server The server to which the request is directed
- * @param[in] job An ADM_JOB identifying the originating job.
  * @param[in] ctx The updated EXECUTION_CONTEXT for the PFS.
  * @param[in] adhoc_storage An ADM_STORAGE referring to the PFS
  * instance of interest.
@@ -168,8 +161,8 @@ ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_pfs_context_t ctx, ADM_storage_t adhoc_storage);
+ADM_update_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                       ADM_storage_t adhoc_storage);
 
 /**
  * Remove an already-registered PFS storage tier.
@@ -182,8 +175,7 @@ ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
  * successfully.
  */
 ADM_return_t
-ADM_remove_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_storage_t adhoc_storage);
+ADM_remove_pfs_storage(ADM_server_t server, ADM_storage_t adhoc_storage);
 
 /**
  * Transfers the dataset identified by the source_name to the storage tier
diff --git a/src/lib/admire.hpp b/src/lib/admire.hpp
index 003af7cbed1c0cde7b3545b1f299157936b64678..a7e5a5171739ce858c7de70d155086d7ccb21820 100644
--- a/src/lib/admire.hpp
+++ b/src/lib/admire.hpp
@@ -57,31 +57,29 @@ ADM_return_t
 remove_job(const server& srv, const job& job);
 
 ADM_return_t
-register_adhoc_storage(const server& srv, ADM_job_t job,
-                       ADM_adhoc_context_t ctx, ADM_storage_t* adhoc_storage);
+register_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
+                       ADM_storage_t* adhoc_storage);
 
 ADM_return_t
-update_adhoc_storage(const server& srv, ADM_job_t job, ADM_adhoc_context_t ctx,
+update_adhoc_storage(const server& srv, ADM_adhoc_context_t ctx,
                      ADM_storage_t adhoc_storage);
 
 ADM_return_t
-remove_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage);
+remove_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage);
 
 ADM_return_t
-deploy_adhoc_storage(const server& srv, ADM_job_t job,
-                     ADM_storage_t adhoc_storage);
+deploy_adhoc_storage(const server& srv, ADM_storage_t adhoc_storage);
 
 ADM_return_t
-register_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+register_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                      ADM_storage_t* pfs_storage);
 
 ADM_return_t
-update_pfs_storage(const server& srv, ADM_job_t job, ADM_pfs_context_t ctx,
+update_pfs_storage(const server& srv, ADM_pfs_context_t ctx,
                    ADM_storage_t pfs_storage);
 
 ADM_return_t
-remove_pfs_storage(const server& srv, ADM_job_t job, ADM_storage_t pfs_storage);
+remove_pfs_storage(const server& srv, ADM_storage_t pfs_storage);
 
 ADM_return_t
 transfer_dataset(const server& srv, ADM_job_t job, ADM_dataset_t** sources,
@@ -134,7 +132,8 @@ finalize_data_operation(const server& srv, ADM_job_t job,
 
 ADM_return_t
 link_transfer_to_data_operation(const server& srv, ADM_job_t job,
-                                ADM_data_operation_t op, ADM_transfer_t transfer, bool should_stream,
+                                ADM_data_operation_t op,
+                                ADM_transfer_t transfer, bool should_stream,
                                 va_list args);
 
 ADM_return_t
diff --git a/src/lib/c_wrapper.cpp b/src/lib/c_wrapper.cpp
index 58dfadc29ecafa13ba5d4316144d3549b7c256cf..dba51d28c3850f6e3fe5c3ca6d9000c4931e94cb 100644
--- a/src/lib/c_wrapper.cpp
+++ b/src/lib/c_wrapper.cpp
@@ -79,67 +79,63 @@ ADM_remove_job(ADM_server_t server, ADM_job_t job) {
 }
 
 ADM_return_t
-ADM_register_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                           ADM_adhoc_context_t ctx,
+ADM_register_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
                            ADM_storage_t* adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::register_adhoc_storage(srv, job, ctx, adhoc_storage);
+    return admire::register_adhoc_storage(srv, ctx, adhoc_storage);
 }
 
 ADM_return_t
-ADM_update_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_adhoc_context_t ctx, ADM_storage_t adhoc_storage) {
+ADM_update_adhoc_storage(ADM_server_t server, ADM_adhoc_context_t ctx,
+                         ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::update_adhoc_storage(srv, job, ctx, adhoc_storage);
+    return admire::update_adhoc_storage(srv, ctx, adhoc_storage);
 }
 
 ADM_return_t
-ADM_remove_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage) {
+ADM_remove_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::remove_adhoc_storage(srv, job, adhoc_storage);
+    return admire::remove_adhoc_storage(srv, adhoc_storage);
 }
 
 ADM_return_t
-ADM_deploy_adhoc_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_storage_t adhoc_storage) {
+ADM_deploy_adhoc_storage(ADM_server_t server, ADM_storage_t adhoc_storage) {
 
     const admire::server srv{server};
 
-    return admire::deploy_adhoc_storage(srv, job, adhoc_storage);
+    return admire::deploy_adhoc_storage(srv, adhoc_storage);
 }
 
 ADM_return_t
-ADM_register_pfs_storage(ADM_server_t server, ADM_job_t job,
-                         ADM_pfs_context_t ctx, ADM_storage_t* pfs_storage) {
+ADM_register_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                         ADM_storage_t* pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::register_pfs_storage(srv, job, ctx, pfs_storage);
+    return admire::register_pfs_storage(srv, ctx, pfs_storage);
 }
 
 ADM_return_t
-ADM_update_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_pfs_context_t ctx, ADM_storage_t pfs_storage) {
+ADM_update_pfs_storage(ADM_server_t server, ADM_pfs_context_t ctx,
+                       ADM_storage_t pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::update_pfs_storage(srv, job, ctx, pfs_storage);
+    return admire::update_pfs_storage(srv, ctx, pfs_storage);
 }
 
 ADM_return_t
-ADM_remove_pfs_storage(ADM_server_t server, ADM_job_t job,
-                       ADM_storage_t pfs_storage) {
+ADM_remove_pfs_storage(ADM_server_t server, ADM_storage_t pfs_storage) {
 
     const admire::server srv{server};
 
-    return admire::remove_pfs_storage(srv, job, pfs_storage);
+    return admire::remove_pfs_storage(srv, pfs_storage);
 }
 
 ADM_return_t