📄 Cognitive Architectures for Language Agents (CoALA)

📋 메타 정보

항목	내용
제목	Cognitive Architectures for Language Agents
저자	Theodore R. Sumers*, Shunyu Yao*, Karthik Narasimhan, Thomas L. Griffiths (*동등 기여)
소속	Princeton University
발표처	Transactions on Machine Learning Research (TMLR)
발표 연도	2024년 2월 22일
arXiv	2309.02427
GitHub	awesome-language-agents

---

🎯 한줄 요약

인지 과학과 기호적 AI의 역사를 바탕으로, LLM 기반 언어 에이전트를 메모리, 액션 공간, 의사결정 프로세스의 세 축으로 체계화한 통합 프레임워크를 제안하여, 기존 에이전트들을 분류하고 언어 기반 범용 지능(Language-based General Intelligence)을 향한 미래 발전 방향을 제시한다.

---

🔍 연구 배경 및 동기

기존 문제점

1. 체계적 프레임워크 부재: LLM에 외부 리소스(인터넷, API 등)나 내부 제어 흐름(프롬프트 체이닝)을 결합한 “언어 에이전트”들이 등장했지만, 이들을 체계적으로 이해하고 비교할 프레임워크가 없었음
2. 용어 및 개념 불일치: 다양한 연구들이 서로 다른 용어와 접근법을 사용하여 연구자 간 소통이 어려움
3. 설계 원칙 부재: 새로운 에이전트를 개발할 때 참고할 수 있는 체계적인 설계 가이드라인이 없었음

인지 아키텍처의 필요성

• 인지 과학 연결: Soar, ACT-R 같은 고전적 인지 아키텍처의 수십 년 연구 성과를 현대 LLM 에이전트에 적용
• 통합적 관점: 개별 에이전트들의 공통점과 차이점을 명확히 파악할 수 있는 렌즈 제공
• Production System 재해석: LLM을 “확률적 생성 시스템(Probabilistic Production System)”으로 위치시켜 고전 AI와 연결
• 미래 방향 제시: 언어 기반 범용 지능(Language-based General Intelligence)을 향한 로드맵 수립

---

💡 핵심 아이디어

LLM을 “확률적 생성 시스템(Probabilistic Production System)”으로 바라보기

CoALA는 LLM을 고전적 생성 시스템(Production System)의 현대적 확장으로 해석한다:

고전적 생성 시스템: IF condition THEN action (규칙 기반 문자열 조작)
                     ↓
LLM 기반 시스템: 문자열 완성에 대한 확률 분포 정의 (학습된 패턴 기반)

Cognitive Architecture 프레임워크: 세 가지 핵심 차원

CoALA는 언어 에이전트를 세 가지 차원으로 조직화한다:

┌─────────────────────────────────────────────────────────────┐
│                    CoALA Framework                          │
├─────────────────┬─────────────────┬─────────────────────────┤
│     Memory      │   Action Space  │    Decision Making      │
│  (정보 저장)    │   (행동 공간)    │      (의사결정)         │
├─────────────────┼─────────────────┼─────────────────────────┤
│ • Working       │ • Internal      │ • Planning Stage        │
│ • Episodic      │   - Reasoning   │   (추론/검색으로 평가)  │
│ • Semantic      │   - Retrieval   │ • Execution Stage       │
│ • Procedural    │   - Learning    │   (선택된 행동 실행)    │
│                 │ • External      │                         │
│                 │   - Grounding   │                         │
└─────────────────┴─────────────────┴─────────────────────────┘

핵심 설계 원칙

1. 모듈화: 각 구성 요소가 독립적으로 설계/개선 가능
2. 유연성: LLM이 기존 hand-coded rule을 대체하여 유연한 추론 제공
3. 텍스트 중심: 텍스트를 사실상의 내부 표현(de facto representation)으로 사용
4. 순환 구조: 지속적인 인지-행동 루프를 통한 적응적 동작

---

🏗️ 프레임워크 구조

1. 메모리 시스템 (Memory System)

