diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs
new file mode 100644
index 000000000000..3594ffe6e722
--- /dev/null
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs
@@ -0,0 +1,66 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Generated code. DO NOT EDIT!
+
+namespace GoogleCSharpSnippets
+{
+    // [START aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async]
+    using Google.Cloud.AIPlatform.V1;
+    using Google.LongRunning;
+    using System.Threading.Tasks;
+
+    public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets
+    {
+        /// <summary>Snippet for AsyncQueryReasoningEngineAsync</summary>
+        /// <remarks>
+        /// This snippet has been automatically generated and should be regarded as a code template only.
+        /// It will require modifications to work:
+        /// - It may require correct/in-range values for request initialization.
+        /// - It may require specifying regional endpoints when creating the service client as shown in
+        ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
+        /// </remarks>
+        public async Task AsyncQueryReasoningEngineRequestObjectAsync()
+        {
+            // Create client
+            ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync();
+            // Initialize request argument(s)
+            AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest
+            {
+                ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"),
+                InputGcsUri = "",
+                OutputGcsUri = "",
+            };
+            // Make the request
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request);
+
+            // Poll until the returned long-running operation is complete
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
+            // Retrieve the operation result
+            AsyncQueryReasoningEngineResponse result = completedResponse.Result;
+
+            // Or get the name of the operation
+            string operationName = response.Name;
+            // This name can be stored, then the long-running operation retrieved later by name
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName);
+            // Check if the retrieved long-running operation has completed
+            if (retrievedResponse.IsCompleted)
+            {
+                // If it has completed, then access the result
+                AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result;
+            }
+        }
+    }
+    // [END aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async]
+}
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs
new file mode 100644
index 000000000000..d8a5d7938f78
--- /dev/null
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs
@@ -0,0 +1,65 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Generated code. DO NOT EDIT!
+
+namespace GoogleCSharpSnippets
+{
+    // [START aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync]
+    using Google.Cloud.AIPlatform.V1;
+    using Google.LongRunning;
+
+    public sealed partial class GeneratedReasoningEngineExecutionServiceClientSnippets
+    {
+        /// <summary>Snippet for AsyncQueryReasoningEngine</summary>
+        /// <remarks>
+        /// This snippet has been automatically generated and should be regarded as a code template only.
+        /// It will require modifications to work:
+        /// - It may require correct/in-range values for request initialization.
+        /// - It may require specifying regional endpoints when creating the service client as shown in
+        ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
+        /// </remarks>
+        public void AsyncQueryReasoningEngineRequestObject()
+        {
+            // Create client
+            ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create();
+            // Initialize request argument(s)
+            AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest
+            {
+                ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"),
+                InputGcsUri = "",
+                OutputGcsUri = "",
+            };
+            // Make the request
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request);
+
+            // Poll until the returned long-running operation is complete
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> completedResponse = response.PollUntilCompleted();
+            // Retrieve the operation result
+            AsyncQueryReasoningEngineResponse result = completedResponse.Result;
+
+            // Or get the name of the operation
+            string operationName = response.Name;
+            // This name can be stored, then the long-running operation retrieved later by name
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName);
+            // Check if the retrieved long-running operation has completed
+            if (retrievedResponse.IsCompleted)
+            {
+                // If it has completed, then access the result
+                AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result;
+            }
+        }
+    }
+    // [END aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync]
+}
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json
index 7d3ef4ed2817..c2c4b636bffc 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.GeneratedSnippets/snippet_metadata_google.cloud.aiplatform.v1.json
@@ -72222,6 +72222,103 @@
         }
       ]
     },
+    {
+      "regionTag": "aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_sync",
+      "title": "AsyncQueryReasoningEngineRequestObject",
+      "description": "Snippet for AsyncQueryReasoningEngine",
+      "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectSnippet.g.cs",
+      "language": "C_SHARP",
+      "clientMethod": {
+        "shortName": "AsyncQueryReasoningEngine",
+        "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine",
+        "parameters": [
+          {
+            "type": "Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest",
+            "name": "request"
+          },
+          {
+            "type": "Google.Api.Gax.Grpc.CallSettings",
+            "name": "callSettings"
+          }
+        ],
+        "resultType": "Google.LongRunning.Operation<Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse, Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata>",
+        "client": {
+          "shortName": "ReasoningEngineExecutionServiceClient",
+          "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient"
+        },
+        "method": {
+          "shortName": "AsyncQueryReasoningEngine",
+          "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine",
+          "service": {
+            "shortName": "ReasoningEngineExecutionService",
+            "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService"
+          }
+        }
+      },
+      "canonical": true,
+      "origin": "API_DEFINITION",
+      "segments": [
+        {
+          "start": 20,
+          "end": 63,
+          "type": "FULL"
+        },
+        {
+          "start": 35,
+          "end": 61,
+          "type": "SHORT"
+        }
+      ]
+    },
+    {
+      "regionTag": "aiplatform_v1_generated_ReasoningEngineExecutionService_AsyncQueryReasoningEngine_async",
+      "title": "AsyncQueryReasoningEngineRequestObjectAsync",
+      "description": "Snippet for AsyncQueryReasoningEngineAsync",
+      "file": "ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineRequestObjectAsyncSnippet.g.cs",
+      "language": "C_SHARP",
+      "clientMethod": {
+        "shortName": "AsyncQueryReasoningEngineAsync",
+        "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync",
+        "async": true,
+        "parameters": [
+          {
+            "type": "Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest",
+            "name": "request"
+          },
+          {
+            "type": "Google.Api.Gax.Grpc.CallSettings",
+            "name": "callSettings"
+          }
+        ],
+        "resultType": "System.Threading.Tasks.Task<Google.LongRunning.Operation<Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse, Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata>>",
+        "client": {
+          "shortName": "ReasoningEngineExecutionServiceClient",
+          "fullName": "Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceClient"
+        },
+        "method": {
+          "shortName": "AsyncQueryReasoningEngine",
+          "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine",
+          "service": {
+            "shortName": "ReasoningEngineExecutionService",
+            "fullName": "google.cloud.aiplatform.v1.ReasoningEngineExecutionService"
+          }
+        }
+      },
+      "canonical": true,
+      "origin": "API_DEFINITION",
+      "segments": [
+        {
+          "start": 20,
+          "end": 64,
+          "type": "FULL"
+        },
+        {
+          "start": 36,
+          "end": 62,
+          "type": "SHORT"
+        }
+      ]
+    },
     {
       "regionTag": "aiplatform_v1_generated_ReasoningEngineService_CreateReasoningEngine_sync",
       "title": "CreateReasoningEngineRequestObject",
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs
index c51cafb1c8a1..bcf1cf51e043 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1.Snippets/ReasoningEngineExecutionServiceClientSnippets.g.cs
@@ -19,6 +19,7 @@ namespace GoogleCSharpSnippets
     using Google.Api;
     using Google.Api.Gax.Grpc;
     using Google.Cloud.AIPlatform.V1;
+    using Google.LongRunning;
     using Google.Protobuf.WellKnownTypes;
     using System.Threading.Tasks;
 
@@ -89,5 +90,74 @@ public async Task StreamQueryReasoningEngineRequestObject()
             // The response stream has completed
             // End snippet
         }
