Premium apps

Twinworks Buffer Allocation Optimiser

Distribute a fixed number of buffer places over a line for maximum throughput.

A Twinworks project (.twinworks.json, format "twinworks-project") or a bare model with "nodes" and "links". Times in seconds, lengths in metres. Leave empty and pick a template instead.

More options

Places to distribute over the buffers. Default: the sum of the current capacities (same space, better placement).

Comma-separated ids (e.g. B1,B2,B3). Default: every buffer with a finite capacity.

h

Overrides the model setting.

Try an example: Bottleneck demo: 8 places over four buffers · 3-station line: redistribute the current 10 places

More about this tool

How it works

Solves the buffer allocation problem of a production line by simulation: a fixed total of buffer places (for example the floor space you have) is distributed over the buffers so that throughput is as high as possible. Greedy marginal allocation with common random numbers, compared against the current allocation with a paired confidence interval.

  • Every buffer starts at the minimum capacity; then, one place at a time, each buffer is tried with one more place and the place goes to the buffer with the highest mean throughput (ties: lower mean lead time). This greedy marginal allocation is the standard heuristic for the buffer allocation problem of serial lines.
  • All candidates use the same random-number seeds (common random numbers), so differences are caused by the allocation and not by noise; the gain over the current allocation is a paired Student-t interval.

Greedy allocation is a heuristic: it is optimal or near-optimal for typical serial lines but not guaranteed for every network. Confirm the result with more replications in the app.

Sources

Part of Twinworks

  • Twinworks Factory digital twin & production simulation

    Model a production line, simulate it and find the bottleneck — free, in your browser.

    Open Twinworks

Related tools

How to use the Twinworks Buffer Allocation Optimiser

Spread a fixed number of buffer places over a production line by simulation so throughput is as high as possible, and see the gain over today's layout.

What it is for

Floor space is limited, so you can't simply make every buffer bigger. The real question is where a given number of places does the most good. Splitting them evenly is the usual default, and it's rarely the best answer: a buffer in front of a variable or failure-prone station is worth far more than one between two steady machines.

This tool solves that buffer allocation problem by simulation. Give it a Twinworks model or template and a total number of places, by default the sum of today's capacities, so you get "same space, better placement". Every buffer starts at the minimum. Then, one place at a time, the tool tries adding it to each buffer and keeps the option with the highest mean throughput. All candidates share the same random numbers, and the final layout is compared with the current one using a paired confidence interval.

The result includes the optimised model and a link to open it in the Twinworks app. Greedy allocation is a heuristic: it is optimal or close to optimal for typical serial lines, but not guaranteed for every network.

Worked example

The first example distributes 8 places over the four buffers of the bottleneck demo template, currently 2 + 2 + 2 + 2, with 3 replications of 6 h per candidate.

8 buffer places: B1=1, B2=4, B3=2, B4=1 gives 97.13 parts/h (current allocation 95.2, significant gain); 6 well-placed places already reach the current throughput.

The steps show how it got there. Starting from 1 + 1 + 1 + 1 (93.0 parts/h), places went to B2, B2, B3, then B2 again. B2 sits in front of OP30 Hone, the variable station, and B3 sits behind it. The gain over the current layout is +1.93 parts/h, with a paired interval of 1.65 to 2.22, so it's real. Mean lead time stayed the same (314 s), and WIP rose slightly from 8.38 to 8.54.

The second line is just as useful: six well-placed places reach today's throughput. If you need floor space for something else, you can free two places without losing output.

How to read the result

  • Current: today's capacities with throughput, lead time and WIP.
  • Best: the recommended capacities and the same three figures.
  • Gain: best minus current, as a paired interval. If it lies entirely above zero, the improvement is significant.
  • Steps: the order in which places were added and the throughput after each. Early steps show which buffers matter most.
  • Places for current throughput: the smallest total that matches today's output.
  • Evaluations: how many simulated candidates were tested (18 here).

Tips and common mistakes

  • The absolute throughput intervals look wide (±24 parts/h here), but the paired gain interval is narrow. Use the gain to decide.
  • Set Minimum per buffer to whatever your conveyors or fixtures physically need. A buffer of 1 may not be possible in practice.
  • Name the buffers you want to optimise in Buffer ids if some are fixed, for example a cooling section.
  • If the result equals the current layout with "no significant gain", buffers aren't your limit. In the 3-station line example 9 of 10 places went to B1 with an identical 62.84 parts/h, because arrivals limit that line.
  • Confirm the winning layout with more replications in the app before moving equipment.

FAQ

Is the greedy result the true optimum?

Not guaranteed. It's the standard heuristic for serial lines and usually optimal or very close. More replications reduce the chance of a noisy pick.

Can I add more places than I have today?

Yes. Set Total buffer places higher, for example to test whether two extra places are worth the space.

Why did a buffer drop to the minimum?

Extra places there added less throughput than anywhere else, typically between two steady, fast stations.

Does it change machines or cycle times?

No. Only buffer capacities change; everything else in the model stays as it is.

Guide last updated:

For scripts and AI agents

  • JSON API: POST https://twinworksbufferallocation.usefulweb.app/api/v1/calculate (same calculation as this page)
  • Interface description: OpenAPI 3.1 · AI guide: llms.txt
  • MCP server (Streamable HTTP): https://twinworksbufferallocation.usefulweb.app/mcp · tool name twinworks_buffer_allocation
Example request
curl -s -X POST https://twinworksbufferallocation.usefulweb.app/api/v1/calculate \
  -H 'content-type: application/json' \
  -d '{"template":"bottleneck-buffer-sizing","total":8,"replications":3,"horizonHours":6}'
Feedback · ideas & bug reports welcome