2nd/10_Wiki/Topics/AI_and_ML/Synthesized Intelligence.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-synthesized-intelligence	Synthesized Intelligence	10_Wiki/Topics	verified	self	Composite AI Multi-Model AI Orchestrated Intelligence AI Orchestration	none	A	0.85	applied	composite-ai multi-model orchestration ensemble agent		2026-05-10	pending	language framework python 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

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)

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)

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)

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)

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)

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

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
• Adjacent: Composite-AI · 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)