+
+        /// <summary>Snippet for AsyncQueryReasoningEngine</summary>
+        public void AsyncQueryReasoningEngineRequestObject()
+        {
+            // Snippet: AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest, CallSettings)
+            // Create client
+            ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = ReasoningEngineExecutionServiceClient.Create();
+            // Initialize request argument(s)
+            AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest
+            {
+                ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"),
+                InputGcsUri = "",
+                OutputGcsUri = "",
+            };
+            // Make the request
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> response = reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine(request);
+
+            // Poll until the returned long-running operation is complete
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> completedResponse = response.PollUntilCompleted();
+            // Retrieve the operation result
+            AsyncQueryReasoningEngineResponse result = completedResponse.Result;
+
+            // Or get the name of the operation
+            string operationName = response.Name;
+            // This name can be stored, then the long-running operation retrieved later by name
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> retrievedResponse = reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngine(operationName);
+            // Check if the retrieved long-running operation has completed
+            if (retrievedResponse.IsCompleted)
+            {
+                // If it has completed, then access the result
+                AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result;
+            }
+            // End snippet
+        }
+
+        /// <summary>Snippet for AsyncQueryReasoningEngineAsync</summary>
+        public async Task AsyncQueryReasoningEngineRequestObjectAsync()
+        {
+            // Snippet: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CallSettings)
+            // Additional: AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest, CancellationToken)
+            // Create client
+            ReasoningEngineExecutionServiceClient reasoningEngineExecutionServiceClient = await ReasoningEngineExecutionServiceClient.CreateAsync();
+            // Initialize request argument(s)
+            AsyncQueryReasoningEngineRequest request = new AsyncQueryReasoningEngineRequest
+            {
+                ReasoningEngineName = ReasoningEngineName.FromProjectLocationReasoningEngine("[PROJECT]", "[LOCATION]", "[REASONING_ENGINE]"),
+                InputGcsUri = "",
+                OutputGcsUri = "",
+            };
+            // Make the request
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> response = await reasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync(request);
+
+            // Poll until the returned long-running operation is complete
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
+            // Retrieve the operation result
+            AsyncQueryReasoningEngineResponse result = completedResponse.Result;
+
+            // Or get the name of the operation
+            string operationName = response.Name;
+            // This name can be stored, then the long-running operation retrieved later by name
+            Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> retrievedResponse = await reasoningEngineExecutionServiceClient.PollOnceAsyncQueryReasoningEngineAsync(operationName);
+            // Check if the retrieved long-running operation has completed
+            if (retrievedResponse.IsCompleted)
+            {
+                // If it has completed, then access the result
+                AsyncQueryReasoningEngineResponse retrievedResult = retrievedResponse.Result;
+            }
+            // End snippet
+        }
     }
 }
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs
index 3413125504a3..8771f80695bd 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionService.g.cs
@@ -29,40 +29,59 @@ static ReasoningEngineExecutionServiceReflection() {
             "Zm9ybS52MRocZ29vZ2xlL2FwaS9hbm5vdGF0aW9ucy5wcm90bxoXZ29vZ2xl",
             "L2FwaS9jbGllbnQucHJvdG8aH2dvb2dsZS9hcGkvZmllbGRfYmVoYXZpb3Iu",
             "cHJvdG8aGWdvb2dsZS9hcGkvaHR0cGJvZHkucHJvdG8aGWdvb2dsZS9hcGkv",
-            "cmVzb3VyY2UucHJvdG8aHGdvb2dsZS9wcm90b2J1Zi9zdHJ1Y3QucHJvdG8i",
-            "pgEKG1F1ZXJ5UmVhc29uaW5nRW5naW5lUmVxdWVzdBI/CgRuYW1lGAEgASgJ",
-            "QjHgQQL6QSsKKWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb20vUmVhc29uaW5n",
-            "RW5naW5lEisKBWlucHV0GAIgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVj",
-            "dEID4EEBEhkKDGNsYXNzX21ldGhvZBgDIAEoCUID4EEBIkYKHFF1ZXJ5UmVh",
-            "c29uaW5nRW5naW5lUmVzcG9uc2USJgoGb3V0cHV0GAEgASgLMhYuZ29vZ2xl",
-            "LnByb3RvYnVmLlZhbHVlIqwBCiFTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2lu",
-            "ZVJlcXVlc3QSPwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdv",
-            "b2dsZWFwaXMuY29tL1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgCIAEoCzIX",
-            "Lmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19tZXRob2QY",
-            "AyABKAlCA+BBATKGBAofUmVhc29uaW5nRW5naW5lRXhlY3V0aW9uU2Vydmlj",
-            "ZRLQAQoUUXVlcnlSZWFzb25pbmdFbmdpbmUSNy5nb29nbGUuY2xvdWQuYWlw",
-            "bGF0Zm9ybS52MS5RdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaOC5nb29n",
-            "bGUuY2xvdWQuYWlwbGF0Zm9ybS52MS5RdWVyeVJlYXNvbmluZ0VuZ2luZVJl",
-            "c3BvbnNlIkWC0+STAj8iOi92MS97bmFtZT1wcm9qZWN0cy8qL2xvY2F0aW9u",
-            "cy8qL3JlYXNvbmluZ0VuZ2luZXMvKn06cXVlcnk6ASoSwAEKGlN0cmVhbVF1",
-            "ZXJ5UmVhc29uaW5nRW5naW5lEj0uZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0u",
-            "djEuU3RyZWFtUXVlcnlSZWFzb25pbmdFbmdpbmVSZXF1ZXN0GhQuZ29vZ2xl",
-            "LmFwaS5IdHRwQm9keSJLgtPkkwJFIkAvdjEve25hbWU9cHJvamVjdHMvKi9s",
-            "b2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVzLyp9OnN0cmVhbVF1ZXJ5OgEq",
-            "MAEaTcpBGWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3",
-            "dy5nb29nbGVhcGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQuIBCh5jb20u",
-            "Z29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjFCJFJlYXNvbmluZ0VuZ2luZUV4",
-            "ZWN1dGlvblNlcnZpY2VQcm90b1ABWj5jbG91ZC5nb29nbGUuY29tL2dvL2Fp",
-            "cGxhdGZvcm0vYXBpdjEvYWlwbGF0Zm9ybXBiO2FpcGxhdGZvcm1wYqoCGkdv",
-            "b2dsZS5DbG91ZC5BSVBsYXRmb3JtLlYxygIaR29vZ2xlXENsb3VkXEFJUGxh",
-            "dGZvcm1cVjHqAh1Hb29nbGU6OkNsb3VkOjpBSVBsYXRmb3JtOjpWMWIGcHJv",
-            "dG8z"));
+            "cmVzb3VyY2UucHJvdG8aKmdvb2dsZS9jbG91ZC9haXBsYXRmb3JtL3YxL29w",
+            "ZXJhdGlvbi5wcm90bxojZ29vZ2xlL2xvbmdydW5uaW5nL29wZXJhdGlvbnMu",
+            "cHJvdG8aHGdvb2dsZS9wcm90b2J1Zi9zdHJ1Y3QucHJvdG8ipgEKG1F1ZXJ5",
+            "UmVhc29uaW5nRW5naW5lUmVxdWVzdBI/CgRuYW1lGAEgASgJQjHgQQL6QSsK",
+            "KWFpcGxhdGZvcm0uZ29vZ2xlYXBpcy5jb20vUmVhc29uaW5nRW5naW5lEisK",
+            "BWlucHV0GAIgASgLMhcuZ29vZ2xlLnByb3RvYnVmLlN0cnVjdEID4EEBEhkK",
+            "DGNsYXNzX21ldGhvZBgDIAEoCUID4EEBIkYKHFF1ZXJ5UmVhc29uaW5nRW5n",
+            "aW5lUmVzcG9uc2USJgoGb3V0cHV0GAEgASgLMhYuZ29vZ2xlLnByb3RvYnVm",
+            "LlZhbHVlIqwBCiFTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QS",
+            "PwoEbmFtZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdvb2dsZWFwaXMu",
+            "Y29tL1JlYXNvbmluZ0VuZ2luZRIrCgVpbnB1dBgCIAEoCzIXLmdvb2dsZS5w",
+            "cm90b2J1Zi5TdHJ1Y3RCA+BBARIZCgxjbGFzc19tZXRob2QYAyABKAlCA+BB",
+            "ASKcAQogQXN5bmNRdWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QSPwoEbmFt",
+            "ZRgBIAEoCUIx4EEC+kErCilhaXBsYXRmb3JtLmdvb2dsZWFwaXMuY29tL1Jl",
+            "YXNvbmluZ0VuZ2luZRIaCg1pbnB1dF9nY3NfdXJpGAIgASgJQgPgQQESGwoO",
+            "b3V0cHV0X2djc191cmkYAyABKAlCA+BBASJ8CipBc3luY1F1ZXJ5UmVhc29u",
+            "aW5nRW5naW5lT3BlcmF0aW9uTWV0YWRhdGESTgoQZ2VuZXJpY19tZXRhZGF0",
+            "YRgBIAEoCzI0Lmdvb2dsZS5jbG91ZC5haXBsYXRmb3JtLnYxLkdlbmVyaWNP",
+            "cGVyYXRpb25NZXRhZGF0YSI7CiFBc3luY1F1ZXJ5UmVhc29uaW5nRW5naW5l",
+            "UmVzcG9uc2USFgoOb3V0cHV0X2djc191cmkYASABKAkyzwYKH1JlYXNvbmlu",
+            "Z0VuZ2luZUV4ZWN1dGlvblNlcnZpY2US0AEKFFF1ZXJ5UmVhc29uaW5nRW5n",
+            "aW5lEjcuZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEuUXVlcnlSZWFzb25p",
+            "bmdFbmdpbmVSZXF1ZXN0GjguZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEu",
+            "UXVlcnlSZWFzb25pbmdFbmdpbmVSZXNwb25zZSJFgtPkkwI/IjovdjEve25h",
+            "bWU9cHJvamVjdHMvKi9sb2NhdGlvbnMvKi9yZWFzb25pbmdFbmdpbmVzLyp9",
+            "OnF1ZXJ5OgEqEsABChpTdHJlYW1RdWVyeVJlYXNvbmluZ0VuZ2luZRI9Lmdv",
+            "b2dsZS5jbG91ZC5haXBsYXRmb3JtLnYxLlN0cmVhbVF1ZXJ5UmVhc29uaW5n",
+            "RW5naW5lUmVxdWVzdBoULmdvb2dsZS5hcGkuSHR0cEJvZHkiS4LT5JMCRSJA",
+            "L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25zLyovcmVhc29uaW5nRW5n",
+            "aW5lcy8qfTpzdHJlYW1RdWVyeToBKjABEsYCChlBc3luY1F1ZXJ5UmVhc29u",
+            "aW5nRW5naW5lEjwuZ29vZ2xlLmNsb3VkLmFpcGxhdGZvcm0udjEuQXN5bmNR",
+            "dWVyeVJlYXNvbmluZ0VuZ2luZVJlcXVlc3QaHS5nb29nbGUubG9uZ3J1bm5p",
+            "bmcuT3BlcmF0aW9uIssBykFPCiFBc3luY1F1ZXJ5UmVhc29uaW5nRW5naW5l",
+            "UmVzcG9uc2USKkFzeW5jUXVlcnlSZWFzb25pbmdFbmdpbmVPcGVyYXRpb25N",
+            "ZXRhZGF0YYLT5JMCcyI/L3YxL3tuYW1lPXByb2plY3RzLyovbG9jYXRpb25z",
+            "LyovcmVhc29uaW5nRW5naW5lcy8qfTphc3luY1F1ZXJ5OgEqWi0iKC92MS97",
+            "bmFtZT1yZWFzb25pbmdFbmdpbmVzLyp9OmFzeW5jUXVlcnk6ASoaTcpBGWFp",
+            "cGxhdGZvcm0uZ29vZ2xlYXBpcy5jb23SQS5odHRwczovL3d3dy5nb29nbGVh",
+            "cGlzLmNvbS9hdXRoL2Nsb3VkLXBsYXRmb3JtQuIBCh5jb20uZ29vZ2xlLmNs",
+            "b3VkLmFpcGxhdGZvcm0udjFCJFJlYXNvbmluZ0VuZ2luZUV4ZWN1dGlvblNl",
+            "cnZpY2VQcm90b1ABWj5jbG91ZC5nb29nbGUuY29tL2dvL2FpcGxhdGZvcm0v",
+            "YXBpdjEvYWlwbGF0Zm9ybXBiO2FpcGxhdGZvcm1wYqoCGkdvb2dsZS5DbG91",
+            "ZC5BSVBsYXRmb3JtLlYxygIaR29vZ2xlXENsb3VkXEFJUGxhdGZvcm1cVjHq",
+            "Ah1Hb29nbGU6OkNsb3VkOjpBSVBsYXRmb3JtOjpWMWIGcHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
-          new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, },
+          new pbr::FileDescriptor[] { global::Google.Api.AnnotationsReflection.Descriptor, global::Google.Api.ClientReflection.Descriptor, global::Google.Api.FieldBehaviorReflection.Descriptor, global::Google.Api.HttpbodyReflection.Descriptor, global::Google.Api.ResourceReflection.Descriptor, global::Google.Cloud.AIPlatform.V1.OperationReflection.Descriptor, global::Google.LongRunning.OperationsReflection.Descriptor, global::Google.Protobuf.WellKnownTypes.StructReflection.Descriptor, },
           new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
             new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null),
             new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse.Parser, new[]{ "Output" }, null, null, null, null),
