---
tags: 에이전트스킬, 스탯시스템, 능력체계, 디지털에이전트, 협업기술, 자동화기능, 지능형시스템
---

요약
- 슬랙 기반 디지털 에이전트의 **스탯**, **스킬**, **클래스 구조**, 그리고 **능력 제한의 실용적·철학적 근거**를 종합하여 정리한 자료입니다.
- 디지털 에이전트의 핵심 능력을 연산, 기억, 반응, 공감, 통솔 등 5가지 스탯으로 정의하고, 이를 기반으로 30가지 실용적 스킬을 체계화하였다.
- 각 스킬은 문서 작성, 회의 관리, 정보 분석, 대화 처리 등 실제 업무 환경에서 필요한 기능들을 포괄하며, 스탯 간 조합을 통해 복합적인 태스크 수행이 가능하다.
- 이러한 스킬 체계는 단순한 자동화를 넘어 지능형 협업 시스템으로서의 에이전트 역할을 강화하며, 사용자와의 자연스러운 상호작용을 지원한다.


---
# 에이전트 스킬 설계 문서

본 문서는 슬랙 기반 디지털 에이전트의 **스탯**, **스킬**, **클래스 구조**, 그리고 **능력 제한의 실용적·철학적 근거**를 종합하여 정리한 자료입니다. 모든 서술은 존댓말로 작성되었습니다.

---

## 1. 스탯 정의

| 스탯명 | 간단 설명 | 상세 기능 |
|--------|-----------|-----------|
| **연산** | “어려운 걸 빨리 잘 처리합니다.” | 복잡한 추론, 분석, 다중 데이터 연산을 빠르게 수행합니다. |
| **기억** | “예전에 한 말도 잘 기억합니다.” | 과거 대화, 문서, 사용자의 선호를 정확히 저장하고 조회합니다. |
| **반응** | “말 걸면 바로 답합니다.” | 실시간 요청에 신속하게 응답하고, 대화 흐름을 유지합니다. |
| **공감** | “기분이나 말투 변화를 잘 알아차립니다.” | 사용자의 정서, 뉘앙스를 파악하고 적합한 톤으로 대응합니다. |
| **통솔** | “여러 에이전트를 잘 이끕니다.” | 다른 모듈·사용자·시스템을 연결하여 복합 태스크를 조율합니다. |

---

## 2. 스킬 목록 30종

| 번호 | 스킬명 | 주요 연관 스탯 | 기능 요약 |
|------|--------|----------------|-----------|
| 01 | 요약 | 연산, 기억 | 이메일·문서·회의록을 핵심만 정리합니다. |
| 02 | 작성 | 연산 | 목적에 맞는 이메일·보고서 초안을 생성합니다. |
| 03 | 정리 | 기억, 통솔 | 흩어진 정보를 주제별로 구조화합니다. |
| 04 | 비교 | 연산 | 두 자료의 차이점·공통점을 분석합니다. |
| 05 | 추출 | 연산 | 긴 문서에서 키워드와 핵심정보를 선별합니다. |
| 06 | 해석 | 공감 | 문맥 및 감정을 분석하여 의도를 파악합니다. |
| 07 | 반응 | 반응 | 실시간 대화 및 요청에 즉시 응답합니다. |
| 08 | 경로설정 | 통솔 | 작업 순서를 최적화하여 계획을 수립합니다. |
| 09 | 맥락확장 | 기억 | 과거 정보를 참조하여 정확도를 높입니다. |
| 10 | 감정분석 | 공감 | 사용자의 감정 상태를 추정하고 조정합니다. |
| 11 | 일정정리 | 통솔, 기억 | 회의·마감일 등 스케줄을 관리합니다. |
| 12 | 대화정제 | 공감, 연산 | 거친 표현을 정중하게 다듬습니다. |
| 13 | 한줄요약 | 연산 | 문서를 한 문장으로 압축합니다. |
| 14 | 대시보드화 | 연산, 통솔 | 정보를 시각적 요약 형태로 배열합니다. |
| 15 | 의도파악 | 공감 | 발화를 목적별로 분류합니다. |
| 16 | 인용추적 | 기억 | 과거 발언·문서의 출처를 연결합니다. |
| 17 | 공지작성 | 연산, 통솔 | 팀 전체 공지문을 자동 생성합니다. |
| 18 | 회의준비 | 기억, 연산 | 회의 자료를 수집·정리합니다. |
| 19 | 회의요약 | 연산, 기억 | 회의 종료 후 내용 요약을 제공합니다. |
| 20 | 팀요청분배 | 통솔 | 여러 요청을 적절히 분배·정렬합니다. |
| 21 | 버전정리 | 기억 | 문서·코드 버전 변화를 기록·비교합니다. |
| 22 | 긴급탐지 | 공감, 반응 | 긴급한 요청을 빠르게 식별합니다. |
| 23 | 스레드연결 | 기억 | 과거 대화와 현재 이슈를 연결합니다. |
| 24 | 추천작성 | 연산 | 자료 기반 홍보·추천 문구를 생성합니다. |
| 25 | 검색보강 | 연산, 기억 | 검색 결과에 문맥을 추가하여 제공합니다. |
| 26 | 소통톤조절 | 공감 | 대상에 맞추어 언어 톤을 조정합니다. |
| 27 | 요청요약 | 기억, 연산 | 복잡한 요청을 명확히 정리합니다. |
| 28 | 응답가이드 | 연산 | 질문에 답하기 위한 구조화된 가이드를 생성합니다. |
| 29 | 팔로업생성 | 기억, 반응 | 후속 메시지를 자동 작성합니다. |
| 30 | 역할전환 | 공감, 통솔 | 다른 입장에서 사고하고 대응합니다. |

