---
id: wiki-2026-0508-feedback-loops-in-systems
title: Feedback Loops in Systems
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Feedback Loop, Closed-Loop, Reinforcing Loop, Balancing Loop]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [systems-thinking, control, dynamics, cybernetics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Python
  framework: scipy.signal, simpy, control
---

# Feedback Loops in Systems

## 매 한 줄
> **"매 output 의 portion 의 input 으로 routed back — 매 system 의 self-regulation / self-amplification 의 fundamental mechanism"**. Wiener 의 cybernetics (1948) → Forrester 의 system dynamics (1961) → Meadows 의 *Thinking in Systems* (2008) → 매 SRE / RL / market-design 까지 매 universal.

## 매 핵심

### 매 두 polarity
- **Reinforcing (R, +)**: 매 same-direction amplification → 매 exponential growth or collapse. 매 viral growth, bank runs, flywheel.
- **Balancing (B, −)**: 매 opposite-direction correction → 매 goal-seeking equilibrium. 매 thermostat, autoscaler, supply-demand.
- 매 system 의 behavior = sum of all loops, with delays.

### 매 4 building blocks (Meadows)
1. **Stocks** (state, accumulator).
2. **Flows** (rate of change).
3. **Information links** (signals).
4. **Delays** (transport, perception, action).

### 매 typical archetypes
- **Limits to growth**: R + B (resource constraint).
- **Shifting the burden**: short-term fix B undermines long-term solution.
- **Tragedy of the commons**: many R + 1 B.
- **Success to the successful**: 2 R coupled.
- **Drift to low performance**: B with eroding goals.
- **Escalation**: 2 R + delay (arms race).

### 매 stability
- 매 negative loop 의 gain > 1 + delay → 매 oscillation, overshoot.
- 매 positive loop 의 unchecked → 매 runaway / collapse.
- 매 Bode / Nyquist 의 control-theory 의 quantitative tool.

## 💻 패턴

### Thermostat (B loop, ODE)
```python
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

setpoint, k_loss, k_heat = 22.0, 0.1, 0.5
def dT(T, t):
    heat = k_heat if T < setpoint else 0
    return -k_loss*(T-10) + heat
t = np.linspace(0, 100, 1000)
T = odeint(dT, 15, t)
plt.plot(t, T); plt.axhline(setpoint, ls="--")
```

### PID controller (B with derivative damping)
```python
class PID:
    def __init__(self, kp, ki, kd, dt):
        self.kp,self.ki,self.kd,self.dt = kp,ki,kd,dt
        self.i, self.prev = 0, 0
    def __call__(self, sp, pv):
        e = sp - pv
        self.i += e*self.dt
        d = (e - self.prev)/self.dt
        self.prev = e
        return self.kp*e + self.ki*self.i + self.kd*d
```

### Reinforcing loop — viral growth
```python
def viral(t_max=30, k=0.2, init=10, cap=1e6):
    n=[init]
    for _ in range(t_max):
        n.append(min(cap, n[-1]*(1+k)))   # R loop
    return n
# 매 limits-to-growth 의 cap 의 추가 — pure exponential 의 unrealistic.
```

### Logistic — R + B (limits to growth)
```python
def logistic(K=1e6, r=0.3, t_max=60, init=10):
    x=[init]
    for _ in range(t_max):
        x.append(x[-1] + r*x[-1]*(1-x[-1]/K))
    return x
```

### Stock-and-flow (Forrester) with simpy
```python
import simpy, random
env = simpy.Environment()
inventory = simpy.Container(env, init=100, capacity=1000)
def supplier(env):
    while True:
        yield env.timeout(2)
        if inventory.level < 50:               # B loop on stock
            yield inventory.put(60)
def customer(env):
    while True:
        yield env.timeout(random.expovariate(1))
        yield inventory.get(1)
env.process(supplier(env)); [env.process(customer(env)) for _ in range(5)]
env.run(until=100)
```

### Autoscaler (SRE B loop)
```python
def autoscaler(metric, target=0.6, replicas=3, max_r=20):
    err = metric - target
    delta = round(err * replicas / target)
    return max(1, min(max_r, replicas + delta))
```

### Causal-loop diagram (text DSL)
```
Users ─R→ Content ─R→ Engagement ─R→ Users      (viral R)
Users ─B→ Server-load ─B→ Latency ─B→ Users     (capacity B)
delay: server provisioning ≈ 10 min  → oscillation risk.
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Continuous physical / control | **PID / state-space** |
| Discrete event business / supply chain | **System Dynamics (stocks-flows)** |
| Service capacity | **B loop autoscaler + SLO error budget** |
| Growth product strategy | **Map R loops; identify limit B; remove constraint** |
| Policy / market | **Causal-loop diagram + agent-based sim** |
| Stability analysis | **Linearize → Bode / root-locus** |

**기본값**: 매 design 의 첫 단계 = **CLD (Causal Loop Diagram)** + delay 표시 + leverage point 식별.

## 🔗 Graph
- 부모: [[Systems_Thinking|Systems-Thinking]] · [[Cybernetics Foundations|Cybernetics]] · [[Control-Theory]]
- 변형: [[Reinforcing-Loop]] · [[Balancing-Loop]]
- 응용: [[Feedback-Control-Systems]] · [[Reinforcement-Learning]]

## 🤖 LLM 활용
**언제**: 매 unintended consequence 의 prediction, 매 product growth 의 root-cause, 매 SRE incident 의 cascading 분석, 매 policy design 의 leverage point.
**언제 X**: 매 fully open-loop 의 simple pipeline (매 unnecessary modeling).

## ❌ 안티패턴
- **Loops without delay**: 매 real systems 의 always have delays — 매 oscillation 의 missed.
- **Linear thinking in nonlinear loop**: 매 small input change 의 huge output (or vice versa).
- **Optimizing one node**: 매 ignoring loop → 매 Goodhart, perverse incentives.
- **Goal erosion**: 매 missed-target → 매 lower target → 매 drift.
- **Fixing symptom (B)**: 매 underlying R loop 의 unaddressed (shifting the burden).

## 🧪 검증 / 중복
- Verified (Wiener 1948; Forrester 1961; Senge 1990; Meadows 2008; *Designing Data-Intensive Apps* on backpressure).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 placeholder |
| 2026-05-10 | Manual cleanup — archetypes + 7 patterns + decision matrix |
