2nd/10_Wiki/Topics/AI_and_ML/Cognitive-Architecture.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-cognitive-architecture	Cognitive Architecture	10_Wiki/Topics	verified	self	SOAR ACT-R agent architecture neuro-symbolic agentic working memory declarative memory	none	B	0.85	applied	cognitive-architecture agent soar act-r neuro-symbolic agentic-workflow llm-agent working-memory		2026-05-10	pending	language framework agent design SOAR / ACT-R / LangGraph / OpenAI Agents SDK

Cognitive Architecture

매 한 줄

"매 intelligence 의 시스템 설계도". 매 perception + memory + reasoning + learning 의 cognitive loop. 매 classical: SOAR, ACT-R. 매 modern: LLM-based agentic (LangGraph, OpenAI Agents SDK, AutoGen). 매 neuro-symbolic 의 hybrid.

매 핵심

매 component (universal)

1. Perception: 매 input 의 representation.
2. Memory:
   • Working / short-term: 매 context.
   • Episodic / long-term: 매 experience.
   • Semantic: 매 concept.
   • Procedural: 매 skill.
3. Reasoning / Planning.
4. Action / Output.
5. Learning: 매 update.
6. Goal management.

Classical architecture

SOAR (Newell, 1980s)

• 매 production rule + 매 state-space search.
• 매 chunking 의 learning.
• 매 unified theory.

ACT-R (Anderson, 1990s)

• 매 declarative + procedural.
• 매 modular (visual, motor, goal, retrieval).
• 매 psychologically grounded.

CLARION

• 매 implicit + explicit.
• 매 dual-process (Kahneman).

LIDA

• 매 global workspace theory.

Modern (LLM-era)

ReAct (Reason + Act)

• 매 think → act → observe loop.
• 매 chain-of-thought + tool.

Plan-and-Execute

• 매 plan first, 매 execute step.
• 매 LangChain.

Reflection

• 매 self-critique.
• 매 Reflexion.

Multi-agent

• 매 specialized role.
• 매 AutoGen, CrewAI, MetaGPT.

Agentic memory

• 매 vector store (semantic).
• 매 episodic (recent + summary).
• 매 procedural (tool examples).

매 modern stack

• LangChain / LangGraph: 매 graph-based.
• OpenAI Agents SDK (2025): 매 first-party.
• AutoGen (Microsoft): 매 multi-agent.
• CrewAI: 매 role-based.
• DSPy: 매 declarative.
• PydanticAI: 매 typed.

Neuro-Symbolic

• 매 LLM (perception + language) + 매 symbolic (logic, math).
• 매 AlphaProof, 매 Wolfram Alpha + LLM.
• 매 hybrid 의 strength + interpretability.

매 응용

1. Personal assistant (Claude, ChatGPT).
2. Code agent (Cursor, Devin, Cline).
3. Research agent (Deep Research).
4. Robotics (RT-2).
5. Game NPC.
6. Customer service.

💻 패턴 (응용)

ReAct loop (LangChain)

from langchain.agents import create_react_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model='gpt-4o')

prompt = PromptTemplate.from_template("""You are a helpful agent. Solve the question.

Tools available:
{tools}

Use the format:
Thought: ...
Action: tool_name
Action Input: ...
Observation: ...
... (repeat)
Thought: I have the answer.
Final Answer: ...

Question: {input}
{agent_scratchpad}""")

agent = create_react_agent(llm, tools, prompt)
result = agent.invoke({'input': 'What is the GDP of Japan in 2024?'})

Plan-and-Execute (LangGraph)

from langgraph.graph import StateGraph
from typing import TypedDict, Annotated
import operator

class State(TypedDict):
    plan: list[str]
    past_steps: Annotated[list, operator.add]
    response: str

def planner(state):
    plan = llm.invoke(f'Plan steps for: {state["input"]}')
    return {'plan': parse_steps(plan)}

def executor(state):
    next_step = state['plan'][len(state['past_steps'])]
    result = execute_step(next_step)
    return {'past_steps': [(next_step, result)]}

def replan(state):
    if all_done(state):
        return {'response': summarize(state['past_steps'])}
    new_plan = llm.invoke(f'Replan based on: {state["past_steps"]}')
    return {'plan': new_plan}

graph = StateGraph(State)
graph.add_node('planner', planner)
graph.add_node('executor', executor)
graph.add_node('replan', replan)
graph.set_entry_point('planner')
graph.add_edge('planner', 'executor')
graph.add_edge('executor', 'replan')
graph.add_conditional_edges('replan', lambda s: 'executor' if not s.get('response') else 'END')

Reflexion (self-critique)

def reflexion_loop(task, max_iter=3):
    history = []
    for i in range(max_iter):
        attempt = llm.solve(task, history=history)
        result = evaluate(attempt)
        if result.passed:
            return attempt
        
        critique = llm.reflect(f"""Task: {task}
Attempt: {attempt}
Failure: {result.error}

Why did this fail? What should be done differently?""")
        history.append({'attempt': attempt, 'critique': critique})
    
    return attempt  # 매 best so far

