imc-tuning-rules
Calculate PI/PID controller gains using Internal Model Control (IMC) tuning rules for first-order systems.
Install / Use
npx skills add benchflow-ai/skillsbench --skill imc-tuning-rulesInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of imc-tuning-rules
imc-tuning-rules scores 82/100 on our quality scale, 3260th of 4,698 Development & Engineering skills we index.
Its SKILL.md is 3.5 KB long, well organised into 9 sections with 5 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-07 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-01. Automated pattern scan on 2026-10-01. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
imc-tuning-rules compared with similar skills
All 4 of these similar skills score higher than imc-tuning-rules; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| imc-tuning-rules (this skill)by benchflow-ai | 82 | 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 imc-tuning-rules?
- Run
npx skills add benchflow-ai/skillsbench --skill imc-tuning-rules. The install tabs above show the steps for each supported agent. - Which AI agents does imc-tuning-rules 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 imc-tuning-rules 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 imc-tuning-rules 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: imc-tuning-rules description: Calculate PI/PID controller gains using Internal Model Control (IMC) tuning rules for first-order systems.
IMC Tuning Rules for PI/PID Controllers
Overview
Internal Model Control (IMC) is a systematic method for tuning PI/PID controllers based on a process model. Once you've identified system parameters (K and tau), IMC provides controller gains.
Why IMC?
- Model-based: Uses identified process parameters directly
- Single tuning parameter: Just choose the closed-loop speed (lambda)
- Guaranteed stability: For first-order systems, always stable if model is accurate
- Predictable response: Closed-loop time constant equals lambda
IMC Tuning for First-Order Systems
For a first-order process with gain K and time constant tau:
Process: G(s) = K / (tau*s + 1)
The IMC-tuned PI controller gains are:
Kp = tau / (K * lambda)
Ki = Kp / tau = 1 / (K * lambda)
Kd = 0 (derivative not needed for first-order systems)
Where:
Kp= Proportional gainKi= Integral gain (units: 1/time)Kd= Derivative gain (zero for first-order)lambda= Desired closed-loop time constant (tuning parameter)
Choosing Lambda (λ)
Lambda controls the trade-off between speed and robustness:
| Lambda | Behavior |
|--------|----------|
| lambda = 0.1 * tau | Very aggressive, fast but sensitive to model error |
| lambda = 0.5 * tau | Aggressive, good for accurate models |
| lambda = 1.0 * tau | Moderate, balanced speed and robustness |
| lambda = 2.0 * tau | Conservative, robust to model uncertainty |
Default recommendation: Start with lambda = tau
For noisy systems or uncertain models, use larger lambda. For precise models and fast response needs, use smaller lambda.
Implementation
def calculate_imc_gains(K, tau, lambda_factor=1.0):
"""
Calculate IMC-tuned PI gains for a first-order system.
Args:
K: Process gain
tau: Time constant
lambda_factor: Multiplier for lambda (default 1.0 = lambda equals tau)
Returns:
dict with Kp, Ki, Kd, lambda
"""
lambda_cl = lambda_factor * tau
Kp = tau / (K * lambda_cl)
Ki = Kp / tau
Kd = 0.0
return {
"Kp": Kp,
"Ki": Ki,
"Kd": Kd,
"lambda": lambda_cl
}
PI Controller Implementation
class PIController:
def __init__(self, Kp, Ki, setpoint):
self.Kp = Kp
self.Ki = Ki
self.setpoint = setpoint
self.integral = 0.0
def compute(self, measurement, dt):
"""Compute control output."""
error = self.setpoint - measurement
# Integral term
self.integral += error * dt
# PI control law
output = self.Kp * error + self.Ki * self.integral
# Clamp to valid range
output = max(output_min, min(output_max, output))
return output
Expected Closed-Loop Behavior
With IMC tuning, the closed-loop response is approximately:
y(t) = y_setpoint * (1 - exp(-t / lambda))
Key properties:
- Rise time: ~2.2 * lambda to reach 90% of setpoint
- Settling time: ~4 * lambda to reach 98% of setpoint
- Overshoot: Minimal for first-order systems
- Steady-state error: Zero (integral action eliminates offset)
Tips
- Start conservative: Use
lambda = tauinitially - Decrease lambda carefully: Smaller lambda = larger Kp = faster but riskier
- Watch for oscillation: If output oscillates, increase lambda
- Anti-windup: Prevent integral wind-up when output saturates
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.