┌─────────────────────────────────────────────────────────────┐
│                      Memory System                           │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Working Memory (작업 메모리)              │   │
│  │  - 현재 의사결정 주기를 위한 활성 정보                    │   │
│  │  - 지각 입력, 활성 지식, 현재 목표                       │   │
│  │  - LLM, 장기 메모리, 환경 간 중앙 허브 역할               │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │            Long-term Memory (장기 메모리)              │   │
│  ├─────────────────────────────────────────────────────┤   │
│  │  Episodic Memory (일화 기억)                          │   │
│  │  - 과거 경험/이벤트 기록                               │   │
│  │  - 예: "지난번 해결책 X를 시도했을 때 무슨 일이?"         │   │
│  │  - 검색: recency + importance + relevance 점수 조합   │   │
│  ├─────────────────────────────────────────────────────┤   │
│  │  Semantic Memory (의미 기억)                          │   │
│  │  - 세계에 대한 사실적/일반화된 지식                     │   │
│  │  - 구현: 지식 베이스, 상징적 AI, 벡터 임베딩            │   │
│  │  - 예: "새는 날 수 있지만 타조는 예외"                   │   │
│  ├─────────────────────────────────────────────────────┤   │
│  │  Procedural Memory (절차 기억)                        │   │
│  │  - 작업 수행 방법 (코드, LLM 파라미터, 프롬프트에 내장)  │   │
│  │  - 에이전트의 실제 동작 방식을 규정                     │   │
│  │  - 예: Voyager의 코드 기반 스킬 라이브러리              │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

메모리 유형별 상세

메모리 유형	역할	구현 방법	예시
Working	현재 컨텍스트 유지	LLM 컨텍스트 윈도우	최근 대화, 부분 솔루션
Episodic	과거 경험 저장	벡터 DB + 시간 정보	Generative Agents의 이벤트 기억
Semantic	사실 지식 저장	지식 그래프, 벡터 임베딩	도메인 지식, 규칙
Procedural	실행 방법 저장	코드, 프롬프트, 모델 가중치	Voyager의 스킬 라이브러리

2. 행동 공간 (Action Space)

┌─────────────────────────────────────────────────────────────┐
│                      Action Space                            │
├────────────────────────┬────────────────────────────────────┤
│   Internal Actions     │      External Actions               │
│   (내부 행동)           │      (외부 행동 - Grounding)         │
├────────────────────────┼────────────────────────────────────┤
│                        │                                     │
│  ┌──────────────────┐  │  ┌────────────────────────────┐    │
│  │   Reasoning      │  │  │  Physical Environment      │    │
│  │   (추론)          │  │  │  - 로봇 제어, 물리적 상호작용  │    │
│  │   - LLM으로 작업  │  │  └────────────────────────────┘    │
│  │     메모리 갱신   │  │                                     │
│  │   - 새 지식/휴리  │  │  ┌────────────────────────────┐    │
│  │     스틱 생성     │  │  │  Digital Environment       │    │
│  └──────────────────┘  │  │  - API 호출, 웹 브라우징     │    │
│                        │  │  - 코드 실행, 파일 조작      │    │
│  ┌──────────────────┐  │  └────────────────────────────┘    │
│  │   Retrieval      │  │                                     │
│  │   (검색)          │  │  ┌────────────────────────────┐    │
│  │   - 장기 메모리   │  │  │  Communicative             │    │
│  │     에서 읽기     │  │  │  - 사용자/다른 에이전트와    │    │
│  │   - Rule/Sparse/ │  │  │    대화                     │    │
│  │     Dense 검색   │  │  └────────────────────────────┘    │
│  └──────────────────┘  │                                     │
│                        │                                     │
│  ┌──────────────────┐  │                                     │
│  │   Learning       │  │                                     │
│  │   (학습)          │  │                                     │
│  │   - 장기 메모리   │  │                                     │
│  │     에 쓰기       │  │                                     │
│  │   - 경험/지식/    │  │                                     │
│  │     스킬 저장     │  │                                     │
│  └──────────────────┘  │                                     │
└────────────────────────┴────────────────────────────────────┘

내부 행동 (Internal Actions) 상세

