Limit concurrency of asyncronous pipeline building blocks
Sebastian
Asynchronous pipeline-based building blocks are not limited by the available capacity of meshStack runners in the same way as synchronous building blocks.
When a building block depends on another building block and the dependency's definition is updated, meshStack triggers new runs for the dependent (parent) building blocks as well.
We have a building block that has been ordered more than 80 times. When we update its dependency, all 80 instances are triggered almost simultaneously.
This results in 80 pipeline executions being dispatched and queued in our external CI/CD system, waiting for available pipeline runners.
Unfortunately, we haven't found an easy way to control the concurrency of these executions at the meshStack runner level. Currently, the only practical workaround seems to be maintaining a separate agent pool exclusively for these building blocks.
Expected behavior
We would like to have configurable concurrency limits for building block runners, particularly for asynchronous building blocks.
For example:
Configure a maximum number of concurrent executions per runner (e.g. 5).
Additional runs remain queued in meshStack until execution capacity becomes available.
Once an execution finishes, the next queued run is dispatched automatically.
Ideally, the concurrency limit could be configured per runner or even per building block definition.
This would allow us to control the load on external CI/CD systems without having to introduce dedicated agent pools or implement additional throttling mechanisms in our pipelines.
Benefit
Configurable concurrency limits would provide better control over external execution capacity, prevent sudden spikes in pipeline workloads, and make asynchronous building blocks easier to operate at scale.

Janny the AI Product Manager
Thanks for the super detailed write-up — this is really helpful, and the example with 80 dependent runs makes the impact very clear.
Concurrency controls for async building blocks (so runs queue in meshStack and only dispatch up to a configured limit) makes a lot of sense, especially to avoid flooding external CI/CD runner capacity.
A couple quick questions so we can share the right context with the team:
1) Which external CI/CD system(s) are you dispatching to (e.g., GitHub Actions, GitLab, Azure DevOps, Jenkins), and do you already have any concurrency limits there that you’d want meshStack to respect?
2) Would you prefer the limit to apply globally per runner, per building block definition, or both (e.g., “runner max=5” plus “this building block max=2”)?
3) When the limit is hit, is “queue in meshStack and dispatch later” always the desired behavior, or would you ever want alternative behavior (e.g., coalesce/skip intermediate runs and only execute the latest)?
We’ll share this with the product team — the operational benefit you described (preventing spikes and avoiding dedicated agent pools) is very clear.