-            new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null)
+            new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser, new[]{ "Name", "Input", "ClassMethod" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest.Parser, new[]{ "Name", "InputGcsUri", "OutputGcsUri" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineOperationMetadata.Parser, new[]{ "GenericMetadata" }, null, null, null, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse), global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineResponse.Parser, new[]{ "OutputGcsUri" }, null, null, null, null)
           }));
     }
     #endregion
@@ -876,6 +895,712 @@ public void MergeFrom(pb::CodedInputStream input) {
 
   }
 
+  /// <summary>
+  /// Request message for
+  /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine].
+  /// </summary>
+  [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
+  public sealed partial class AsyncQueryReasoningEngineRequest : pb::IMessage<AsyncQueryReasoningEngineRequest>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<AsyncQueryReasoningEngineRequest> _parser = new pb::MessageParser<AsyncQueryReasoningEngineRequest>(() => new AsyncQueryReasoningEngineRequest());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<AsyncQueryReasoningEngineRequest> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[3]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineRequest() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineRequest(AsyncQueryReasoningEngineRequest other) : this() {
+      name_ = other.name_;
+      inputGcsUri_ = other.inputGcsUri_;
+      outputGcsUri_ = other.outputGcsUri_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineRequest Clone() {
+      return new AsyncQueryReasoningEngineRequest(this);
+    }
+
+    /// <summary>Field number for the "name" field.</summary>
+    public const int NameFieldNumber = 1;
+    private string name_ = "";
+    /// <summary>
+    /// Required. The name of the ReasoningEngine resource to use.
+    /// Format:
+    /// `projects/{project}/locations/{location}/reasoningEngines/{reasoning_engine}`
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public string Name {
+      get { return name_; }
+      set {
+        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "input_gcs_uri" field.</summary>
+    public const int InputGcsUriFieldNumber = 2;
+    private string inputGcsUri_ = "";
+    /// <summary>
+    /// Optional. Input Cloud Storage URI for the Async query.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public string InputGcsUri {
+      get { return inputGcsUri_; }
+      set {
+        inputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    /// <summary>Field number for the "output_gcs_uri" field.</summary>
+    public const int OutputGcsUriFieldNumber = 3;
+    private string outputGcsUri_ = "";
+    /// <summary>
+    /// Optional. Output Cloud Storage URI for the Async query.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public string OutputGcsUri {
+      get { return outputGcsUri_; }
+      set {
+        outputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as AsyncQueryReasoningEngineRequest);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(AsyncQueryReasoningEngineRequest other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Name != other.Name) return false;
+      if (InputGcsUri != other.InputGcsUri) return false;
+      if (OutputGcsUri != other.OutputGcsUri) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (Name.Length != 0) hash ^= Name.GetHashCode();
+      if (InputGcsUri.Length != 0) hash ^= InputGcsUri.GetHashCode();
+      if (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (InputGcsUri.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(InputGcsUri);
+      }
+      if (OutputGcsUri.Length != 0) {
+        output.WriteRawTag(26);
+        output.WriteString(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (Name.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(Name);
+      }
+      if (InputGcsUri.Length != 0) {
+        output.WriteRawTag(18);
+        output.WriteString(InputGcsUri);
+      }
+      if (OutputGcsUri.Length != 0) {
+        output.WriteRawTag(26);
+        output.WriteString(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (Name.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
+      }
+      if (InputGcsUri.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(InputGcsUri);
+      }
+      if (OutputGcsUri.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(AsyncQueryReasoningEngineRequest other) {
+      if (other == null) {
+        return;
+      }
+      if (other.Name.Length != 0) {
+        Name = other.Name;
+      }
+      if (other.InputGcsUri.Length != 0) {
+        InputGcsUri = other.InputGcsUri;
+      }
+      if (other.OutputGcsUri.Length != 0) {
+        OutputGcsUri = other.OutputGcsUri;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            InputGcsUri = input.ReadString();
+            break;
+          }
+          case 26: {
+            OutputGcsUri = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            Name = input.ReadString();
+            break;
+          }
+          case 18: {
+            InputGcsUri = input.ReadString();
+            break;
+          }
+          case 26: {
+            OutputGcsUri = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Operation metadata message for
+  /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine].
+  /// </summary>
+  [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
+  public sealed partial class AsyncQueryReasoningEngineOperationMetadata : pb::IMessage<AsyncQueryReasoningEngineOperationMetadata>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<AsyncQueryReasoningEngineOperationMetadata> _parser = new pb::MessageParser<AsyncQueryReasoningEngineOperationMetadata>(() => new AsyncQueryReasoningEngineOperationMetadata());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<AsyncQueryReasoningEngineOperationMetadata> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[4]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineOperationMetadata() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineOperationMetadata(AsyncQueryReasoningEngineOperationMetadata other) : this() {
+      genericMetadata_ = other.genericMetadata_ != null ? other.genericMetadata_.Clone() : null;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineOperationMetadata Clone() {
+      return new AsyncQueryReasoningEngineOperationMetadata(this);
+    }
+
+    /// <summary>Field number for the "generic_metadata" field.</summary>
+    public const int GenericMetadataFieldNumber = 1;
+    private global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata genericMetadata_;
+    /// <summary>
+    /// The common part of the operation metadata.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata GenericMetadata {
+      get { return genericMetadata_; }
+      set {
+        genericMetadata_ = value;
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as AsyncQueryReasoningEngineOperationMetadata);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(AsyncQueryReasoningEngineOperationMetadata other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!object.Equals(GenericMetadata, other.GenericMetadata)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (genericMetadata_ != null) hash ^= GenericMetadata.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (genericMetadata_ != null) {
+        output.WriteRawTag(10);
+        output.WriteMessage(GenericMetadata);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (genericMetadata_ != null) {
+        output.WriteRawTag(10);
+        output.WriteMessage(GenericMetadata);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (genericMetadata_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(GenericMetadata);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(AsyncQueryReasoningEngineOperationMetadata other) {
+      if (other == null) {
+        return;
+      }
+      if (other.genericMetadata_ != null) {
+        if (genericMetadata_ == null) {
+          GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata();
+        }
+        GenericMetadata.MergeFrom(other.GenericMetadata);
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            if (genericMetadata_ == null) {
+              GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata();
+            }
+            input.ReadMessage(GenericMetadata);
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            if (genericMetadata_ == null) {
+              GenericMetadata = new global::Google.Cloud.AIPlatform.V1.GenericOperationMetadata();
+            }
+            input.ReadMessage(GenericMetadata);
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
+  /// <summary>
+  /// Response message for
+  /// [ReasoningEngineExecutionService.AsyncQueryReasoningEngine][google.cloud.aiplatform.v1.ReasoningEngineExecutionService.AsyncQueryReasoningEngine].
+  /// </summary>
+  [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
+  public sealed partial class AsyncQueryReasoningEngineResponse : pb::IMessage<AsyncQueryReasoningEngineResponse>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<AsyncQueryReasoningEngineResponse> _parser = new pb::MessageParser<AsyncQueryReasoningEngineResponse>(() => new AsyncQueryReasoningEngineResponse());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<AsyncQueryReasoningEngineResponse> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Google.Cloud.AIPlatform.V1.ReasoningEngineExecutionServiceReflection.Descriptor.MessageTypes[5]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineResponse() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineResponse(AsyncQueryReasoningEngineResponse other) : this() {
+      outputGcsUri_ = other.outputGcsUri_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public AsyncQueryReasoningEngineResponse Clone() {
+      return new AsyncQueryReasoningEngineResponse(this);
+    }
+
+    /// <summary>Field number for the "output_gcs_uri" field.</summary>
+    public const int OutputGcsUriFieldNumber = 1;
+    private string outputGcsUri_ = "";
+    /// <summary>
+    /// Output Cloud Storage URI for the Async query.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public string OutputGcsUri {
+      get { return outputGcsUri_; }
+      set {
+        outputGcsUri_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as AsyncQueryReasoningEngineResponse);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(AsyncQueryReasoningEngineResponse other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (OutputGcsUri != other.OutputGcsUri) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (OutputGcsUri.Length != 0) hash ^= OutputGcsUri.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (OutputGcsUri.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (OutputGcsUri.Length != 0) {
+        output.WriteRawTag(10);
+        output.WriteString(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (OutputGcsUri.Length != 0) {
+        size += 1 + pb::CodedOutputStream.ComputeStringSize(OutputGcsUri);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(AsyncQueryReasoningEngineResponse other) {
+      if (other == null) {
+        return;
+      }
+      if (other.OutputGcsUri.Length != 0) {
+        OutputGcsUri = other.OutputGcsUri;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            OutputGcsUri = input.ReadString();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+      if ((tag & 7) == 4) {
+        // Abort on any end group tag.
+        return;
+      }
+      switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            OutputGcsUri = input.ReadString();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+  }
+
   #endregion
 
 }
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs
index 0e191b466d35..3ff9f663c7e8 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceClient.g.cs
@@ -22,6 +22,7 @@
 using gcl = Google.Cloud.Location;
 using grpccore = Grpc.Core;
 using grpcinter = Grpc.Core.Interceptors;
+using lro = Google.LongRunning;
 using mel = Microsoft.Extensions.Logging;
 using proto = Google.Protobuf;
 using scg = System.Collections.Generic;
@@ -51,6 +52,8 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS
             gax::GaxPreconditions.CheckNotNull(existing, nameof(existing));
             QueryReasoningEngineSettings = existing.QueryReasoningEngineSettings;
             StreamQueryReasoningEngineSettings = existing.StreamQueryReasoningEngineSettings;
+            AsyncQueryReasoningEngineSettings = existing.AsyncQueryReasoningEngineSettings;
+            AsyncQueryReasoningEngineOperationsSettings = existing.AsyncQueryReasoningEngineOperationsSettings.Clone();
             LocationsSettings = existing.LocationsSettings;
             IAMPolicySettings = existing.IAMPolicySettings;
             OnCopy(existing);
@@ -84,6 +87,38 @@ private ReasoningEngineExecutionServiceSettings(ReasoningEngineExecutionServiceS
         /// </remarks>
         public gaxgrpc::CallSettings StreamQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None);
 
+        /// <summary>
+        /// <see cref="gaxgrpc::CallSettings"/> for synchronous and asynchronous calls to
+        /// <c>ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine</c> and
+        /// <c>ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync</c>.
+        /// </summary>
+        /// <remarks>
+        /// <list type="bullet">
+        /// <item><description>This call will not be retried.</description></item>
+        /// <item><description>No timeout is applied.</description></item>
+        /// </list>
+        /// </remarks>
+        public gaxgrpc::CallSettings AsyncQueryReasoningEngineSettings { get; set; } = gaxgrpc::CallSettings.FromExpiration(gax::Expiration.None);
+
+        /// <summary>
+        /// Long Running Operation settings for calls to
+        /// <c>ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngine</c> and
+        /// <c>ReasoningEngineExecutionServiceClient.AsyncQueryReasoningEngineAsync</c>.
+        /// </summary>
+        /// <remarks>
+        /// Uses default <see cref="gax::PollSettings"/> of:
+        /// <list type="bullet">
+        /// <item><description>Initial delay: 20 seconds.</description></item>
+        /// <item><description>Delay multiplier: 1.5</description></item>
+        /// <item><description>Maximum delay: 45 seconds.</description></item>
+        /// <item><description>Total timeout: 24 hours.</description></item>
+        /// </list>
+        /// </remarks>
+        public lro::OperationsSettings AsyncQueryReasoningEngineOperationsSettings { get; set; } = new lro::OperationsSettings
+        {
+            DefaultPollSettings = new gax::PollSettings(gax::Expiration.FromTimeout(sys::TimeSpan.FromHours(24)), sys::TimeSpan.FromSeconds(20), 1.5, sys::TimeSpan.FromSeconds(45)),
+        };
+
         /// <summary>
         /// The settings to use for the <see cref="gcl::LocationsClient"/> associated with the client.
         /// </summary>
@@ -288,6 +323,60 @@ public abstract partial class StreamQueryReasoningEngineStream : gaxgrpc::Server
         /// <returns>The server stream.</returns>
         public virtual StreamQueryReasoningEngineStream StreamQueryReasoningEngine(StreamQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) =>
             throw new sys::NotImplementedException();
+
+        /// <summary>
+        /// Async query using a reasoning engine.
+        /// </summary>
+        /// <param name="request">The request object containing all of the parameters for the API call.</param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>The RPC response.</returns>
+        public virtual lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) =>
+            throw new sys::NotImplementedException();
+
+        /// <summary>
+        /// Async query using a reasoning engine.
+        /// </summary>
+        /// <param name="request">The request object containing all of the parameters for the API call.</param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>A Task containing the RPC response.</returns>
+        public virtual stt::Task<lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null) =>
+            throw new sys::NotImplementedException();
+
+        /// <summary>
+        /// Async query using a reasoning engine.
+        /// </summary>
+        /// <param name="request">The request object containing all of the parameters for the API call.</param>
+        /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param>
+        /// <returns>A Task containing the RPC response.</returns>
+        public virtual stt::Task<lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, st::CancellationToken cancellationToken) =>
+            AsyncQueryReasoningEngineAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
+
+        /// <summary>The long-running operations client for <c>AsyncQueryReasoningEngine</c>.</summary>
+        public virtual lro::OperationsClient AsyncQueryReasoningEngineOperationsClient => throw new sys::NotImplementedException();
+
+        /// <summary>
+        /// Poll an operation once, using an <c>operationName</c> from a previous invocation of
+        /// <c>AsyncQueryReasoningEngine</c>.
+        /// </summary>
+        /// <param name="operationName">
+        /// The name of a previously invoked operation. Must not be <c>null</c> or empty.
+        /// </param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>The result of polling the operation.</returns>
+        public virtual lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> PollOnceAsyncQueryReasoningEngine(string operationName, gaxgrpc::CallSettings callSettings = null) =>
+            lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>.PollOnceFromName(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings);
+
+        /// <summary>
+        /// Asynchronously poll an operation once, using an <c>operationName</c> from a previous invocation of
+        /// <c>AsyncQueryReasoningEngine</c>.
+        /// </summary>
+        /// <param name="operationName">
+        /// The name of a previously invoked operation. Must not be <c>null</c> or empty.
+        /// </param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>A task representing the result of polling the operation.</returns>
+        public virtual stt::Task<lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>> PollOnceAsyncQueryReasoningEngineAsync(string operationName, gaxgrpc::CallSettings callSettings = null) =>
+            lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>.PollOnceFromNameAsync(gax::GaxPreconditions.CheckNotNullOrEmpty(operationName, nameof(operationName)), AsyncQueryReasoningEngineOperationsClient, callSettings);
     }
 
     /// <summary>ReasoningEngineExecutionService client wrapper implementation, for convenient use.</summary>
@@ -300,6 +389,8 @@ public sealed partial class ReasoningEngineExecutionServiceClientImpl : Reasonin
 
         private readonly gaxgrpc::ApiServerStreamingCall<StreamQueryReasoningEngineRequest, ga::HttpBody> _callStreamQueryReasoningEngine;
 
+        private readonly gaxgrpc::ApiCall<AsyncQueryReasoningEngineRequest, lro::Operation> _callAsyncQueryReasoningEngine;
+
         /// <summary>
         /// Constructs a client wrapper for the ReasoningEngineExecutionService service, with the specified gRPC client
         /// and settings.
@@ -318,6 +409,7 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService
                 Settings = effectiveSettings,
                 Logger = logger,
             });
+            AsyncQueryReasoningEngineOperationsClient = new lro::OperationsClientImpl(grpcClient.CreateOperationsClient(), effectiveSettings.AsyncQueryReasoningEngineOperationsSettings, logger);
             LocationsClient = new gcl::LocationsClientImpl(grpcClient.CreateLocationsClient(), effectiveSettings.LocationsSettings, logger);
             IAMPolicyClient = new gciv::IAMPolicyClientImpl(grpcClient.CreateIAMPolicyClient(), effectiveSettings.IAMPolicySettings, logger);
             _callQueryReasoningEngine = clientHelper.BuildApiCall<QueryReasoningEngineRequest, QueryReasoningEngineResponse>("QueryReasoningEngine", grpcClient.QueryReasoningEngineAsync, grpcClient.QueryReasoningEngine, effectiveSettings.QueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name);
@@ -326,6 +418,9 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService
             _callStreamQueryReasoningEngine = clientHelper.BuildApiCall<StreamQueryReasoningEngineRequest, ga::HttpBody>("StreamQueryReasoningEngine", grpcClient.StreamQueryReasoningEngine, effectiveSettings.StreamQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name);
             Modify_ApiCall(ref _callStreamQueryReasoningEngine);
             Modify_StreamQueryReasoningEngineApiCall(ref _callStreamQueryReasoningEngine);
+            _callAsyncQueryReasoningEngine = clientHelper.BuildApiCall<AsyncQueryReasoningEngineRequest, lro::Operation>("AsyncQueryReasoningEngine", grpcClient.AsyncQueryReasoningEngineAsync, grpcClient.AsyncQueryReasoningEngine, effectiveSettings.AsyncQueryReasoningEngineSettings).WithGoogleRequestParam("name", request => request.Name);
+            Modify_ApiCall(ref _callAsyncQueryReasoningEngine);
+            Modify_AsyncQueryReasoningEngineApiCall(ref _callAsyncQueryReasoningEngine);
             OnConstruction(grpcClient, effectiveSettings, clientHelper);
         }
 
@@ -337,6 +432,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService
 
         partial void Modify_StreamQueryReasoningEngineApiCall(ref gaxgrpc::ApiServerStreamingCall<StreamQueryReasoningEngineRequest, ga::HttpBody> call);
 
+        partial void Modify_AsyncQueryReasoningEngineApiCall(ref gaxgrpc::ApiCall<AsyncQueryReasoningEngineRequest, lro::Operation> call);
+
         partial void OnConstruction(ReasoningEngineExecutionService.ReasoningEngineExecutionServiceClient grpcClient, ReasoningEngineExecutionServiceSettings effectiveSettings, gaxgrpc::ClientHelper clientHelper);
 
         /// <summary>The underlying gRPC ReasoningEngineExecutionService client</summary>
@@ -352,6 +449,8 @@ public ReasoningEngineExecutionServiceClientImpl(ReasoningEngineExecutionService
 
         partial void Modify_StreamQueryReasoningEngineRequest(ref StreamQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings);
 
+        partial void Modify_AsyncQueryReasoningEngineRequest(ref AsyncQueryReasoningEngineRequest request, ref gaxgrpc::CallSettings settings);
+
         /// <summary>
         /// Queries using a reasoning engine.
         /// </summary>
@@ -396,6 +495,47 @@ public override ReasoningEngineExecutionServiceClient.StreamQueryReasoningEngine
             Modify_StreamQueryReasoningEngineRequest(ref request, ref callSettings);
             return new StreamQueryReasoningEngineStreamImpl(_callStreamQueryReasoningEngine.Call(request, callSettings));
         }
+
+        /// <summary>The long-running operations client for <c>AsyncQueryReasoningEngine</c>.</summary>
+        public override lro::OperationsClient AsyncQueryReasoningEngineOperationsClient { get; }
+
+        /// <summary>
+        /// Async query using a reasoning engine.
+        /// </summary>
+        /// <param name="request">The request object containing all of the parameters for the API call.</param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>The RPC response.</returns>
+        public override lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata> AsyncQueryReasoningEngine(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null)
+        {
+            Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings);
+            return new lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>(_callAsyncQueryReasoningEngine.Sync(request, callSettings), AsyncQueryReasoningEngineOperationsClient);
+        }
+
+        /// <summary>
+        /// Async query using a reasoning engine.
+        /// </summary>
+        /// <param name="request">The request object containing all of the parameters for the API call.</param>
+        /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
+        /// <returns>A Task containing the RPC response.</returns>
+        public override async stt::Task<lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>> AsyncQueryReasoningEngineAsync(AsyncQueryReasoningEngineRequest request, gaxgrpc::CallSettings callSettings = null)
+        {
+            Modify_AsyncQueryReasoningEngineRequest(ref request, ref callSettings);
+            return new lro::Operation<AsyncQueryReasoningEngineResponse, AsyncQueryReasoningEngineOperationMetadata>(await _callAsyncQueryReasoningEngine.Async(request, callSettings).ConfigureAwait(false), AsyncQueryReasoningEngineOperationsClient);
+        }
+    }
+
+    public static partial class ReasoningEngineExecutionService
+    {
+        public partial class ReasoningEngineExecutionServiceClient
+        {
+            /// <summary>
+            /// Creates a new instance of <see cref="lro::Operations.OperationsClient"/> using the same call invoker as
+            /// this client.
+            /// </summary>
+            /// <returns>A new Operations client for the same target as this client.</returns>
+            public virtual lro::Operations.OperationsClient CreateOperationsClient() =>
+                new lro::Operations.OperationsClient(CallInvoker);
+        }
     }
 
     public static partial class ReasoningEngineExecutionService
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs
index 6409bc844e31..68dc95fed153 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceGrpc.g.cs
@@ -3,7 +3,7 @@
 //     source: google/cloud/aiplatform/v1/reasoning_engine_execution_service.proto
 // </auto-generated>
 // Original file comments:
-// Copyright 2025 Google LLC
+// Copyright 2026 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -71,6 +71,10 @@ static T __Helper_DeserializeMessage<T>(grpc::DeserializationContext context, gl
     static readonly grpc::Marshaller<global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest> __Marshaller_google_cloud_aiplatform_v1_StreamQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest.Parser));
     [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
     static readonly grpc::Marshaller<global::Google.Api.HttpBody> __Marshaller_google_api_HttpBody = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Api.HttpBody.Parser));
+    [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+    static readonly grpc::Marshaller<global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest> __Marshaller_google_cloud_aiplatform_v1_AsyncQueryReasoningEngineRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest.Parser));
+    [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+    static readonly grpc::Marshaller<global::Google.LongRunning.Operation> __Marshaller_google_longrunning_Operation = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Google.LongRunning.Operation.Parser));
 
     [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
     static readonly grpc::Method<global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest, global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse> __Method_QueryReasoningEngine = new grpc::Method<global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest, global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse>(
@@ -88,6 +92,14 @@ static T __Helper_DeserializeMessage<T>(grpc::DeserializationContext context, gl
         __Marshaller_google_cloud_aiplatform_v1_StreamQueryReasoningEngineRequest,
         __Marshaller_google_api_HttpBody);
 
+    [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+    static readonly grpc::Method<global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest, global::Google.LongRunning.Operation> __Method_AsyncQueryReasoningEngine = new grpc::Method<global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest, global::Google.LongRunning.Operation>(
+        grpc::MethodType.Unary,
+        __ServiceName,
+        "AsyncQueryReasoningEngine",
+        __Marshaller_google_cloud_aiplatform_v1_AsyncQueryReasoningEngineRequest,
+        __Marshaller_google_longrunning_Operation);
+
     /// <summary>Service descriptor</summary>
     public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
     {
@@ -123,6 +135,18 @@ public abstract partial class ReasoningEngineExecutionServiceBase
         throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
       }
 
+      /// <summary>
+      /// Async query using a reasoning engine.
+      /// </summary>
+      /// <param name="request">The request received from the client.</param>
+      /// <param name="context">The context of the server-side call handler being invoked.</param>
+      /// <returns>The response to send back to the client (wrapped by a task).</returns>
+      [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+      public virtual global::System.Threading.Tasks.Task<global::Google.LongRunning.Operation> AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::ServerCallContext context)
+      {
+        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
+      }
+
     }
 
     /// <summary>Client for ReasoningEngineExecutionService</summary>
@@ -224,6 +248,54 @@ protected ReasoningEngineExecutionServiceClient(ClientBaseConfiguration configur
       {
         return CallInvoker.AsyncServerStreamingCall(__Method_StreamQueryReasoningEngine, null, options, request);
       }
+      /// <summary>
+      /// Async query using a reasoning engine.
+      /// </summary>
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The response received from the server.</returns>
+      [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+      public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
+      {
+        return AsyncQueryReasoningEngine(request, new grpc::CallOptions(headers, deadline, cancellationToken));
+      }
+      /// <summary>
+      /// Async query using a reasoning engine.
+      /// </summary>
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The response received from the server.</returns>
+      [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+      public virtual global::Google.LongRunning.Operation AsyncQueryReasoningEngine(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options)
+      {
+        return CallInvoker.BlockingUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request);
+      }
+      /// <summary>
+      /// Async query using a reasoning engine.
+      /// </summary>
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The call object.</returns>
+      [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+      public virtual grpc::AsyncUnaryCall<global::Google.LongRunning.Operation> AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
+      {
+        return AsyncQueryReasoningEngineAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
+      }
+      /// <summary>
+      /// Async query using a reasoning engine.
+      /// </summary>
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The call object.</returns>
+      [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
+      public virtual grpc::AsyncUnaryCall<global::Google.LongRunning.Operation> AsyncQueryReasoningEngineAsync(global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest request, grpc::CallOptions options)
+      {
+        return CallInvoker.AsyncUnaryCall(__Method_AsyncQueryReasoningEngine, null, options, request);
+      }
       /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>
       [global::System.CodeDom.Compiler.GeneratedCode("grpc_csharp_plugin", null)]
       protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseConfiguration configuration)
@@ -239,7 +311,8 @@ protected override ReasoningEngineExecutionServiceClient NewInstance(ClientBaseC
     {
       return grpc::ServerServiceDefinition.CreateBuilder()
           .AddMethod(__Method_QueryReasoningEngine, serviceImpl.QueryReasoningEngine)
-          .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine).Build();
+          .AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl.StreamQueryReasoningEngine)
+          .AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl.AsyncQueryReasoningEngine).Build();
     }
 
     /// <summary>Register service method with a service binder with or without implementation. Useful when customizing the service binding logic.
@@ -251,6 +324,7 @@ public static void BindService(grpc::ServiceBinderBase serviceBinder, ReasoningE
     {
       serviceBinder.AddMethod(__Method_QueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineRequest, global::Google.Cloud.AIPlatform.V1.QueryReasoningEngineResponse>(serviceImpl.QueryReasoningEngine));
       serviceBinder.AddMethod(__Method_StreamQueryReasoningEngine, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod<global::Google.Cloud.AIPlatform.V1.StreamQueryReasoningEngineRequest, global::Google.Api.HttpBody>(serviceImpl.StreamQueryReasoningEngine));
+      serviceBinder.AddMethod(__Method_AsyncQueryReasoningEngine, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Google.Cloud.AIPlatform.V1.AsyncQueryReasoningEngineRequest, global::Google.LongRunning.Operation>(serviceImpl.AsyncQueryReasoningEngine));
     }
 
   }
diff --git a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs
index c64db83f5ce3..e61fb07050bf 100644
--- a/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs
+++ b/apis/Google.Cloud.AIPlatform.V1/Google.Cloud.AIPlatform.V1/ReasoningEngineExecutionServiceResourceNames.g.cs
@@ -42,4 +42,16 @@ public partial class StreamQueryReasoningEngineRequest
             set => Name = value?.ToString() ?? "";
         }
     }
+
+    public partial class AsyncQueryReasoningEngineRequest
+    {
+        /// <summary>
+        /// <see cref="gcav::ReasoningEngineName"/>-typed view over the <see cref="Name"/> resource name property.
+        /// </summary>
+        public gcav::ReasoningEngineName ReasoningEngineName
+        {
+            get => string.IsNullOrEmpty(Name) ? null : gcav::ReasoningEngineName.Parse(Name, allowUnparsed: true);
+            set => Name = value?.ToString() ?? "";
+        }
+    }
 }
diff --git a/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json b/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json
index bb28c64bec81..38cc44387eac 100644
--- a/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json
+++ b/apis/Google.Cloud.AIPlatform.V1/gapic_metadata.json
@@ -1765,6 +1765,12 @@
         "grpc": {
           "libraryClient": "ReasoningEngineExecutionServiceClient",
           "rpcs": {
+            "AsyncQueryReasoningEngine": {
+              "methods": [
+                "AsyncQueryReasoningEngine",
+                "AsyncQueryReasoningEngineAsync"
+              ]
+            },
             "QueryReasoningEngine": {
               "methods": [
                 "QueryReasoningEngine",
diff --git a/generator-input/pipeline-state.json b/generator-input/pipeline-state.json
index e9a3a2e47506..87bd49deb866 100644
--- a/generator-input/pipeline-state.json
+++ b/generator-input/pipeline-state.json
@@ -292,7 +292,7 @@
             "generationAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC",
             "releaseAutomationLevel": "AUTOMATION_LEVEL_AUTOMATIC",
             "releaseTimestamp": "2026-04-06T14:08:05.688830893Z",
-            "lastGeneratedCommit": "62e4ecb2f4390728990514fea14aad0431881a52",
+            "lastGeneratedCommit": "1a00cecd9a90ac056247d5b522e94af5347adc1d",
             "lastReleasedCommit": "582172de2d9b6443e1fecf696167867c6d8a5fc4",
             "apiPaths": [
                 "google/cloud/aiplatform/v1"