2nd/10_Wiki/Topics/Domain_Programming/AI_and_ML/Synergy.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-synergy	Synergy	10_Wiki/Topics	verified	self	시너지 Combined Effect Emergent Effect	none	A	0.85	applied	systems-theory business military emergence combined-arms		2026-05-10	pending	language framework conceptual systems-thinking

Synergy

매 한 줄

"매 synergy 는 1+1 > 2 — components 의 combined effect 의 sum 보다 큰 case". 매 systems theory (Aristotle "whole > sum"), business strategy (M&A), military combined arms 의 cross-cutting concept. 매 2026 software 의 microservice composition, AI ensemble, multi-agent coordination 의 substrate.

매 핵심

매 origin

• Aristotle: "The whole is greater than the sum of its parts" (Metaphysics).
• Buckminster Fuller: synergetics — "behavior of whole systems unpredicted by parts."
• Ansoff (1965): business synergy framework — 2+2=5 effect.
• Combined Arms (military): infantry + armor + air → mutual reinforcement.

매 types

• Cost synergy: shared infra → unit cost ↓ (M&A justification).
• Revenue synergy: cross-sell, bundle.
• Operational synergy: shared process / tech stack.
• Negative synergy (anti-synergy): cultural clash, overhead → 1+1 < 2.

매 mechanism

• Complementarity: 각 part 의 strength 가 다른 part 의 weakness 의 cover.
• Resource sharing: fixed cost amortization.
• Network effect: connection 자체 의 value 의 source.
• Information sharing: 매 knowledge transfer 의 multiplier.

매 software/AI 응용

• Multi-agent system: planner + executor + verifier 의 division of labor.
• Ensemble learning: weak learners 의 combine → strong (boosting, stacking).
• Tool-using LLM: LLM + Python + search + KG → 매 individually 의 weak combinations 의 strong system.
• Microservice composition: bounded context 의 individual deploy + integration synergy.

매 응용

1. AI ensemble: 모델 vote / stack — single 보다 +5-10% accuracy.
2. Multi-agent (Claude + tools): 매 hallucination ↓ via verifier.
3. M&A integration: 매 due diligence 의 synergy hypothesis 의 validation.

💻 패턴

1. Ensemble (stacking)

from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from xgboost import XGBClassifier
from sklearn.svm import SVC

base = [
    ("xgb", XGBClassifier(n_estimators=300)),
    ("svm", SVC(probability=True)),
    ("lr", LogisticRegression(max_iter=1000)),
]

# meta-learner combines base predictions — synergy
stack = StackingClassifier(estimators=base, final_estimator=LogisticRegression())
stack.fit(X_train, y_train)

2. LLM + tools (synergy)

import anthropic
client = anthropic.Anthropic()

tools = [
    {"name": "python", "description": "execute Python", ...},
    {"name": "web_search", "description": "search web", ...},
    {"name": "knowledge_graph", "description": "query KG", ...},
]

# LLM strength: language understanding + planning
# Tool strength: ground truth (math, fresh info, structured)
# Synergy: better than either alone
resp = client.messages.create(
    model="claude-opus-4-7", tools=tools,
    messages=[{"role": "user", "content": "Compare GPU prices today and compute 10-year ROI."}]
)

3. Multi-agent (planner + executor + critic)

def multi_agent_solve(task):
    plan = planner_llm(task)               # decomposition synergy
    drafts = [executor_llm(step) for step in plan]
    critique = critic_llm(plan, drafts)    # verification synergy
    if critique.has_issues:
        return multi_agent_solve(task + critique.feedback)  # loop
    return drafts

4. Microservice composition

# Each service independently deployable; orchestration creates synergy
services:
  user-service:    { db: postgres-users,    bounded_context: identity }
  order-service:   { db: postgres-orders,   bounded_context: commerce }
  payment-service: { db: postgres-payments, bounded_context: finance  }
  notify-service:  { queue: kafka,          bounded_context: comms    }

# Saga orchestration: each independent, combined → checkout flow

5. Combined arms (game/sim)

class Squad:
    def __init__(self):
        self.tank = Tank()      # absorb damage
        self.infantry = Infantry()  # capture
        self.medic = Medic()    # sustain
        self.recon = Recon()    # vision

    def effectiveness(self):
        # Multiplicative synergy, not additive
        base = sum(u.power for u in [self.tank, self.infantry, self.medic, self.recon])
        synergy_bonus = 0.4 if self.has_all_roles() else 0
        return base * (1 + synergy_bonus)

6. Synergy measurement

def synergy_score(parts_individual, combined):
    """Synergy index: > 1 means positive, < 1 negative."""
    return combined / sum(parts_individual)

매 결정 기준

상황	Approach
Heterogeneous models	Stacking ensemble
Reasoning + ground truth	LLM + tool synergy
Complex pipeline	Multi-agent (specialized roles)
Negative synergy risk	Decompose / decouple
Single dominant component	매 synergy 의 forced 의 X — pick winner

기본값: heterogeneity 의 source 의 high 일 때만 synergy 의 pursue.

🔗 Graph

• 부모: System-Theory · Emergence
• 변형: Combined Arms (제병협동) 전술 · Ensemble-Learning · Multi-Agent-System
• Adjacent: Network-Effect · Support Insulated

🤖 LLM 활용

언제: synergy hypothesis ideation, architecture review (synergy/anti-synergy 식별). 언제 X: synergy quantification (require domain measurement, LLM 의 estimate 의 unreliable).

❌ 안티패턴

• Synergy 의 assume without measurement: 매 M&A 의 typical failure.
• Forced ensemble of similar models: 매 correlated → no gain. heterogeneity 의 critical.
• Multi-agent 의 every task: 매 simple task 의 single LLM 으로 충분 — overhead 의 큰.
• Microservice 의 over-decompose: 매 distributed monolith — anti-synergy.

🧪 검증 / 중복

• Verified (Aristotle Metaphysics, Ansoff "Corporate Strategy" 1965, Wolpert "No Free Lunch", Brown 2024 multi-agent debate paper).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — synergy (systems theory + business + AI ensemble + multi-agent)