SkillAgentSearch skills...

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-rules

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

82/100

Supported Platforms

Universal

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.

Substance
26/30
Structure
20/20
Description
12/15
Adoption
14/20
Freshness
11/15

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 found

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.

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.

SkillScoreStarsUpdatedFormat
imc-tuning-rules (this skill)by benchflow-ai821.8k4mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP 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.

name: 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 gain
  • Ki = 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

  1. Start conservative: Use lambda = tau initially
  2. Decrease lambda carefully: Smaller lambda = larger Kp = faster but riskier
  3. Watch for oscillation: If output oscillates, increase lambda
  4. Anti-windup: Prevent integral wind-up when output saturates

Related Skills

View on GitHub
GitHub Stars1.8k
CategoryDevelopment
Updated3mo ago
Forks368

Languages

PDDL

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info