---
id: wiki-2026-0508-synthesized-intelligence
title: Synthesized Intelligence
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Composite AI, Multi-Model AI, Orchestrated Intelligence, AI Orchestration]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [composite-ai, multi-model, orchestration, ensemble, agent]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: python
  framework: anthropic-sdk
---

# Synthesized Intelligence

## 매 한 줄
> **"매 synthesized intelligence 는 multiple AI components 의 orchestrate 하여 단일 model 보다 강한 system 의 build"**. 매 Gartner "composite AI" trend 의 evolution. 매 2026 production AI 의 default architecture: LLM router → specialist (vision/code/math) + symbolic verifier + memory + tools.

## 매 핵심

### 매 components (typical 2026 stack)
- **Router/Planner LLM**: Opus 4.7 / GPT-5 — 매 task decomposition + dispatch.
- **Specialist models**: vision (Claude vision), code (DeepSeek Coder, Codestral), math (Lean+LLM), audio (Whisper v3).
- **Symbolic engines**: Z3, SymPy, Lean, Wolfram.
- **Retrieval**: vector DB (Qdrant) + graph (Neo4j) → GraphRAG.
- **Memory**: episodic (vector) + semantic (KG) + working (context window).
- **Verifier**: smaller LLM critic / symbolic check / test execution.

### 매 orchestration patterns
- **Pipeline**: linear flow (parse → retrieve → generate → verify).
- **Router**: classify → dispatch to specialist.
- **Map-reduce**: parallel fan-out + aggregate.
- **Debate**: 2-N agents argue, judge aggregates.
- **Reflection**: self-critique loop.
- **Tool-augmented loop**: ReAct / function-calling.

### 매 vs single-model
- **Pros**: specialization gain, verifier-grounded, modular swap, cost optimization (route cheap tasks to small model).
- **Cons**: latency (multi-hop), error compounding, orchestration complexity, debugging difficulty.

### 매 응용
1. **Coding agent**: planner (Opus) + code (Haiku/Codestral) + test runner + linter.
2. **Research agent**: search + reader + summarizer + critic.
3. **Customer support**: intent classifier → KB retrieval → response → safety filter.

## 💻 패턴

### 1. Router pattern
```python
import anthropic
client = anthropic.Anthropic()

def route(query):
    classifier = client.messages.create(
        model="claude-haiku-4-7",  # cheap router
        max_tokens=10,
        messages=[{"role": "user", "content":
            f"Classify (math/code/general): {query}\nOutput one word."}]
    ).content[0].text.strip().lower()

    return {
        "math":    "claude-opus-4-7",     # heavy math
        "code":    "claude-sonnet-4-7",   # mid code
        "general": "claude-haiku-4-7",    # cheap general
    }.get(classifier, "claude-sonnet-4-7")

def answer(query):
    model = route(query)
    return client.messages.create(model=model, max_tokens=1000,
        messages=[{"role": "user", "content": query}])
```

### 2. Pipeline (parse → retrieve → answer → verify)
```python
def pipeline(query):
    parsed = parser_llm(query)              # extract entities/intent
    docs = retriever(parsed.entities)       # vector + KG
    draft = answerer_llm(query, context=docs)
    verdict = verifier_llm(query, draft, docs)
    if not verdict.ok:
        return pipeline(query + f"\n[Hint: {verdict.feedback}]")
    return draft
```

### 3. Debate pattern (multi-agent)
```python
def debate(question, rounds=3, n_agents=3):
    answers = [llm(question, persona=f"agent_{i}") for i in range(n_agents)]
    for _ in range(rounds):
        new = []
        for i, a in enumerate(answers):
            others = [x for j, x in enumerate(answers) if j != i]
            new.append(llm(question + f"\nOther answers: {others}\nRevise:"))
        answers = new
    return judge_llm(question, answers)
```

### 4. Tool-augmented (ReAct)
```python
TOOLS = {"python": run_python, "search": web_search, "lean": prove_lean}

def react_loop(task, max_steps=10):
    history = []
    for _ in range(max_steps):
        thought = llm(task, history=history,
            instruction="Think step. If tool needed output Action: tool(arg). Else Final: ...")
        if thought.startswith("Final:"):
            return thought[6:]
        tool, arg = parse_action(thought)
        observation = TOOLS[tool](arg)
        history.append((thought, observation))
    return "max steps"
```

### 5. Reflection (self-critique loop)
```python
def reflect(task, max_iter=3):
    draft = llm(task)
    for _ in range(max_iter):
        critique = llm(f"Critique this answer to '{task}':\n{draft}")
        if "no issues" in critique.lower():
            break
        draft = llm(f"Revise based on critique:\nOriginal: {draft}\nCritique: {critique}")
    return draft
```

### 6. Specialist dispatch (code agent)
```python
def code_agent(task):
    plan = planner_opus(task)
    files = []
    for step in plan.steps:
        code = coder_codestral(step)        # cheap specialist
        if step.needs_test:
            test_result = runner(code)
            if not test_result.passed:
                code = fixer_opus(code, test_result.error)  # heavy fix
        files.append(code)
    return integrate(files)
```

### 7. Cost-aware routing
```python
def smart_route(query, budget):
    """Route to smallest model that meets quality bar."""
    candidates = [("haiku", 0.001), ("sonnet", 0.01), ("opus", 0.05)]
    for model, cost in candidates:
        if cost > budget: continue
        ans = call(model, query)
        if confidence(ans) > 0.85:
            return ans
    return call("opus", query)  # fallback
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Mixed task types | Router |
| Complex multi-step | Pipeline + verifier |
| High-stakes correctness | Debate / reflection |
| Need ground truth | Tool-augmented (ReAct) |
| Cost-sensitive | Cost-aware routing |
| Single domain | Single model — synthesis 의 overkill |

**기본값**: Router + tool-augmented loop + cheap verifier.

## 🔗 Graph
- 부모: [[Multi-Agent-System]] · [[AI-Orchestration]]
- 변형: [[ReAct]] · [[Reflection-Pattern]] · [[Multi-Agent-Debate]]
- 응용: [[Coding-Agent]] · [[Research-Agent]]
- Adjacent: [[Composite-AI]] · [[Tool-Using-LLM]] · [[Synergy]]

## 🤖 LLM 활용
**언제**: 매 architecture 의 itself — synthesized intelligence 의 LLM 의 substrate.
**언제 X**: simple deterministic task — 매 single function call 으로 충분.

## ❌ 안티패턴
- **Over-orchestration**: 매 simple Q 의 5-hop pipeline → latency·cost 폭발.
- **Verifier 의 stronger 의 main**: 매 logical paradox — verifier 의 생산 weaker checker.
- **Single-model task 의 multi-agent 의 force**: 매 cost ↑, gain 의 minimal.
- **No fallback path**: 매 specialist down → total failure.
- **Latency budget 무시**: 매 user-facing 의 multi-hop 의 deadly.

## 🧪 검증 / 중복
- Verified (Gartner Composite AI 2024, Anthropic Constitutional AI, Yao et al. ReAct 2022, Du et al. multi-agent debate 2023).
- 신뢰도 A-.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — synthesized intelligence (composite AI orchestration patterns) |