Multi-agent (AutoGen-style)

from autogen import AssistantAgent, UserProxyAgent

planner = AssistantAgent('planner', system_message='You decompose tasks.')
coder = AssistantAgent('coder', system_message='You write Python.')
critic = AssistantAgent('critic', system_message='You review code.')
user = UserProxyAgent('user', code_execution_config={'work_dir': './sandbox'})

# 매 group chat
groupchat = GroupChat(agents=[user, planner, coder, critic], messages=[], max_round=10)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)
user.initiate_chat(manager, message='Build a web scraper for HN.')

Memory (vector + episodic)

from langchain.memory import VectorStoreRetrieverMemory
from langchain_community.vectorstores import Chroma

class HierarchicalMemory:
    def __init__(self):
        self.short_term = []  # 매 last 20 turns
        self.episodic = Chroma(...)  # 매 recent episodes
        self.semantic = Chroma(...)  # 매 facts about world
        self.procedural = []  # 매 tool examples
    
    def remember(self, event):
        self.short_term.append(event)
        if len(self.short_term) > 20:
            old = self.short_term.pop(0)
            self.episodic.add_texts([summarize(old)])
        
        if is_fact(event):
            self.semantic.add_texts([fact_extract(event)])
    
    def retrieve(self, query, k=5):
        return {
            'short_term': self.short_term,
            'episodic': self.episodic.similarity_search(query, k=k),
            'semantic': self.semantic.similarity_search(query, k=k),
        }

Working memory limit (Miller's 7±2)

class WorkingMemory:
    """매 limited capacity (LLM context budget)."""
    def __init__(self, max_tokens=8000):
        self.items = []
        self.max_tokens = max_tokens
    
    def add(self, item):
        self.items.append(item)
        while self.token_count() > self.max_tokens:
            # 매 oldest 의 summarize + drop
            old = self.items.pop(0)
            summary = summarize_briefly(old)
            self.items.insert(0, summary)

Goal management

class GoalStack:
    """매 hierarchical goals."""
    def __init__(self, top_goal):
        self.stack = [top_goal]
    
    def push_subgoal(self, subgoal):
        self.stack.append(subgoal)
    
    def pop_complete(self):
        if self.stack:
            done = self.stack.pop()
            return done
        return None
    
    def current(self):
        return self.stack[-1] if self.stack else None

Neuro-symbolic (LLM + Wolfram)

def neuro_symbolic_solve(question):
    # 매 LLM 의 understand + 매 formalize
    formal = llm.generate(f"""Convert to Wolfram Alpha query: {question}""")
    
    # 매 symbolic 의 compute
    result = wolfram.query(formal)
    
    # 매 LLM 의 explain
    return llm.generate(f"""Question: {question}
Wolfram result: {result}
Explain in plain language.""")

🤔 결정 기준

상황	Architecture
Single-step Q&A	LLM only
Tool-using	ReAct
Multi-step	Plan-and-execute
Self-improve	Reflexion
Specialist roles	Multi-agent (AutoGen)
Long-term context	Hierarchical memory
Math / proof	Neuro-symbolic
Robot	RT-2 / VLA

기본값: ReAct (single agent) + memory + tool. 매 complex = LangGraph / Plan-and-Execute.

🔗 Graph

• 부모: Agent-Architecture · AI
• Classical: SOAR · ACT-R
• Modern: ReAct · LangGraph · AutoGen · Reflexion
• 응용: Memory-Hierarchy · Working Memory
• Adjacent: Bayesian-Brain-Hypothesis · Biological-Intelligence · Neural-Symbolic-Integration · Multi-agent-System

🤖 LLM 활용

언제: 매 agent design. 매 long-running task. 매 multi-step. 매 tool-using. 매 robotics. 언제 X: 매 single-step Q&A. 매 stateless API.

❌ 안티패턴

• No memory: 매 stateless 의 multi-step fail.
• Unbounded loop: 매 budget exhausted.
• No reflection: 매 same error 의 repeat.
• Single agent for everything: 매 specialist 의 lose.
• Tool spam: 매 simple question 의 tool 의 over-call.
• Too many tool: 매 selection 의 confusion.
• Memory overflow: 매 context 의 unmanaged.

🧪 검증 / 중복

• Verified (Newell SOAR, Anderson ACT-R, Yao ReAct, Shinn Reflexion, AutoGen / LangGraph docs).
• 신뢰도 B.
• Related: Bayesian-Brain-Hypothesis · Biological-Intelligence · Neural-Symbolic-Integration · Multi-agent-System · Best-of-N_Sampling.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — classical + modern + 매 ReAct / LangGraph / multi-agent / memory code