fragmentation-aware-packing
Choose placements that preserve useful residual capacity. Use for bin packing, GPU sharing, accelerator placement, and multi-resource scheduling where stranded capacity hurts future fit.
Install / Use
npx skills add benchflow-ai/skillsbench --skill fragmentation-aware-packingInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of fragmentation-aware-packing
fragmentation-aware-packing scores 81/100 on our quality scale, 3471st of 4,698 Development & Engineering skills we index.
Its SKILL.md is 3.8 KB long, split into 6 sections with 3 code examples: a solid amount of guidance for an agent.
With 1,813 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-08 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-02. Automated pattern scan on 2026-10-02. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
fragmentation-aware-packing compared with similar skills
All 4 of these similar skills score higher than fragmentation-aware-packing; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| fragmentation-aware-packing (this skill)by benchflow-ai | 81 | 1.8k | 4mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install fragmentation-aware-packing?
- Run
npx skills add benchflow-ai/skillsbench --skill fragmentation-aware-packing. The install tabs above show the steps for each supported agent. - Which AI agents does fragmentation-aware-packing work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is fragmentation-aware-packing safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is fragmentation-aware-packing still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: fragmentation-aware-packing description: Choose placements that preserve useful residual capacity. Use for bin packing, GPU sharing, accelerator placement, and multi-resource scheduling where stranded capacity hurts future fit.
Fragmentation-Aware Packing
Use this skill when several feasible placements exist and the choice affects future capacity.
Core Idea
A placement is not good just because it fits. Good placements preserve useful residual capacity. With fractional GPUs, this often means packing small compatible jobs together while preserving whole or scarce GPU slots. The same idea applies to any slots, bins, or resources with discrete capacities.
Marginal Fragmentation
For each feasible placement, compute a local before/after estimate:
- Measure current free capacity by resource type and slot.
- Copy the target machine or bin state.
- Compute
fragmentation_before. - Apply the candidate placement.
- Compute
fragmentation_after. - Set
marginal_fragmentation = fragmentation_after - fragmentation_before.
best = None
for placement in feasible_placements:
target_before = copy(target_state)
fragmentation_before = estimate_fragmentation(target_before, workload_types)
target_after = apply(placement, target_before)
fragmentation_after = estimate_fragmentation(target_after, workload_types)
marginal_fragmentation = fragmentation_after - fragmentation_before
score = weighted_action_score(
marginal_fragmentation=marginal_fragmentation,
other_component_deltas=estimate_other_deltas(placement)
)
best = lower_score(best, placement, score)
choose best
Respect hard feasibility first. Use marginal_fragmentation as an input to the weighted action score, not as the only decision rule.
Estimating Fragmentation
When workload shape probabilities are available, such as workload_types from cluster_config.json, use them to estimate which free capacity is likely to be useful:
fragmentation = 0
for workload_type in workload_types_from_cluster_config:
if workload_type.gpu_type is incompatible with target.gpu_type:
continue
can_fit =
target.cpu_free >= workload_type.cpu_units
and target.memory_free >= workload_type.memory_units
and any(slot.free_gpu_units >= workload_type.gpu_units
for slot in target.gpu_slots)
compatible_free_gpu = sum(slot.free_gpu_units for slot in target.gpu_slots)
if not can_fit:
fragmentation += workload_type.probability * compatible_free_gpu
else:
small_fragments = sum(
slot.free_gpu_units
for slot in target.gpu_slots
if 0 < slot.free_gpu_units < workload_type.gpu_units
)
fragmentation += workload_type.probability * small_fragments
Intuitive Example
If two 50-unit GPU jobs can share one 100-unit GPU slot, placing both on the same slot leaves another full slot free. Placing them on two separate slots creates two 50-unit leftovers, which may be harder for future 75- or 100-unit jobs to use.
The same pattern appears outside GPUs: two small tasks may belong in one bin so another bin remains available for a large task. When scores are close, use stable tie-breaks such as urgency, priority, smaller harmless leftovers, and deterministic target order.
Weighted Objective Context
Fragmentation is one objective component. A placement with slightly worse fragmentation may still be better if it substantially improves another weighted component, such as waiting, lateness, resource activation, or unserved-work cost. Conversely, a placement with excellent fragmentation may be bad if it causes a large cost elsewhere.
Use the before/after fragmentation estimate as one delta in a general score:
weighted_marginal_score =
fragmentation_weight * marginal_fragmentation
+ other_weight_1 * delta_other_component_1
+ other_weight_2 * delta_other_component_2
+ deterministic_tie_break
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6k🤯 LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