행동 유형	설명	메모리 접근	구현 예시
Reasoning	LLM으로 작업 메모리 업데이트, 새 지식/휴리스틱 생성	Write to Working	Chain-of-Thought, 상황 분석
Retrieval	장기 메모리에서 작업 메모리로 정보 읽기	Read from Long-term	Dense/Sparse/Rule 기반 검색
Learning	경험/지식/스킬을 장기 메모리에 기록	Write to Long-term	에피소드 저장, 스킬 라이브러리 업데이트

3. 의사결정 프로세스 (Decision Making)

┌─────────────────────────────────────────────────────────────┐
│                    Decision Cycle                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│    ┌──────────────┐                                         │
│    │  Perception  │ <- 환경으로부터 입력                       │
│    └──────┬───────┘                                         │
│           ↓                                                  │
│    ┌──────────────────────────────────────────────┐         │
│    │           PLANNING STAGE                      │         │
│    │  ┌─────────────────────────────────────────┐ │         │
│    │  │  1. Reasoning (추론)                     │ │         │
│    │  │     - 상황 분석                          │ │         │
│    │  │     - 행동 후보 생성 (Propose)           │ │         │
│    │  ├─────────────────────────────────────────┤ │         │
│    │  │  2. Retrieval (검색)                    │ │         │
│    │  │     - 관련 경험/지식/절차 검색           │ │         │
│    │  ├─────────────────────────────────────────┤ │         │
│    │  │  3. Evaluation & Selection (평가/선택)  │ │         │
│    │  │     - 행동 후보 평가 (Evaluate)          │ │         │
│    │  │     - 최적 행동 선택 (Select)            │ │         │
│    │  └─────────────────────────────────────────┘ │         │
│    └──────────────────┬───────────────────────────┘         │
│                       ↓                                      │
│    ┌──────────────────────────────────────────────┐         │
│    │           EXECUTION STAGE                     │         │
│    │  ┌───────────────────┬─────────────────────┐ │         │
│    │  │  Learning Action  │  Grounding Action   │ │         │
│    │  │  (장기 메모리 갱신) │  (외부 환경 상호작용) │ │         │
│    │  └───────────────────┴─────────────────────┘ │         │
│    └──────────────────┬───────────────────────────┘         │
│                       ↓                                      │
│              [다음 주기로 반복]                               │
└─────────────────────────────────────────────────────────────┘

의사결정 주기 의사코드

class CoALAAgent:
    def __init__(self):
        self.working_memory = WorkingMemory()
        self.episodic_memory = EpisodicMemory()
        self.semantic_memory = SemanticMemory()
        self.procedural_memory = ProceduralMemory()
        self.llm = LanguageModel()

    def decision_cycle(self):
        """메인 의사결정 루프 - 지속적으로 실행"""
        while True:
            # 1. 지각 입력 수신
            perception = self.receive_perception()
            self.working_memory.update(perception)

            # 2. Planning Stage (계획 단계)
            action = self.planning_stage()

            # 3. Execution Stage (실행 단계)
            self.execution_stage(action)

    def planning_stage(self):
        """계획 단계: 추론과 검색을 반복하며 행동 선택"""
        while not action_selected:
            # Reasoning: LLM으로 상황 분석 및 후보 생성
            analysis = self.reasoning_action(self.working_memory)

            # Retrieval: 관련 정보 장기 메모리에서 검색
            relevant_info = self.retrieval_action(analysis)
            self.working_memory.update(relevant_info)

            # 행동 후보 제안 및 평가/선택
            candidates = self.propose_actions(self.working_memory)
            action = self.evaluate_and_select(candidates)

        return action  # Learning 또는 Grounding 행동

    def execution_stage(self, action):
        """실행 단계: 선택된 행동 실행"""
        if action.type == "learning":
            self.update_long_term_memory(action)
        elif action.type == "grounding":
            result = self.execute_external_action(action)
            self.working_memory.update(result)

---

📊 에이전트 분류

CoALA 프레임워크로 분석한 기존 에이전트들

CoALA는 실험 논문이 아닌 프레임워크/서베이 논문으로, 기존 에이전트들을 체계적으로 분류하고 분석한다:

