Yes. Run AI tool calls in parallel when their inputs are already known and their execution cannot invalidate one another’s results or changes. Wait when a call requires an earlier result; serialise conflicting updates to the same business resource.
Several tool calls in one model response do not establish that they are safe to execute concurrently. The application still owns dispatch. That distinction matters when an internal agent moves from fetching documents to updating the systems people rely on.
A blanket ban on parallel calls adds waiting to independent work. Unrestricted execution creates a different problem: an agent can finish faster while leaving the wrong record behind.
A model’s batch is a proposal for the runtime
OpenAI’s function-calling documentation describes responses containing multiple calls. Setting parallel_tool_calls to false limits the model to zero or one call in a response. That controls call generation; the application executes the functions.
Anthropic’s parallel-tool guidance makes the distinction explicit: the API does not prescribe execution order for ordinary client-tool calls. The application can run them concurrently, sequentially or in a combination. Anthropic’s computer-use and browser-use tool batches have stricter ordered-execution rules, so check the specific tool contract before applying a generic scheduler.
For Claude’s Messages API with automatic tool choice, disable_parallel_tool_use: true belongs inside tool_choice and limits each response to at most one tool call. It does not establish safe ordering between separate sessions or workers.
These settings are useful controls when a runtime cannot handle concurrent calls safely. They do not replace dependency checks or protection against another process changing a record.
Classify the calls before choosing their execution order
Start with one proposed batch. Ask whether each call has valid inputs without borrowing an unseen result from another call. Then check what resources it reads or changes.
| Proposed work | Dispatch decision | Reason |
|---|---|---|
| Fetch two unrelated documents using known identifiers | Concurrent reads, subject to access and capacity limits | Neither call supplies an input or changes evidence used by the other. |
| Create a case, then attach a note using the newly assigned case ID | Complete creation before generating the attachment call | The second call cannot name its destination until the first result exists. |
| Read a record while another call changes a field needed by that read | Order them according to the intended version | A read-only operation can still race a write. |
| Two tools replace the same account’s follow-up plan | Serialise or reject the conflict using the destination’s concurrency controls | Both calls can be valid individually while one overwrites the other’s work. |
| Read independent records through a constrained API | Bounded concurrency | Independence does not remove rate limits or capacity constraints. |
Sequentially executing a bad batch does not repair invented arguments. If an attachment call already contains a guessed case ID, waiting for creation to finish leaves that wrong ID unchanged. Reject the unresolved call and generate it after receiving the actual identifier, or use an explicit, validated dependency-reference mechanism implemented by the runtime.
Keep rate-limit handling separate from dependency handling. The agent integration guide covers retry budgets and constrained services; backoff cannot resolve an unknown destination ID.
Two correct-looking CRM calls can produce a lost update
Consider a hypothetical account-preparation agent. It reads the account’s follow-up plan, then proposes two replacements: one adds a product trial; the other adds a procurement review. Both tools submit the complete plan they read earlier, each with its own addition.
If the destination accepts both replacements without checking versions, the later write can erase the earlier addition. Every tool response can report success. The business result is still incomplete.
Serial execution alone is insufficient when both payloads were built from the old version. The second operation must either read the current state and reapply its intended change, use a supported atomic operation, or fail a version check and return for reconciliation. Choose the behaviour the destination actually supports.
Give each state-changing operation a conflict key, such as the account and resource being changed. The dispatcher can then overlap unrelated work while holding incompatible writes until their inputs are current. One account’s update need not block every other account.
A lock inside this agent process will not stop another application writing to the same resource. Use destination-enforced concurrency checks where available and reconcile rejected or uncertain changes. This is a proposed runtime design; the model’s tool-calling flag supplies none of those protections.
Return a result for every proposed call
A partially completed batch must remain intelligible to the model. Preserve the association between each call identifier and its actual result. Completion order is not a reliable substitute for that association.
For Claude client-tool batches, the cited guidance requires one tool_result for every tool_use, with the results together in the next user message and before any text. If the runtime skips a call because a prerequisite failed, return an error result explaining that it was not executed. Do not let a missing result look like a successful operation.
Anthropic’s tool-result documentation also distinguishes a tool execution error from a successful result. That lets the next model turn respond to the actual failure rather than building on an assumed change.
Test ordering failures before claiming a speed improvement
Use controlled fixtures with stubbed dependencies before trying this on live records. The following is a proposed acceptance protocol; it is not a reported benchmark or a completed client test.
| Fixture | Evidence required |
|---|---|
| Independent reads finish in reverse order | Each result retains its original call ID and reaches the correct part of the answer. |
| Case creation returns an unexpected ID | The note targets that returned ID; a guessed attachment call is rejected. |
| Two replacements begin from the same resource version | The system preserves both intended changes or exposes a conflict for reconciliation. |
| One prerequisite fails | Dependent work is not executed, and the model receives an explicit failure result. |
| An unrelated worker changes the resource | Destination checks or reconciliation expose the competing update; a local lock is not accepted as sufficient evidence. |
Compare elapsed time only after checking final state. A faster run that loses an update has failed the workflow, regardless of how many tools completed successfully.
Keep this test inside one agent initially. Parallel function calls do not require specialist agents, separate context windows or handoffs. The multi-agent architecture comparison addresses that larger decision; adding agents introduces coordination work beyond tool dispatch.
Model Operator is a Dubai-based AI product studio led by Alexander Chrisostomou. Its AI Initiative Consulting work includes workflow analysis and implementation priorities. If your team is approving concurrent tool execution, bring one real tool trace to Model Operator and agree which calls can overlap before expanding the build.