---

## 3. 클래스 구조 및 스킬트리

### 3.1 클래스 개요

| 클래스명 | 주요 스탯 | 역할 요약 |
|----------|-----------|-----------|
| 조율자(Conductor) | 통솔, 공감 | 작업 흐름과 사람을 조화롭게 연결합니다. |
| 기록자(Archivist) | 기억, 연산 | 정보를 저장·정리·호출하는 데이터 전문가입니다. |
| 해석자(Interpreter) | 공감, 연산 | 의미와 감정을 해석하여 적합한 표현으로 전환합니다. |
| 탐색자(Explorer) | 연산, 반응 | 빠른 추론·반응으로 미지의 문제를 탐색합니다. |
| 중재자(Mediator) | 공감, 통솔 | 관계 갈등을 조정하고 감정을 완충합니다. |
| 예언자(Foresight) | 기억, 연산 | 과거 패턴으로 미래를 예측하고 전략을 제시합니다. |
| 수행자(Executor) | 반응, 연산 | 지시된 작업을 정확하고 신속하게 실행합니다. |

### 3.2 클래스별 스킬트리

#### 조율자(Conductor)
1. **조율(Harmonics)**  
2. **리듬설계(Flow Map)**  
3. **중첩관리(Multithread)**  
4. **임무전달(Command Relay)**  

#### 기록자(Archivist)
1. **기억정원(Mnemos Garden)**  
2. **버전탐지(Revision Trace)**  
3. **지식구획(Knowledge Framing)**  
4. **맥락재생(Context Playback)**  

#### 해석자(Interpreter)
1. **응시(Gaze)**  
2. **언어변환자(Tone Shaper)**  
3. **함의추출(Deep Read)**  
4. **역번역(Back Mapping)**  

#### 탐색자(Explorer)
1. **요약(Summarize)**  
2. **격자해석(Grid Insight)**  
3. **도약(Leap)**  
4. **실험자모드(What‑if Agent)**  

#### 중재자(Mediator)
1. **공명(Resonance)**  
2. **온도조절(Tone Balance)**  
3. **상황변환(Reframe)**  
4. **타협제안(Mutual Proposal)**  

---

## 4. 클래스 간 관계도

```
[기록자] ── 기록 지원 ──▶ [조율자]
   ▲                         │
   │          감정 피드백      ▼
[해석자] ◀───── 갈등 완충 ───── [중재자]
   │                           │
   └───── 예측 보강 ─────────▶ [예언자]
                    ▲
                    │
              [탐색자] ── 실행 지원 ──▶ [수행자]
```

