What happened
AnyLanguageModel’s 1.3.0 release notes say that tool calls made by a model in one round now run at the same time on every provider. The project compares this behavior with Foundation Models, where it says concurrent execution was already possible. The change concerns calls grouped in one tool round, rather than a general claim that every step of an agent workflow is parallel.
The release places an explicit responsibility on tool implementers and integrators. A tool that is not safe to run alongside other tools must serialize its own work. That matters where calls alter shared state, depend on ordering, consume a limited external resource, or trigger side effects. The notes do not say that the runtime will infer these dependencies automatically. Concurrency is therefore a capability exposed by the library, with correctness remaining a property of the tools and the application that wires them together.
The surrounding interaction retains ordered behavior. The release notes say delegate decisions and didExecuteToolCall continue to happen in the model’s order, and the results retain that order as well. In practical terms, execution can overlap while the application-facing sequence remains stable. The concurrent-call work is identified in the changelog as pull request #375.
Version 1.3.0 also adds ToolExecutionDelegate.pendingMessages(in:). This delegate hook lets an application add messages between tool rounds; the release notes use steering a long response while it runs as an example. Its default implementation adds nothing, and messages inserted through the hook do not reset the tool-round limit. SystemLanguageModel does not ask for pending messages because Foundation Models runs its own tool loop. The hook is distinct from concurrent execution: one affects the timing of calls inside a round, while the other supplies an application intervention point between rounds.
The release also changes transcript replay for stopped tool calls. When replaying a turn with a tool call that has no result, the library now supplies the output “The tool call was not executed.” According to the release notes, that prevents the next request from sending a call without a result, which OpenAI and Anthropic reject. The saved transcript is not changed. For Anthropic, text from a tool round is now sent before that round’s tool calls; previously it came after the tool result.
Several smaller changes affect provider adapters and cancellation. With thinking enabled, GeminiLanguageModel leaves thought parts out of response text and replayed text. OpenResponsesLanguageModel now sends a tool output as text rather than a JSON-encoded content block. Cancelled responses on MLXLanguageModel and LlamaLanguageModel throw CancellationError, rather than return cut-off text, and do not append that text to the transcript. HTTP response loops check for cancellation before each request. The README now also links anylanguagemodel-litert-lm, a community package for LiteRT-LM models on iOS and macOS that provides LanguageModel conformance.
What the archive adds
New Runtime covered AnyLanguageModel 1.1.1 on 2026-11-04. Version 1.3.0 is a new release on the same project: it adds concurrent execution and delegate messages between tool rounds rather than restating the earlier version’s release.
Trend signal
This release supports goal-scoped loops replace manual continuation only weakly. pendingMessages(in:) creates a controlled point to influence an agent between tool rounds, but it does not define an external completion contract, verification step, or reliable stopping rule. The main change is execution behavior: it helps a loop perform a requested round more efficiently, not decide whether the larger objective is complete.
Why it matters
For an agent that requests several independent lookups, reads, or computations at once, sequential execution can make a single tool turn wait for the sum of each call’s duration. Running those calls concurrently can instead make the turn approach the duration of its slowest independent call. That may improve perceived responsiveness without changing models, prompts, or provider selection.
The boundary is important. Parallel reads may be straightforward, but writes, purchases, destructive operations, rate-limited APIs, or tools sharing a session can require ordering. AnyLanguageModel’s release notes put serialization responsibility on the unsafe tool itself. Teams should therefore classify tools by side effects and shared dependencies before relying on the new default behavior. Preserved order for delegate decisions and returned results can make migration easier for applications that still need a predictable interaction sequence.
The new delegate hook is also useful as a bounded control surface. It lets an application introduce messages between rounds without extending the configured tool-round limit. That may help a team provide context or steering during an extended response, but it does not replace validation, authorization, or an explicit policy for ending work.
Limits and uncertainty
The release notes do not quantify latency improvements, identify the workloads that benefit most, or compare concurrent and sequential execution under load. They do not describe a built-in dependency detector, locking mechanism, or policy that determines whether two tools are safe to run together. Tool authors and application integrators must make that decision.
The notes also do not measure the operational effect of pendingMessages(in:), including whether it improves reliability or creates new prompt-management complexity. Provider-specific fixes are described by the project, but this release announcement is not an independent evaluation across every supported provider. Adoption, compatibility constraints, and real-world behavior of the linked community LiteRT-LM package are likewise not established here.
Skill to build now
Audit one multi-tool agent flow this week. Mark each tool as read-only and independent, ordered because it shares state, or side-effecting and therefore serialized. Then test an independent same-round group with concurrency enabled, recording latency and checking that ordered result handling still matches application expectations. Add serialization inside any tool whose work cannot safely overlap.
Reader takeaway
AnyLanguageModel 1.3.0 can execute same-round tool calls concurrently while preserving their order in the surrounding interaction. Use it to reduce waiting for genuinely independent work, but make tool safety explicit: concurrency is useful only when shared state, side effects, and external limits are properly controlled.