에이전트	Working Memory	Long-term Memory	주요 Action	특징
ReAct	LLM 컨텍스트	제한적	Reasoning + Grounding	Thought-Action 인터리빙
Toolformer	LLM 컨텍스트	–	Grounding (API 호출)	외부 도구 사용 능력 확장
AutoGPT/BabyAGI	벡터 스토어	Task List + Results	복잡한 태스크 루프	자율 에이전트 개념 증명
Voyager	LLM 컨텍스트	Procedural (스킬 라이브러리)	+ Procedural Learning	코드 기반 스킬 학습
Generative Agents	LLM 컨텍스트	Episodic + Semantic	4가지 모두	가장 완전한 메모리 시스템
Tree of Thoughts	LLM 컨텍스트	–	반복적 추론	트리 구조 의사결정
Reflexion	LLM 컨텍스트	Episodic + Semantic	+ Learning	자기 성찰 및 적응

에이전트별 CoALA 관점 심층 분석

ReAct

• Memory: Working memory만 사용 (LLM 컨텍스트 윈도우)
• Actions: 외부 도구(웹 검색, lookup) + LLM 기반 추론
• Decision: Thought-Action 인터리빙으로 추론과 행동의 시너지
• 한계: 장기 기억 부재로 경험 축적 불가

Voyager

• Memory: Procedural memory (코드 기반 스킬 라이브러리) 추가
• Actions: Dense retrieval로 스킬 검색 + Minecraft 환경 상호작용
• Learning: 새로운 스킬을 procedural memory에 저장
• 특징: CoALA에서 강조하는 절차적 학습의 고급 사례

Generative Agents

• Memory: Episodic + Semantic memory 모두 활용
• Retrieval: Recency(규칙 기반) + Importance(추론 기반) + Relevance(임베딩 기반) 점수 조합
• Learning: Episodic 추론을 통해 Semantic 지식 생성 (경험 -> 일반화)
• 특징: 가장 완전한 형태의 CoALA 메모리 시스템 구현

Action Space vs Decision Complexity 트레이드오프

Action Space 복잡도 ↑  ───►  Decision Procedure 복잡도 ↑
        │                           │
        │                           │
   Voyager,                    더 많은 hand-craft
   Generative Agents           커스터마이징 필요

핵심 통찰: 더 능력있는 에이전트(Voyager, Generative Agents)는 더 큰 행동 공간을 보유하지만, 이는 더 복잡한 의사결정 문제를 야기하여 더 맞춤화된 의사결정 절차가 필요하다.

---

💪 강점 및 기여

1. 이론적 기여

• 통합 프레임워크: 산발적이던 언어 에이전트 연구를 체계화
• 표준 용어 정립: 연구자 간 소통을 위한 공통 어휘 제공
• 역사적 연결: 고전적 인지 아키텍처(Soar, ACT-R)와 현대 LLM의 가교 역할
• 이론적 기반: LLM을 “확률적 생성 시스템”으로 위치시켜 학문적 맥락 제공

2. 실용적 기여

• 분석 도구: 기존 에이전트들의 장단점을 체계적으로 비교 가능
• 설계 가이드: 새로운 에이전트 개발 시 고려해야 할 차원들 명시화
• 갭 분석: 기존 연구에서 탐색되지 않은 영역 식별
• 청사진 제공: 어떤 컴포넌트가 필요하고 어떻게 상호작용해야 하는지 제시

3. 성능 향상 입증

• GPT-3.5 + Cognitive Architecture: 코딩 벤치마크에서 48% -> 95% 성능 향상
• 도구 사용 + Agentic Reflection 결합의 효과 입증

4. 학문적 영향

• 다수의 후속 연구에 영향
• awesome-language-agents 저장소: 지속적으로 업데이트되는 관련 연구 목록 유지

---

⚠️ 한계점 및 향후 연구

프레임워크의 한계

1. 개념적 프레임워크의 한계
   • 직접적인 성능 벤치마크나 실험 결과 제공하지 않음
   • 구체적인 구현 가이드라인보다는 개념적 조직화에 초점
   • 단순함이 강점이자 한계 – 세부 구현 가이드 부족