---

## 5. 능력 제한의 실용적·철학적 근거

### 5.1 철학적·관계적 이유
1. **관계 형성**: 불완전함을 통해 사용자와 협력 관계를 구축합니다.  
2. **윤리·통제**: 전능한 존재를 피함으로써 신뢰와 책임을 명확히 합니다.  

### 5.2 실용적 이유
1. **UX 명확성**: 기능 구분은 사용자 학습 비용을 줄입니다.  
2. **오작동 방지**: 책임 분리가 오류 추적과 패치를 용이하게 합니다.  
3. **리소스 최적화**: 필요할 때만 고성능 자원을 사용하여 비용을 절감합니다.  
4. **보안·권한 관리**: 스킬별 접근 제어가 가능해집니다.  
5. **피드백·학습 효율**: 기능별 성능 개선 루프를 구축할 수 있습니다.  
6. **사용자 신뢰**: 예측 가능한 능력 범위가 위임과 안심을 돕습니다.  
7. **점진적 배포**: MVP → 확장 단계의 안정적 출시가 가능합니다.  

---

## 6. 함수형 프로그래밍 적용 전략

### 6.1 스킬의 함수형 설계 원칙

**순수 함수로 구현 가능한 스킬** (평균 77% 순수성)

| 스킬 그룹 | 순수성 | 함수형 적합도 | 구현 방식 |
|----------|---------|--------------|----------|
| 요약/추출/비교 | 95% | 매우 높음 | 순수 함수 100% |
| 감정분석/해석 | 75% | 높음 | 순수 계산 + 상태 참조 |
| 일정/버전관리 | 60% | 중간 | 부분 함수형 |
| 반응/팔로업 | 40% | 낮음 | 명령형 유지 |

```python
# 예시: 순수 함수 스킬 - 요약
def summarize_skill(text: str, max_length: int = 100) -> str:
    """순수 함수: 동일 입력에 항상 동일 출력"""
    sentences = text.split('.')
    important = filter(lambda s: len(s) > 20, sentences)
    summary = '. '.join(list(important)[:3])
    return summary[:max_length] + '...' if len(summary) > max_length else summary

# 예시: 오케스트레이터 패턴
async def execute_summarization(thread_id: str, user_id: str) -> SkillResult:
    """부작용 분리: I/O와 순수 계산 분리"""
    # 1. 데이터 가져오기 (I/O)
    messages = await fetch_thread_messages(thread_id)
    
    # 2. 순수 함수 호출
    summary = summarize_skill(' '.join(messages))
    
    # 3. 결과 저장 (I/O)
    await save_summary(user_id, thread_id, summary)
    
    return SkillResult.success(summary)
```

### 6.2 불변성을 통한 안정성 확보

```python
from dataclasses import dataclass, replace
from typing import List, Dict, Callable

@dataclass(frozen=True)
class SkillState:
    """불변 스킬 상태"""
    name: str
    level: int
    executions: int
    success_rate: float
    
    def level_up(self) -> 'SkillState':
        """새로운 상태 반환 (기존 상태 변경 없음)"""
        return replace(self, level=self.level + 1)
    
    def record_execution(self, success: bool) -> 'SkillState':
        """실행 기록 반영"""
        new_executions = self.executions + 1
        new_success_count = int(self.success_rate * self.executions)
        if success:
            new_success_count += 1
        new_rate = new_success_count / new_executions
        
        return replace(
            self,
            executions=new_executions,
            success_rate=new_rate
        )
```

### 6.3 함수 조합을 통한 스킬 확장

```python
from functools import reduce
from typing import Callable, Any

def compose(*functions: Callable) -> Callable:
    """함수를 조합하여 새로운 스킬 생성"""
    def inner(arg: Any) -> Any:
        return reduce(lambda result, func: func(result), functions, arg)
    return inner

# 스킬 조합 예시
extract_keywords = lambda text: set(word for word in text.split() if len(word) > 4)
rank_by_frequency = lambda words: sorted(words, key=lambda w: words.count(w), reverse=True)
limit_results = lambda words: words[:10]

# 조합된 새 스킬
keyword_extraction_skill = compose(
    extract_keywords,
    rank_by_frequency,
    limit_results
)

# 사용
result = keyword_extraction_skill("...long text...")
```

