resource-pool-optimizer
Optimize shared resource pools across multiple construction projects. Balance resource allocation, minimize conflicts, and maximize utilization across the portfolio.
Install / Use
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill resource-pool-optimizerInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of resource-pool-optimizer
resource-pool-optimizer scores 91/100 on our quality scale, 1189th of 4,716 Development & Engineering skills we index (top 26%).
Its SKILL.md is 20 KB long, well organised into 13 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.
It has 333 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so resource-pool-optimizer is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/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-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk ā read a skill before letting an agent act on it.
resource-pool-optimizer compared with similar skills
All 4 of these similar skills score higher than resource-pool-optimizer; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| resource-pool-optimizer (this skill)by datadrivenconstruction | 91 | 333 | 3mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 118.9k | 11d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| hyperframesby heygen-com | 100 | 87.1k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
Frequently asked questions
- How do I install resource-pool-optimizer?
- Run
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill resource-pool-optimizer. The install tabs above show the steps for each supported agent. - Which AI agents does resource-pool-optimizer work with?
- It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is resource-pool-optimizer 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 MIT-licensed and scores 100/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 resource-pool-optimizer still maintained?
- The repository was last updated about 3 months ago, so resource-pool-optimizer is actively maintained.
Skill content
View source on GitHubname: "resource-pool-optimizer" description: "Optimize shared resource pools across multiple construction projects. Balance resource allocation, minimize conflicts, and maximize utilization across the portfolio." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "š", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
Resource Pool Optimizer
Overview
Manage and optimize shared resources (equipment, specialized labor, materials) across multiple construction projects. Identify conflicts, balance allocations, and maximize resource utilization while minimizing idle time and project delays.
Resource Pool Concept
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā RESOURCE POOL OPTIMIZATION ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā¤
ā ā
ā RESOURCE POOL PROJECTS ā
ā āāāāāāāāāāāāā āāāāāāāā ā
ā šļø Tower Crane A āāāāāāāāāāāā Project 1 (Weeks 1-8) ā
ā šļø Tower Crane B āāāāāāāāāāāā Project 2 (Weeks 3-12) ā
ā š§ Excavator Fleet āāāāāā¬āāāāāā Project 1 (Weeks 1-4) ā
ā āāāāāāā Project 3 (Weeks 5-10) ā
ā š· Steel Crew A āāāāāāāāāāāā Project 2 (Weeks 6-15) ā
ā š· Steel Crew B āāāāāā¬āāāāāā Project 1 (Weeks 8-14) ā
ā āāāāāāā Project 3 (Weeks 15-20) ā
ā ā
ā OPTIMIZATION GOALS: ā
ā ⢠Minimize idle time between projects ā
ā ⢠Avoid double-booking conflicts ā
ā ⢠Prioritize critical path activities ā
ā ⢠Balance utilization across resources ā
ā ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
Technical Implementation
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple, Set
from datetime import datetime, timedelta
from enum import Enum
import heapq
class ResourceType(Enum):
EQUIPMENT = "equipment"
LABOR_CREW = "labor_crew"
MATERIAL = "material"
SPECIALTY = "specialty"
class AllocationStatus(Enum):
AVAILABLE = "available"
ALLOCATED = "allocated"
MAINTENANCE = "maintenance"
CONFLICT = "conflict"
class Priority(Enum):
CRITICAL = 1
HIGH = 2
NORMAL = 3
LOW = 4
@dataclass
class Resource:
id: str
name: str
resource_type: ResourceType
capacity: float = 1.0 # Can be split (e.g., crew size)
daily_cost: float = 0.0
home_location: str = ""
mobilization_days: int = 1
skills: List[str] = field(default_factory=list)
@dataclass
class ResourceRequest:
id: str
project_id: str
project_name: str
resource_type: ResourceType
required_skills: List[str]
start_date: datetime
end_date: datetime
quantity_needed: float = 1.0
priority: Priority = Priority.NORMAL
is_critical_path: bool = False
flexibility_days: int = 0 # Can shift by this many days
notes: str = ""
@dataclass
class Allocation:
id: str
resource_id: str
request_id: str
project_id: str
start_date: datetime
end_date: datetime
quantity: float
status: AllocationStatus = AllocationStatus.ALLOCATED
@dataclass
class Conflict:
resource_id: str
resource_name: str
date: datetime
requests: List[ResourceRequest]
total_demand: float
available: float
resolution_options: List[str]
@dataclass
class UtilizationReport:
resource_id: str
resource_name: str
period_start: datetime
period_end: datetime
total_days: int
allocated_days: int
utilization_pct: float
idle_periods: List[Tuple[datetime, datetime]]
cost: float
class ResourcePoolOptimizer:
"""Optimize shared resources across projects."""
def __init__(self, pool_name: str):
self.pool_name = pool_name
self.resources: Dict[str, Resource] = {}
self.requests: Dict[str, ResourceRequest] = {}
self.allocations: Dict[str, Allocation] = {}
def add_resource(self, id: str, name: str, resource_type: ResourceType,
capacity: float = 1.0, daily_cost: float = 0.0,
skills: List[str] = None) -> Resource:
"""Add resource to pool."""
resource = Resource(
id=id,
name=name,
resource_type=resource_type,
capacity=capacity,
daily_cost=daily_cost,
skills=skills or []
)
self.resources[id] = resource
return resource
def add_request(self, project_id: str, project_name: str,
resource_type: ResourceType, start_date: datetime,
end_date: datetime, quantity: float = 1.0,
priority: Priority = Priority.NORMAL,
required_skills: List[str] = None,
is_critical_path: bool = False,
flexibility_days: int = 0) -> ResourceRequest:
"""Add resource request from project."""
request_id = f"REQ-{project_id}-{len(self.requests)+1:03d}"
request = ResourceRequest(
id=request_id,
project_id=project_id,
project_name=project_name,
resource_type=resource_type,
required_skills=required_skills or [],
start_date=start_date,
end_date=end_date,
quantity_needed=quantity,
priority=priority,
is_critical_path=is_critical_path,
flexibility_days=flexibility_days
)
self.requests[request_id] = request
return request
def find_available_resources(self, request: ResourceRequest) -> List[Tuple[Resource, float]]:
"""Find resources that can fulfill request."""
available = []
for resource in self.resources.values():
# Check type match
if resource.resource_type != request.resource_type:
continue
# Check skills match
if request.required_skills:
if not all(skill in resource.skills for skill in request.required_skills):
continue
# Check availability
available_qty = self._get_availability(
resource.id, request.start_date, request.end_date
)
if available_qty > 0:
available.append((resource, available_qty))
return sorted(available, key=lambda x: -x[1])
def _get_availability(self, resource_id: str, start: datetime, end: datetime) -> float:
"""Get available capacity for resource in period."""
resource = self.resources.get(resource_id)
if not resource:
return 0
# Find overlapping allocations
allocated = 0
for alloc in self.allocations.values():
if alloc.resource_id != resource_id:
continue
# Check overlap
if alloc.start_date < end and alloc.end_date > start:
allocated = max(allocated, alloc.quantity)
return resource.capacity - allocated
def allocate(self, request_id: str, resource_id: str,
quantity: float = None) -> Allocation:
"""Allocate resource to request."""
if request_id not in self.requests:
raise ValueError(f"Request {request_id} not found")
if resource_id not in self.resources:
raise ValueError(f"Resource {resource_id} not found")
request = self.requests[request_id]
resource = self.resources[resource_id]
if quantity is None:
quantity = min(request.quantity_needed, resource.capacity)
# Check availability
available = self._get_availability(
resource_id, request.start_date, request.end_date
)
if available < quantity:
raise ValueError(f"Insufficient capacity. Available: {available}, Requested: {quantity}")
alloc_id = f"ALLOC-{len(self.allocations)+1:04d}"
allocation = Allocation(
id=alloc_id,
resource_id=resource_id,
request_id=request_id,
project_id=request.project_id,
start_date=request.start_date,
end_date=request.end_date,
quantity=quantity
)
self.allocations[alloc_id] = allocation
return allocation
def auto_allocate(self) -> Dict[str, List[Allocation]]:
"""Automatically allocate resources using priority-based algorithm."""
results = {"allocated": [], "unallocated": [], "conflicts": []}
# Sort requests by priority and critical path
sorted_requests = sorted(
self.requests.values(),
key=lambda r: (r.priority.value, not r.is_critical_path, r.start_date)
)
for request in sorted_requests:
# Check if already allocated
existing = [a for a in self.allocations.values()
if a.request_id == request.id]
if existing:
continue
# Find available resources
available = self.find_available_resources(request)
if not available:
results["unallocated"].append(request)
continue
# Allocate best match
resource, qty = available[0]
try:
allocation = self.allocate(request.id, resource.id,
min(request.quantity_needed, qty))
results["allocated"].append(allocation)
except ValueError:
results["conflicts"].append(request)
return results
def detect_conflicts(self) -> List[Conflict]:
"""Detect resource conflicts across all requests."""
conflicts = []
# Group requests by resource type
by_type: Dict[ResourceType, List[ResourceRequest]] = {}
for req in self.requests.values():
if req.resource_type not in by_type:
by_type[req.resource_type] = []
by_type[req.resource_type].append(req)
# Check each resource type
for resource_type, requests in by_type.items():
# Get all resources of this type
resources = [r for r in self.resources.values()
if r.resource_type == resource_type]
total_capacity = sum(r.capacity for r in resources)
# Check each day for conflicts
all_dates = set()
for req in requests:
current = req.start_date
while current <= req.end_date:
all_dates.add(current)
current += timedelta(days=1)
for date in sorted(all_dates):
# Sum demand for this date
day_requests = [r for r in requests
if r.start_date <= date <= r.end_date]
total_demand = sum(r.quantity_needed for r in day_requests)
if total_demand > total_capacity:
# Generate resolution options
options = []
for req in sorted(day_requests, key=lambda x: x.priority.value, reverse=True):
if req.flexibility_days > 0:
options.append(f"Shift {req.project_name} by {req.flexibility_days} days")
options.append("Add additional resource")
options.append("Extend work hours")
conflict = Conflict(
Truncated for display ā read the full file on GitHub.
Related Skills
taste-skill
118.9kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu ā one CLI, zero API fees.
hyperframes
87.1kAI video you can actually edit. HyperFrames is a free, open-source AI video editor. Describe any video and get a real project you can change down to the frame.
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
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.