2. 메모리 구현의 도전
   • 효율적인 장기 메모리 검색/쓰기 메커니즘 미해결
   • 대규모 메모리 관리 문제

미래 연구 방향

1. Working Memory & Reasoning 고도화

• 단순한 프롬프트 엔지니어링을 넘어서는 “진정한 사고” 메커니즘 탐구
• 저수준 문자열 조작이 아닌 고수준 인지 설계

2. 에이전트 안전성 (Agent Safety)

• 내부적 위험: Learning 행동(특히 절차 삭제/수정)이 야기할 수 있는 문제
• 외부적 위험: Grounding 행동(bash의 rm, 유해 발언, 물리적 위험)의 위험성
• 행동 공간 관점에서의 안전성 분석 필요

3. Reinforcement Learning 통합

• 경험 기반 의사결정 정책 최적화
• End-to-end 또는 co-adapted 학습

4. 통합 학습 (Unified Learning)

• Memory, Action Selection, Skill Acquisition의 통합 학습
• 사전 훈련된 LLM 능력에만 의존하지 않는 아키텍처

5. Symbolic-LLM 결합

• 상징적 추론 컴포넌트와 LLM의 최적 조합 탐구
• 양 패러다임의 장점 활용

6. Meta-learning & Value Alignment

• 에이전트 코드 자체의 메타 학습
• 인간 가치와의 정렬 (Alignment)

# 미래 방향: 자기 코드를 수정하는 에이전트
def meta_learning(self):
    # 경험 분석
    performance = self.analyze_performance()
    # 코드 개선안 생성
    code_improvement = self.llm.generate_code_improvement(performance)
    # 자기 코드 수정
    self.update_agent_code(code_improvement)

---

🔗 관련 논문

선행 연구 (Foundational Works)

논문	연도	관련성
Soar: An Architecture for General Intelligence	1987	CoALA의 주요 영감 원천, 메모리 구조
ACT-R: A Theory of Higher Level Cognition	1998	인지 아키텍처 기반
ReAct: Synergizing Reasoning and Acting in Language Models	2022	분석 대상 에이전트
Toolformer: Language Models Can Teach Themselves to Use Tools	2023	도구 사용 능력 확장
Reflexion: Language Agents with Verbal Reinforcement Learning	2023	자기 성찰 메커니즘
Voyager: An Open-Ended Embodied Agent	2023	Procedural Memory 사례
Generative Agents: Interactive Simulacra of Human Behavior	2023	완전한 메모리 시스템
Tree of Thoughts: Deliberate Problem Solving with Large Language Models	2023	의사결정 구조

후속 연구 (2024-2025)

논문	연도	내용
Self-Contrast: Better Reflection Through Inconsistent Solving Perspectives	2024-01	반성 메커니즘 개선
Agent-Pro: Learning to Evolve via Policy-Level Reflection	2024-02	정책 수준 학습
AppWorld: Benchmarking Interactive Coding Agents	2024-07	에이전트 벤치마크
Uncertainty-Aware Language Agent (UALA)	2024 (ACL)	불확실성 기반 에이전트
A Survey on Large Language Model based Autonomous Agents	2023-2024	종합 서베이

---

💻 실무 적용 포인트

1. 에이전트 설계 체크리스트

## CoALA 기반 에이전트 설계 체크리스트

### 메모리 설계
- [ ] Working Memory: 현재 컨텍스트 관리 방법 정의
- [ ] Episodic Memory: 과거 경험 저장 필요 여부
- [ ] Semantic Memory: 외부 지식 베이스 연동 필요 여부
- [ ] Procedural Memory: 스킬/코드 라이브러리 필요 여부

### 액션 공간 설계
- [ ] 내부 행동: 추론/검색/학습 중 필요한 것
- [ ] 외부 행동: 어떤 환경과 상호작용하는지 (물리/디지털/대화)
- [ ] 행동 공간 크기 vs 의사결정 복잡도 트레이드오프 고려