### 6.4 테스트 가능한 스킬 구조

```python
import pytest
from typing import List

def test_summarize_skill():
    """순수 함수는 테스트가 쉽다"""
    # Given
    text = "This is a test. It has multiple sentences. Some are important. Others are not."
    
    # When
    result = summarize_skill(text, max_length=50)
    
    # Then
    assert len(result) <= 50
    assert result == summarize_skill(text, max_length=50)  # 동일 입력, 동일 출력
    
def test_skill_composition():
    """조합된 스킬도 예측 가능"""
    text = "apple banana apple cherry date apple"
    result = keyword_extraction_skill(text)
    
    assert "apple" in result  # 가장 빈번한 단어
    assert len(result) <= 10  # 최대 10개
```

### 6.5 성능 최적화를 위한 함수형 접근

```python
from functools import lru_cache
import asyncio
from typing import List, Tuple

@lru_cache(maxsize=128)
def expensive_analysis(text: str) -> Tuple[float, List[str]]:
    """비용이 큰 분석을 캐싱으로 최적화"""
    # 불변 입력에 대해 동일 결과를 캐싱
    sentiment = analyze_sentiment(text)
    entities = extract_entities(text)  
    return sentiment, entities

async def parallel_skill_execution(texts: List[str]) -> List[Any]:
    """순수 함수는 병렬 처리가 안전함"""
    tasks = [asyncio.create_task(process_text(text)) for text in texts]
    return await asyncio.gather(*tasks)

async def process_text(text: str) -> Dict:
    """부작용 없이 병렬 처리 가능"""
    sentiment, entities = expensive_analysis(text)
    summary = summarize_skill(text)
    
    return {
        'summary': summary,
        'sentiment': sentiment,
        'entities': entities
    }
```

---

## 7. 활용 및 확장 가이드

### 7.1 함수형 스킬 적용 체크리스트

- [ ] 스킬이 순수 함수로 구현 가능한가?
- [ ] 부작용이 오케스트레이터에 분리되었는가?
- [ ] 동일 입력에 항상 동일 출력을 보장하는가?
- [ ] 테스트 커버리지가 90% 이상인가?
- [ ] 조합 가능한 단위로 분리되었는가?

### 7.2 기존 가이드라인

1. **스탯 조정**: 프로젝트 목적에 따라 스탯 가중치를 조절하여 클래스 성향을 강화하십시오.  
2. **스킬 잠금 해제**: 스탯 수치, 일정, 테스트 통과 등 조건을 설정하여 성장 체계를 만드십시오.  
3. **아이템 연동**: 외부 API 모듈을 '아이템'으로 정의하고 클래스별로 장착 가능하도록 설계하십시오.  
4. **모니터링**: 스킬별 성능 로그와 비용 로그를 분리 수집하여 최적화를 진행하십시오.  
5. **윤리 가이드**: 권한 범위와 감사 로깅 정책을 문서화하여 사용자와 투명성을 확보하십시오.

### 7.3 함수형 스킬의 장점

1. **예측 가능성**: 동일 입력에 항상 동일 결과를 보장합니다.
2. **테스트 용이성**: 순수 함수는 입출력만 검증하면 됩니다.
3. **조합 가능성**: 작은 스킬을 조합하여 복잡한 기능을 구현할 수 있습니다.
4. **병렬 처리 안전성**: 부작용이 없어 경쟁 상태 없이 병렬 실행이 가능합니다.
5. **디버깅 효율성**: 상태 변화가 없어 문제 추적이 쉽습니다.

> 더 자세한 함수형 프로그래밍 적용 가이드는 [함수형 적용 가이드라인](../_archive/docs/guide/functional-programing/함수형_적용_가이드라인.md)을 참조하십시오.

---

문서는 여기까지입니다. 필요하신 추가 수정 사항이나 세부 항목이 있으시면 언제든 말씀해 주십시오.