### 의사결정 설계
- [ ] 계획 단계의 복잡도 결정 (단순 vs 반복적 평가)
- [ ] 행동 선택 전략 정의

### 안전성 설계
- [ ] Learning 행동의 내부 위험 분석
- [ ] Grounding 행동의 외부 위험 분석

2. LangChain 기반 구현 예시

from langchain.agents import AgentExecutor
from langchain.memory import ConversationBufferMemory, VectorStoreRetrieverMemory
from langchain_openai import ChatOpenAI

class CoALAInspiredAgent:
    """CoALA 원칙을 반영한 에이전트 구조"""

    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4")

        # Working Memory: 대화 버퍼
        self.working_memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )

        # Semantic Memory: 벡터 스토어 기반
        self.semantic_memory = VectorStoreRetrieverMemory(
            retriever=self.setup_retriever()
        )

        # Episodic Memory: 경험 저장소
        self.episodic_memory = []

        # Procedural Memory: 스킬 라이브러리
        self.procedural_memory = self.load_skills()

    def planning_stage(self, user_input):
        """계획 단계: 추론과 검색"""
        # 1. Retrieval - 관련 정보 검색
        relevant_knowledge = self.semantic_memory.load_memory_variables(
            {"query": user_input}
        )
        relevant_experiences = self.retrieve_episodes(user_input)

        # 2. Reasoning - 상황 분석 및 행동 계획
        context = self.build_context(
            user_input,
            relevant_knowledge,
            relevant_experiences
        )
        action_plan = self.llm.invoke(context)

        return action_plan

    def execution_stage(self, action_plan):
        """실행 단계: 학습 또는 그라운딩"""
        if action_plan.requires_external_action:
            # Grounding: 외부 도구 실행
            result = self.execute_tool(action_plan.tool, action_plan.args)
        else:
            # Learning: 메모리 업데이트
            self.update_memories(action_plan)
            result = action_plan.response

        # 경험 기록 (Episodic Learning)
        self.episodic_memory.append({
            "input": action_plan.input,
            "action": action_plan.action,
            "result": result
        })

        return result

3. 주요 설계 고려사항

고려사항	권장 사항
메모리 선택	작업 특성에 따라 필요한 메모리 유형만 구현 (복잡도 관리)
행동 공간 크기	행동 공간이 클수록 의사결정이 복잡해짐 – 트레이드오프 고려
의사결정 루프	메인 로직은 한 곳에 집중, 모듈화 유지
학습 전략	단순: In-context -> 중간: RAG -> 고급: 파인튜닝/코드 수정
검색 방식	Rule-based vs Sparse vs Dense – 상황에 맞게 조합

4. 안전성 체크포인트

def safety_check(action):
    """CoALA 안전성 관점의 행동 검사"""

    # 내부 위험: Learning 행동 검사
    if action.type == "learning":
        if action.target == "procedural_memory":
            if action.operation in ["delete", "modify"]:
                return require_confirmation(
                    "절차 메모리 수정은 에이전트 행동에 영향을 줄 수 있습니다."
                )

    # 외부 위험: Grounding 행동 검사
    if action.type == "grounding":
        dangerous_commands = ["rm", "delete", "format", "sudo"]
        if any(cmd in action.command for cmd in dangerous_commands):
            return require_confirmation(
                f"위험한 명령어 감지: {action.command}"
            )

    return True

---

🏷️ Tags

#AIAgent #CognitiveArchitecture #LLM #LanguageAgent #CoALA #Memory #ReAct #Voyager #GenerativeAgents #Reflexion #DecisionMaking #Princeton #TMLR #2024 #Framework #Survey #Soar #ACTR #ProductionSystem #ProceduralMemory #EpisodicMemory #SemanticMemory #WorkingMemory #AgentSafety #MetaLearning #Toolformer #TreeOfThoughts #Grounding #Reasoning #Retrieval #Learning

---

📚 참고 자료

• 논문 원문: arXiv:2309.02427
• GitHub 저장소: awesome-language-agents
• OpenReview: TMLR 리뷰
• Princeton 연구 페이지: Princeton Research