에이전트 발전사 기호주의에서 LLM까지

AI 에이전트의 기원부터 LLM 기반 에이전트까지 발전 과정을 이북 스타일로 살펴봅니다. 초보 개발자도 쉽게 이해할 수 있도록 비유와 스토리텔링으로 풀어냅니다.

1. 초기 AI와 기호주의 접근법

어느 날 김개발 씨가 회사 사내 스터디에서 AI의 역사에 대해 발표하게 되었습니다. "AI는 그냥 최근에 뜬 거 아닌가요?"라는 질문에 정확한 답을 하지 못했던 김개발 씨, 오늘은 제대로 준비해 보려고 합니다.

**기호주의(Symbolic AI)**는 인간의 사고를 기호와 규칙으로 표현하려는 초기 AI 접근법입니다. 마치 수학 공식을 풀듯, 정해진 규칙에 따라 기호를 조작하여 문제를 해결합니다.

현대 AI의 뿌리를 이해하는 데 필수적인 개념입니다.

다음 코드를 살펴봅시다.

# 기호주의 AI의 핵심: 규칙 기반 추론
class SymbolicReasoner:
    def __init__(self):
        # 지식을 규칙으로 정의합니다
        self.rules = {
            "비가 온다": "우산을 가져간다",
            "온도가 낮다": "겉옷을 입는다",
            "비가 온다": "장화를 신는다",
        }

    def reason(self, situation):
        # 주어진 상황에 대해 규칙을 적용합니다
        actions = []
        for condition, action in self.rules.items():
            if condition in situation:
                actions.append(action)
        return actions

# "비가 온다" 상황에서 추론 실행
reasoner = SymbolicReasoner()
result = reasoner.reason("오늘 비가 온다")
print(result)  # ['우산을 가져간다', '장화를 신는다']

"AI 에이전트 완전 정복 - Hello Agents" 코스의 두 번째 카드뉴스에 오신 것을 환영합니다. 지난 첫 번째 카드뉴스에서는 에이전트의 정의와 유형, 그리고 다양한 패러다임을 살펴보았습니다.

이번에는 그 에이전트가 어떤 과정을 거쳐 발전해 왔는지, 역사의 시간선을 따라가 보겠습니다. 김개발 씨는 최근 챗봇과 AI 코딩 도구에 매료되어 "AI는 원래부터 이렇게 똑똑했을까?"라는 궁금증을 품게 되었습니다.

사내 스터디에서 AI 역사 발표를 맡게 된 김개발 씨, 선배 박시니어 씨에게 도움을 청했습니다. 박시니어 씨는 빈 웃음을 지으며 말했습니다.

"AI의 역사는 생각보다 훨씬 깁니다. 1950년대로 거슬러 올라가야 해요." 그렇다면 기호주의란 정확히 무엇일까요?

쉽게 비유하자면, 기호주의는 마치 요리 레시피와 같습니다. "토마토 2개를 썰고, 올리브유를 두르고, 불을 약하게 줄인다"처럼 모든 과정을 정확한 규칙으로 기록해 두는 방식입니다.

이 레시피를 그대로 따르면 누구나 같은 요리를 만들 수 있습니다. 기호주의 AI도 마찬가지입니다.

개발자가 모든 규칙을 미리 정해두면, 컴퓨터는 그 규칙을 기호로 변환하여 논리적으로 문제를 해결합니다. 기호주의가 없던 시절에는 어땠을까요?

물론 기호주의 이전에도 사람들은 "기계가 생각할 수 있을까?"라는 질문을 던졌습니다. 하지만 구체적인 방법론이 없었습니다.

1956년, 다트머스 회의에서 Allan Newell과 Herbert Simon이 Logic Theorist를 발표하면서 상황이 바뀝니다. 이 프로그램은 수학적 정리를 스스로 증명하는 데 성공했고, 사람들은 "기계가 논리적으로 생각할 수 있다"는 가능성을 보게 되었습니다.

이후 기호주의는 AI 연구의 주류로 자리 잡았습니다. 연구자들은 지식을 If-Then 규칙의 형태로 체계적으로 정리했습니다.

"만약 A라면 B다"라는 형태로, 수많은 규칙을 컴퓨터에 입력하면 복잡한 문제도 해결할 수 있다고 믿었습니다. 위의 코드를 한 줄씩 살펴보겠습니다.

먼저 SymbolicReasoner 클래스를 정의합니다. 이 클래스는 상황과 행동의 매핑 규칙을 사전 형태로 저장합니다.

reason 메서드에서는 주어진 상황 문자열에 규칙의 조건이 포함되어 있는지 확인하고, 일치하는 모든 행동을 수집하여 반환합니다. 상황이 "오늘 비가 온다"이고 규칙에 "비가 온다" 조건이 있으므로, 해당 행동들이 순서대로 수집됩니다.

실제 현업에서는 어떻게 활용할까요? 은행의 대출 심사 시스템을 예로 들 수 있습니다.

"신용등급이 700 미만이면 대출을 거절한다", "소득이 3천만 원 이상이면 금리를 0.5% 낮춘다"처럼 명확한 비즈니스 규칙이 있는 곳에서 기호주의 접근법은 여전히 유효합니다. 실제로 많은 금융 시스템의 뼈대에는 이런 규칙 기반 엔진이 남아 있습니다.

하지만 주의할 점도 있습니다. 기호주의의 가장 큰 한계는 모든 상황을 미리 규칙으로 정의해야 한다는 점입니다.

현실 세계는 너무 복잡해서, 발생할 수 있는 모든 경우의 수를 규칙으로 만들 수 없습니다. 또한 규칙이 많아질수록 규칙 간의 충돌이 발생하고, 시스템을 유지보수하기가 점점 어려워집니다.

이 한계가 훗날 새로운 AI 패러다임을 탄생시키는 계기가 됩니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

박시니어 씨의 설명을 들은 김개발 씨는 고개를 끄덕였습니다. "그러니까, 초기 AI는 사람이 규칙을 모두 만들어주면 기계가 그것을 따르는 방식이었군요!" 기호주의는 AI의 첫걸음이었습니다.

완벽하지는 않았지만, "기계가 논리적으로 추론할 수 있다"는 것을 증명한 거대한 첫걸음이었습니다.

실전 팁

💡 - 기호주의는 현실 세계의 복잡성을 모두 규칙으로 표현하기 어렵다는 근본적 한계가 있습니다

오늘날에도 규칙이 명확한 도메인(금융, 법률 등)에서는 기호주의적 접근이 유효하게 사용됩니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

2. 전문가 시스템과 규칙 기반 에이전트

김개발 씨가 스터디 준비를 하던 중, 흥미로운 사실을 발견했습니다. 1980년대에 이미 AI가 의사의 진단을 돕는 시스템이 상용화되었다는 것입니다.

"그때 이미 그런 게 있었다고요?" 놀란 김개발 씨, 박시니어 씨에게 자세히 물어보기로 했습니다.

**전문가 시스템(Expert System)**은 특정 분야 전문가의 지식을 규칙으로 추출하여 컴퓨터에 구현한 시스템입니다. 마치 경험 많은 선배의 머릿속 지식을 그대로 복사해 놓은 것과 같습니다.

기호주의의 한계를 규칙의 양과 질로 극복하려 했던 대표적 시도입니다.

다음 코드를 살펴봅시다.

# 전문가 시스템의 핵심: 조건부 규칙 엔진
class MedicalExpertSystem:
    def __init__(self):
        self.rules = [
            {"conditions": ["발열", "기침"], "confidence": 0.8,
             "diagnosis": "감기", "advice": "충분한 휴식과 수분 섭취"},
            {"conditions": ["발열", "호흡곤란"], "confidence": 0.95,
             "diagnosis": "폐렴 의심", "advice": "즉시 응급실 방문"},
            {"conditions": ["두통", "메스꺼움"], "confidence": 0.7,
             "diagnosis": "편두통", "advice": "안정을 취하며 경과 관찰"},
        ]

    def diagnose(self, symptoms):
        results = []
        for rule in self.rules:
            match = all(s in symptoms for s in rule["conditions"])
            if match:
                results.append(rule)
        # 신뢰도가 높은 순으로 정렬합니다
        return sorted(results, key=lambda r: r["confidence"], reverse=True)

# 환자 증상으로 진단 수행
doctor = MedicalExpertSystem()
result = doctor.diagnose(["발열", "기침", "두통"])
for r in result:
    print(f"{r['diagnosis']} (신뢰도: {r['confidence']}) - {r['advice']}")

기호주의 AI가 "기계도 생각할 수 있다"는 가능성을 보여준 후, 연구자들은 더 큰 질문을 던졌습니다. "이걸 실제로 쓸 수는 없을까?" 이 질문에 답한 것이 바로 전문가 시스템입니다.

1960년대 후반부터 1980년대까지, 전문가 시스템은 AI 실용화의 최전선에 서 있었습니다. 가장 유명한 사례는 MYCIN입니다.

스탠퍼드 대학에서 개발된 MYCIN은 감염성 질환을 진단하고 항생제를 처방하는 시스템이었습니다. 의사들의 진단 결과와 비교했을 때, MYCIN의 정확도는 의사들보다 높았다고 합니다.

하지만 "컴퓨터가 사람의 생명을 결정할 수는 없다"는 윤리적 문제로 인해 실제 임상에 투입되지는 못했습니다. 쉽게 비유하자면, 전문가 시스템은 마치 경력 30년의 요리사가 남긴 레시피 노트와 같습니다.

초보 요리사가 이 노트를 보면, 경험 많은 요리사와 비슷한 수준의 요리를 만들 수 있습니다. 전문가 시스템도 마찬가지입니다.

분야 전문가가 수십 년간 쌓은 지식을 "규칙"의 형태로 컴퓨터에 입력하면, 그 컴퓨터가 전문가처럼 판단할 수 있습니다. 전문가 시스템의 구조를 살펴보면 크게 세 가지 핵심 요소로 이루어집니다.

첫째, **지식 베이스(Knowledge Base)**입니다. 이것은 전문가의 지식이 저장되는 곳입니다.

의료 전문가 시스템이라면 "발열이 있고 기침이 동반되면 감기일 가능성이 높다" 같은 수천 개의 규칙이 여기에 저장됩니다. 둘째, **추론 엔진(Inference Engine)**입니다.

이것은 지식 베이스의 규칙을 바탕으로 새로운 결론을 도출하는 핵심 모듈입니다. 사용자가 입력한 증상과 규칙을 매칭하여, 가장 적절한 진단을 찾아냅니다.

셋째, 사용자 인터페이스입니다. 사용자가 증상을 입력하고, 시스템이 진단 결과를 보여주는 창구입니다.

위의 코드를 한 줄씩 살펴보겠습니다. MedicalExpertSystem 클래스는 의료 전문가 시스템을 간단히 모방한 것입니다.

각 규칙은 conditions(증상 조건), confidence(신뢰도), diagnosis(진단명), advice(조언)로 구성됩니다. diagnose 메서드는 환자의 증상이 주어지면, 모든 규칙을 검사하여 조건이 일치하는 결과를 신뢰도 순으로 정렬하여 반환합니다.

실제 현업에서는 어떻게 활용할까요? 1980년대에는 DEC사의 XCON이라는 전문가 시스템이 큰 성공을 거두었습니다.

XCON은 컴퓨터 주문을 자동으로 구성하는 시스템이었는데, 매년 4천만 달러 이상의 비용을 절감했습니다. 이 성공으로 전문가 시스템 시장은 폭발적으로 성장했고, 수많은 기업이 도입을 시도했습니다.

하지만 주의할 점도 있습니다. 전문가 시스템의 치명적인 한계는 지식 획득의 병목이었습니다.

전문가의 머릿속 지식을 규칙으로 추출하는 과정이 생각보다 훨씬 어려웠습니다. 전문가들은 자신이 어떻게 판단하는지 명확히 설명하지 못하는 경우가 많았고, "알 수 없지만 경험적으로 알고 있다"는 암묵지를 규칙으로 변환하는 것은 거의 불가능에 가까웠습니다.

또한 규칙이 수천 개를 넘어가면 관리가 불가능해지고, 예상치 못한 상황에는 전혀 대처하지 못하는 취약성이 드러났습니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

박시니어 씨는 말했습니다. "전문가 시스템은 규칙만으로는 한계가 있다는 것을 보여준 중요한 교훈이에요.

사람의 지식을 모두 규칙으로 표현할 수 없다는 걸 깨닫게 해주었죠." 김개발 씨는 노트에 적었습니다. "규칙 기반 접근의 한계를 극복하려면, 기계가 스스로 학습해야 한다." 이 문장은 다음 단계로 향하는 열쇠가 됩니다.

실전 팁

💡 - 전문가 시스템은 지식 획득 병목(Knowledge Acquisition Bottleneck)이라는 근본적 한계를 가집니다

규칙이 많아질수록 유지보수가 어려워지며, 예상치 못한 상황에 대처하지 못합니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

3. 머신러닝 시대의 에이전트 발전

김개발 씨는 스터디에서 전문가 시스템의 한계를 발표한 후, 팀원에게 이런 질문을 받았습니다. "그럼 규칙을 사람이 만들지 말고, 기계가 스스로 배우게 하면 되지 않을까요?" 김개발 씨는 이 질문이 사실 다음 시대의 문을 여는 열쇠라는 것을 곧 알게 됩니다.

**머신러닝(Machine Learning)**은 데이터에서 스스로 패턴을 학습하여 문제를 해결하는 접근법입니다. 마치 아이가 수많은 고양이 사진을 보며 "이게 고양이구나"라고 스스로 깨닫는 것과 같습니다.

규칙을 사람이 직접 만들던 기호주의의 한계를 극복한 혁명적 전환입니다.

다음 코드를 살펴봅시다.

# 머신러닝의 핵심: 데이터에서 패턴 학습하기
from sklearn.linear_model import Perceptron
from sklearn.model_selection import train_test_split

# 에이전트 행동 데이터 준비합니다
# 특성: [사용자 감정(0=부정,1=긍정), 질문 복잡도(0-10), 이전 대화 수]
X = [
    [0, 2, 1], [0, 3, 2], [0, 1, 1],   # 부정 감정
    [1, 5, 3], [1, 8, 5], [1, 4, 2],   # 긍정 감정
    [0, 7, 4], [1, 9, 6], [0, 6, 3],   # 혼합 상황
]
# 정답: 0=단순 응답, 1=상세 응답
y = [0, 0, 0, 1, 1, 0, 1, 1, 1]

# 데이터를 학습용과 테스트용으로 분리합니다
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# 퍼셉트론 모델로 학습합니다
model = Perceptron(max_iter=1000)
model.fit(X_train, y_train)

# 새로운 상황에서 에이전트 응답 예측
prediction = model.predict([[1, 7, 4]])  # 긍정, 복잡, 대화 경험 있음
print(f"예측 응답: {'상세 응답' if prediction[0] == 1 else '단순 응답'}")

전문가 시스템이 "사람이 규칙을 만든다"는 방식의 한계에 부딪혔을 때, 연구자들은 근본적으로 다른 접근을 고민하기 시작했습니다. "만약 컴퓨터가 스스로 규칙을 발견하게 한다면 어떨까?" 이 아이디어가 바로 머신러닝의 핵심입니다.

1950년대 Arthur Samuel이 "기계가 스스로 학습할 수 있도록 하는 연구 분야"라고 정의한 이 개념은, 수십 년의 침체기를 거친 후 2000년대와 2010년대에 폭발적인 성장을 이룩합니다. 쉽게 비유하자면, 머신러닝은 마치 아이가 자전거 타는 법을 배우는 과정과 같습니다.

부모가 "왼쪽 페달을 밟고, 오른쪽 핸들을 15도 꺾고..."라고 규칙을 일일이 가르치는 것이 아닙니다. 아이는 넘어지고 다시 일어서는 과정을 반복하면서, 자신만의 규칙을 몸으로 체득합니다.

머신러닝도 마찬가지입니다. 수많은 데이터를 경험하면서, 데이터 속에 숨겨진 패턴을 스스로 발견합니다.

머신러닝이 에이전트 발전에 미친 영향은 결정적이었습니다. 기존의 규칙 기반 에이전트는 "사용자가 X라고 말하면 Y라고 응답한다"는 식의 고정 규칙만 따랐습니다.

하지만 머신러닝 기반 에이전트는 사용자의 행동 패턴, 선호도, 맥락을 데이터에서 학습하여 점점 더 똑똑해지는 것이 가능해졌습니다. 머신러닝의 발전을 이끈 세 가지 핵심 요소가 있습니다.

첫째, 데이터의 폭발적 증가입니다. 인터넷의 보급으로 학습에 사용할 데이터가 기하급수적으로 늘어났습니다.

1990년대에 수천 개였던 데이터 포인트는 2010년대에 수십억 개로 증가했습니다. 둘째, 컴퓨팅 파워의 향상입니다.

특히 GPU(그래픽 처리 장치)가 병렬 연산에 탁월한 성능을 발휘하면서, 대규모 데이터를 빠르게 처리할 수 있게 되었습니다. 셋째, 알고리즘의 발전입니다.

신경망(Neural Network)을 기반으로 한 **딥러닝(Deep Learning)**이 등장하면서, 이미지 인식, 음성 인식, 자연어 처리 등에서 인간 수준 이상의 성능을 보이기 시작했습니다. 위의 코드를 한 줄씩 살펴보겠습니다.

먼저 에이전트의 행동을 결정하는 특성 데이터를 준비합니다. 사용자 감정, 질문 복잡도, 이전 대화 수를 특성으로 사용하고, 단순 응답과 상세 응답을 분류하는 문제를 설정합니다.

train_test_split으로 데이터를 분리한 후, Perceptron 모델에 학습 데이터를 입력합니다. 학습이 완료되면 새로운 상황에 대해 에이전트가 어떤 응답을 선택할지 예측할 수 있습니다.

실제 현업에서는 어떻게 활용할까요? 추천 시스템이 대표적입니다.

넷플릭스, 유튜브, 아마존의 추천 시스템은 머신러닝을 기반으로 합니다. 사용자의 시청 기록, 클릭 패턴, 체류 시간 등의 데이터를 학습하여 "이 사용자에게 이 콘텐츠를 추천하면 좋겠다"고 예측합니다.

이것은 사실상 매우 정교한 형태의 에이전트입니다. 사용자의 행동을 관찰하고, 패턴을 학습하며, 최적의 행동을 선택하는 것이죠.

하지만 주의할 점도 있습니다. 머신러닝 모델은 학습 데이터의 품질에 크게 의존합니다.

편향된 데이터로 학습하면 편향된 결과를 내놓습니다. 또한 모델이 어떻게 결정을 내렸는지 설명하기 어렵다는 블랙박스 문제가 있습니다.

의료나 법률 같은 분야에서는 이 설명 가능성(Explainability)이 매우 중요한데, 이 문제는 아직도 활발한 연구 주제입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

"그러니까, 전문가 시스템은 사람이 규칙을 만들고, 머신러닝은 기계가 데이터에서 규칙을 발견하는 거군요!" 김개발 씨의 눈이 반짝였습니다. 박시니어 씨는 고개를 끄덕이며 덧붙였습니다.

"맞아요. 그리고 이 발전은 더 큰 도약, 바로 에이전트가 환경과 직접 상호작용하며 학습하는 방식으로 이어집니다."

실전 팁

💡 - 머신러닝은 "규칙을 프로그래밍"하는 것이 아니라 "데이터에서 규칙을 학습"하는 패러다임 전환입니다

데이터의 질과 양이 모델의 성능을 결정하므로, 데이터 수집과 전처리가 가장 중요합니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

4. 강화학습 기반 에이전트의 등장

김개발 씨가 최근 알파고에 대한 다큐멘터리를 보았습니다. "기계가 어떻게 바둑 기사를 이길 수 있었을까요?" 이 질문의 답은 단순히 "더 많이 계산해서"가 아니었습니다.

핵심은 에이전트가 환경과 상호작용하며 스스로 전략을 학습하는 강화학습에 있었습니다.

**강화학습(Reinforcement Learning)**은 에이전트가 환경과 상호작용하며 보상을 최대화하는 행동 전략을 스스로 학습하는 방법입니다. 마치 강아지가 간식을 보상받으며 명령을 배우는 것과 같습니다.

에이전트가 자율적으로 의사결정을 내리는 능력의 핵심입니다.

다음 코드를 살펴봅시다.

# 강화학습의 핵심: Q-Learning으로 미로 탈출 에이전트
import numpy as np

# 4x4 미로 환경을 정의합니다 (0=빈칸, 1=장애물, 2=목표)
maze = np.array([
    [0, 0, 0, 0],
    [0, 1, 0, 1],
    [0, 0, 0, 0],
    [1, 0, 2, 0],
])
# Q-테이블 초기화: 상태(16) x 행동(상하좌우)
q_table = np.zeros((16, 4))

# 학습 파라미터
learning_rate = 0.1
discount = 0.95
epsilon = 0.1  # 탐험 확률

def get_reward(state):
    row, col = divmod(state, 4)
    if maze[row][col] == 2:
        return 100   # 목표 도달 보상
    if maze[row][col] == 1:
        return -50   # 장애물 충돌 페널티
    return -1        # 한 걸음 이동 비용

# 에이전트가 미로를 탐험하며 학습합니다
for episode in range(500):
    state = 0  # 시작 위치
    for step in range(50):
        # epsilon-greedy: 무작위 탐험 vs 경험 활용
        if np.random.random() < epsilon:
            action = np.random.randint(4)
        else:
            action = np.argmax(q_table[state])
        # Q-값 업데이트: 미래 보상을 고려하여 학습합니다
        next_state = (state + [4, -4, 1, -1][action]) % 16
        reward = get_reward(next_state)
        best_next = np.max(q_table[next_state])
        q_table[state][action] += learning_rate * (
            reward + discount * best_next - q_table[state][action]
        )
        state = next_state
        if reward == 100:
            break

print("학습 완료! 최적 Q-값 경로가 형성되었습니다.")

머신러닝이 "데이터에서 패턴을 발견"하는 능력을 부여했다면, 강화학습은 에이전트에게 "행동하고 그 결과를 통해 배우는" 능력을 부여했습니다. 이것은 에이전트 발전사에서 매우 중요한 전환점입니다.

강화학습의 아이디어는 놀라울 정도로 직관적입니다. 심리학의 행동주의에서 영감을 받았는데, "좋은 행동에는 보상을, 나쁜 행동에는 벌을" 주면 개체가 최적의 행동을 학습한다는 원리입니다.

쉽게 비유하자면, 강화학습은 마치 비디오 게임을 처음 하는 사람과 같습니다. 처음에는 버튼을 아무렇게나 누르다가, 점수가 올라가는 버튼 조합을 발견하고, 더 높은 점수를 위해 전략을 수정합니다.

죽으면(벌), 다른 방법을 시도하고, 클리어하면(보상), 그 방법을 기억합니다. 강화학습 에이전트도 똑같은 방식으로 학습합니다.

강화학습의 핵심 구조를 이해하려면 **MDP(Markov Decision Process)**라는 개념을 알아야 합니다. MDP는 다섯 가지 요소로 구성됩니다.

**상태(State)**는 에이전트가 현재 처한 상황입니다. **행동(Action)**은 에이전트가 선택할 수 있는 행동입니다.

**전이(Transition)**는 행동에 따라 상태가 어떻게 변하는지를 나타냅니다. **보상(Reward)**은 행동의 결과로 얻는 점수입니다.

그리고 **할인율(Discount Factor)**은 미래의 보상을 현재 가치로 환산하는 비율입니다. 위의 코드를 한 줄씩 살펴보겠습니다.

먼저 4x4 미로 환경을 정의합니다. 빈칸, 장애물, 목표 지점으로 구성된 미로에서 에이전트는 목표를 찾아야 합니다.

q_table은 각 상태에서 각 행동의 가치를 저장하는 표입니다. 학습 과정에서 에이전트는 epsilon-greedy 전략을 사용합니다.

10%의 확률로 무작위 행동을 하여 새로운 경로를 탐험하고, 90%의 확률로 현재까지 배운 최적의 행동을 선택합니다. Q-값 업데이트 공식은 "현재 보상 + 미래 보상의 예상값 - 현재 Q-값" 만큼 Q-값을 조정합니다.

2016년, **알파고(AlphaGo)**가 이 세상에 등장했습니다. DeepMind가 개발한 알파고는 강화학습과 딥러닝을 결합하여 바둑의 세계 챔피언 이세돌을 4대1로 이겼습니다.

바둑은 경우의 수가 우주의 원자 수보다 많다고 알려진 게임입니다. 전문가 시스템으로는 도저히 해결할 수 없는 문제였습니다.

알파고는 수천만 번의 자기 대국을 통해, 인간이 수천 년간 발견하지 못한 새로운 수를 찾아냈습니다. 이후 알파고의 후속작인 AlphaZero는 인간의 바둑 기보를 전혀 학습하지 않고, 오직 강화학습만으로 바둑, 체스, 장기의 최고 수준에 도달했습니다.

이것은 "기계가 스스로 세상의 규칙을 발견할 수 있다"는 것을 입증한 상징적 사건입니다. 실제 현업에서는 어떻게 활용할까요?

자율주행 자동차가 대표적입니다. 자율주행 에이전트는 도로 환경(상태)을 인식하고, 조향과 속도 제어(행동)를 결정하며, 안전 운전(보상)을 최대화하도록 학습합니다.

또한 로봇 공학에서 로봇이 물체를 잡고 옮기는 행동을 강화학습으로 학습하고, 데이터센터에서는 전력 소모를 최소화하는 냉각 시스템을 강화학습으로 최적화합니다. 하지만 주의할 점도 있습니다.

강화학습의 가장 큰 문제는 **보상 설계(Reward Design)**입니다. 에이전트는 우리가 원하는 것이 아니라, 우리가 정해준 보상을 최대화합니다.

보상을 잘못 설정하면 예상치 못한 행동을 학습합니다. 예를 들어, "코인을 많이 먹어라"라는 보상을 준 게임 에이전트가 코인 바로 앞에서 죽었다가 부활하여 코인을 다시 먹는 행동을 반복한 사례도 있습니다.

이를 **보상 해킹(Reward Hacking)**이라고 부릅니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

"에이전트가 환경과 상호작용하며 스스로 학습한다니, 정말 놀랍네요!" 김개발 씨는 스터디 발표 자료에 이 문장을 크게 적었습니다. "강화학습은 에이전트가 자율적으로 행동할 수 있게 해준 핵심 기술이다." 박시니어 씨가 말했습니다.

"하지만 강화학습 에이전트도 한계가 있어요. 미리 정해진 환경에서는 훌륭하지만, 복잡한 언어나 추론이 필요한 상황에서는 부족했죠.

그리고 그 한계를 깨뜨린 것이 바로..."

실전 팁

💡 - 강화학습에서는 보상 설계가 가장 중요합니다. 잘못된 보상은 보상 해킹이라는 의도치 않은 결과를 낳습니다

탐험(Exploration)과 활용(Exploitation)의 균형을 맞추는 것이 강화학습 에이전트의 핵심 딜레마입니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

5. 대규모 언어모델의 혁신

김개발 씨의 팀에 새로운 AI 비서가 도입되었습니다. "이 코드를 리뷰해 줘", "이 버그의 원인을 분석해 줘"라고 말하면 마치 팀원처럼 정확한 답변을 돌려줍니다.

김개발 씨는 이 기술의 정체가 궁금해졌습니다. "이게 어떻게 가능한 거죠?" 박시니어 씨의 답은 짧았습니다.

"LLM이에요."

**대규모 언어모델(LLM, Large Language Model)**은 수조 개의 파라미터로 학습된 거대한 신경망으로, 인간의 언어를 이해하고 생성하는 능력을 갖춘 모델입니다. 마치 전 세계의 책을 읽고 요약한 초지식 인재와 같습니다.

AI 에이전트의 뇌 역할을 하는 혁신적 기술입니다.

다음 코드를 살펴봅시다.

# LLM 기반 에이전트의 핵심: 프롬프트로 행동 제어하기
import openai

def create_agent_response(user_message, system_context):
    """LLM을 에이전트의 두뇌로 사용합니다"""
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_context},
            {"role": "user", "content": user_message},
        ],
        temperature=0.7,
    )
    return response.choices[0].message.content

# 에이전트의 페르소나와 행동 규칙을 정의합니다
AGENT_CONTEXT = """
당신은 친절한 코딩 멘토 에이전트입니다.
사용자의 질문에 코드 예제를 포함하여 답변하세요.
초보자도 이해할 수 있도록 쉽게 설명하세요.
"""

# 사용자 질문에 에이전트가 응답합니다
question = "Python에서 리스트와 튜플의 차이점이 뭔가요?"
answer = create_agent_response(question, AGENT_CONTEXT)
print(answer)

2017년, Google의 연구팀이 **"Attention is All You Need"**라는 논문을 발표했습니다. 이 논문에서 제안한 Transformer 아키텍처는 AI 역사상 가장 중요한 발명 중 하나로 꼽힙니다.

그리고 이 Transformer를 기반으로 탄생한 것이 바로 **대규모 언어모델(LLM)**입니다. 이전까지의 언어 모델은 문장을 단어 순서대로 처리했습니다.

하지만 Transformer는 Self-Attention이라는 메커니즘을 사용하여, 문장의 모든 단어를 동시에 보고 단어 간의 관계를 파악합니다. "나는 사과를 좋아하고, 바나나도 좋아한다"라는 문장에서 "나는"이 "좋아한다"와 어떤 관계인지, "사과"와 "바나나"가 왜 같은 범주인지를 한 번에 파악합니다.

쉽게 비유하자면, LLM은 마치 전 세계 도서관의 책을 모두 읽은 초지식 인재와 같습니다. 어떤 질문을 해도, 수십억 권의 책에서 관련 지식을 찾아내어 자연스러운 문장으로 답변합니다.

단순히 정보를 검색하는 것이 아니라, 맥락을 이해하고 추론하며, 새로운 문장을 생성합니다. LLM의 발전을 이끈 핵심 원리는 **Scale Law(스케일 법칙)**입니다.

OpenAI의 연구에 따르면, 모델의 파라미터 수, 학습 데이터의 크기, 컴퓨팅 파워를 늘리면 모델의 성능이 예측 가능하게 향상합니다. 2018년 GPT-1은 1억 1천만 개의 파라미터를 가졌고, 2019년 GPT-2는 15억 개, 2020년 GPT-3는 1,750억 개로 증가했습니다.

이 스케일업은 **부작용 없는 성능 향상(Emergent Abilities)**이라는 놀라운 현상을 낳았습니다. 작은 모델에서는 전혀 할 수 없었던 번역, 요약, 코딩 같은 능력이, 모델이 일정 크기를 넘어서면 갑자기 나타나는 것입니다.

위의 코드를 한 줄씩 살펴보겠습니다. create_agent_response 함수는 LLM API를 호출하여 에이전트의 응답을 생성합니다.

핵심은 system context입니다. 시스템 메시지에 에이전트의 역할, 행동 규칙, 응답 스타일을 정의하면, LLM이 그 페르소나를 따라 응답합니다.

사용자의 질문이 들어오면, LLM은 시스템 컨텍스트와 사용자 질문을 함께 고려하여 적절한 답변을 생성합니다. temperature는 응답의 다양성을 조절하는 파라미터로, 낮을수록 결정적이고 높을수록 창의적인 응답을 만듭니다.

LLM이 에이전트에 가져온 변화는 혁명적이었습니다. 이전의 에이전트는 미리 정의된 규칙이나 제한된 환경에서만 동작했습니다.

하지만 LLM 기반 에이전트는 자연어로 지시만 하면 어떤 작업이든 수행할 수 있습니다. "이메일을 작성해 줘", "코드를 리뷰해 줘", "데이터를 분석해 줘"처럼 사람의 언어로 명령하면, LLM이 그 의도를 이해하고 적절한 행동을 선택합니다.

하지만 주의할 점도 있습니다. LLM은 환각(Hallucination) 현상을 보입니다.

자신 있는 어조로 사실이 아닌 정보를 말하는 것입니다. 또한 수학적 계산이나 논리적 추론에서 오류를 범할 수 있습니다.

최신 정보에 접근할 수 없다는 점도 한계입니다. 이런 한계를 극복하기 위해 RAG(Retrieval-Augmented Generation), Chain-of-Thought 같은 기법이 개발되었고, 이것은 다음 카드에서 다룰 LLM 기반 에이전트의 핵심 기술이 됩니다.

다시 김개발 씨의 이야기로 돌아가 봅시다. "LLM이 에이전트의 두뇌 역할을 한다고요?

그러면 LLM에 도구를 연결하면 진짜 뭔가를 할 수 있는 에이전트가 되는 건가요?" 박시니어 씨가 빛나는 눈으로 대답했습니다. "정확해요.

그게 바로 LLM 기반 에이전트의 핵심이에요."

실전 팁

💡 - LLM의 성능은 모델 크기와 학습 데이터 규모에 비례하여 향상하는 스케일 법칙을 따릅니다

환각 현상을 방지하려면 RAG나 체인 오브 생각 같은 기법을 활용하는 것이 좋습니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

6. LLM 기반 에이전트의 탄생과 발전

김개발 씨의 팀에서 주목하는 프로젝트가 하나 있습니다. "LLM이 직접 웹 검색을 하고, 코드를 실행하고, 이메일까지 보내는 에이전트를 만들 수 없을까?" 이 아이디어는 단순한 상상이 아니었습니다.

2023년 이후, 전 세계의 개발자들이 바로 이것을 현실로 만들고 있었습니다.

LLM 기반 에이전트는 대규모 언어모델을 두뇌로 삼고, 외부 도구와 API를 활용하여 복잡한 작업을 자율적으로 수행하는 시스템입니다. 마치 똑똑한 비서에게 도구 사용법을 알려주면 스스로 업무를 처리하는 것과 같습니다.

AI 에이전트의 궁극적 형태에 가장 가까운 패러다임입니다.

다음 코드를 살펴봅시다.

# LLM 기반 에이전트: 도구 사용과 추론 루프
import json

class ToolUsingAgent:
    def __init__(self, llm_client, tools):
        self.llm = llm_client
        self.tools = tools  # 사용 가능한 도구 목록

    def run(self, task, max_steps=5):
        messages = [{"role": "user", "content": task}]
        for step in range(max_steps):
            # LLM이 다음 행동을 결정합니다
            response = self.llm.chat(messages)
            thought = response.get("thought", "")

            if "최종 답변" in thought:
                return response["answer"]

            # 도구 호출이 필요한 경우 실행합니다
            if "도구" in response:
                tool_name = response["tool_name"]
                tool_input = response["tool_input"]
                # 에이전트가 도구를 사용하여 환경과 상호작용합니다
                result = self.tools[tool_name](**tool_input)
                messages.append({
                    "role": "assistant",
                    "content": f"생각: {thought}\n도구 사용: {tool_name}"
                })
                messages.append({
                    "role": "tool",
                    "content": f"결과: {json.dumps(result, ensure_ascii=False)}"
                })
        return "최대 단계 수에 도달했습니다."

# 도구 정의: 에이전트가 사용할 수 있는 능력
tools = {
    "search": lambda query: {"results": [f"{query} 관련 검색 결과"]},
    "calculate": lambda expr: {"result": eval(expr)},
}

# 에이전트에게 복잡한 작업을 맡깁니다
agent = ToolUsingAgent(llm_client=None, tools=tools)

LLM이 언어를 이해하고 생성할 수 있다는 것을 알게 된 후, 연구자들은 자연스럽게 다음 질문을 던졌습니다. "이 언어 이해 능력을 활용해 에이전트를 만들 수 있다면?" 2022년 말 ChatGPT가 등장하면서, 이 질문에 대한 답이 현실로 다가왔습니다.

LLM이 이전의 어떤 시스템보다도 자연스럽게 인간의 의도를 이해하고, 적절한 응답을 생성하는 능력을 보여주었습니다. 그리고 2023년, 연구자들은 LLM을 에이전트의 두뇌로 사용하는 본격적인 시도를 시작했습니다.

이 패러다임의 핵심 아이디어는 간단합니다. LLM은 생각할 줄 아는데, 행동할 수는 없습니다.

그러니까 **도구(Tool)**를 연결해 주자는 것입니다. 검색 엔진, 코드 실행기, 계산기, 데이터베이스, API 같은 도구를 LLM에 연결하면, LLM이 스스로 어떤 도구를 사용할지 결정하고, 도구의 결과를 바탕으로 다음 행동을 계획합니다.

쉽게 비유하자면, LLM 기반 에이전트는 마치 전화로 지시를 받으며 현장에서 작업하는 프로젝트 매니저와 같습니다. 본사(사용자)에서 "다음 주 회의 일정을 잡아 줘"라고 전화를 걸면, 프로젝트 매니저는 참석자 일정을 확인하고(도구 사용), 회의실을 예약하고(도구 사용), 초대 이메일을 보내고(도구 사용), 최종적으로 "회의가 예약되었습니다"라고 보고합니다.

가장 영향력 있는 초기 연구 중 하나가 **ReAct(Reasoning + Acting)**입니다. 2022년 Yao 등이 발표한 ReAct는 에이전트가 "생각(Thought)"과 "행동(Action)"을 번갈아 반복하는 프레임워크입니다.

에이전트는 문제를 해결하기 위해 먼저 생각을 정리하고, 필요한 도구를 사용하며, 도구의 결과를 바탕으로 다시 생각을 수정합니다. 이 추론-행동 루프는 LLM 기반 에이전트의 기본 패턴이 되었습니다.

2023년에는 더 야심찬 프로젝트들이 등장했습니다. AutoGPT는 사용자가 목표만 주면 스스로 작업을 분해하고 실행하는 자율 에이전트를 시도했습니다.

BabyAGI는 작업 목록을 관리하며 순차적으로 작업을 수행하는 에이전트를 구현했습니다. 이들 프로젝트는 완벽하지는 않았지만, LLM 기반 에이전트의 가능성을 전 세계에 보여주었습니다.

위의 코드를 한 줄씩 살펴보겠습니다. ToolUsingAgent 클래스는 LLM 기반 에이전트의 핵심 구조를 보여줍니다.

__init__에서 LLM 클라이언트와 사용 가능한 도구 목록을 받습니다. run 메서드는 추론-행동 루프를 구현합니다.

LLM의 응답에 "최종 답변"이 포함되면 작업을 종료하고, "도구"가 필요하면 해당 도구를 실행하여 결과를 메시지 히스토리에 추가합니다. 이 과정을 최대 단계 수만큼 반복하면서 에이전트는 점진적으로 문제를 해결합니다.

실제 현업에서는 어떻게 활용할까요? LangChain과 LlamaIndex 같은 프레임워크가 이 패러다임을 실용화했습니다.

LangChain의 Agent 모듈은 LLM, 도구, 메모리를 쉽게 결합할 수 있는 인터페이스를 제공합니다. 많은 기업에서 고객 지원 챗봇, 문서 분석 시스템, 코드 리뷰 자동화에 이 프레임워크를 활용하고 있습니다.

GitHub Copilot도 사실 LLM을 두뇌로 삼고 코드 편집기를 도구로 사용하는 에이전트의 일종입니다. 하지만 주의할 점도 있습니다.

LLM 기반 에이전트의 가장 큰 문제는 안정성입니다. 동일한 입력에도 다른 도구를 선택하거나, 불필요한 루프에 빠지거나, 환각으로 인해 존재하지 않는 도구를 호출하려는 시도를 합니다.

또한 비용 문제도 무시할 수 없습니다. 복잡한 작업을 수행하려면 수십 번의 LLM API 호출이 필요하고, 이는 누적되면 상당한 비용이 됩니다.

에이전트의 행동을 제어하고 안정성을 높이는 것은 현재도 활발한 연구 주제입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

"LLM에 도구를 연결하면 진짜 뭔가를 할 수 있는 에이전트가 되는 거군요!" 김개발 씨의 스터디 노트는 이제 거의 완성되어 가고 있었습니다. 기호주의에서 전문가 시스템, 머신러닝, 강화학습, 그리고 LLM 기반 에이전트까지.

AI 에이전트의 발전사가 한눈에 보이는 흐름도가 완성되었습니다.

실전 팁

💡 - ReAct 패턴(생각-행동-관찰 루프)은 LLM 기반 에이전트의 가장 기본적이고 중요한 패턴입니다

에이전트의 안정성을 높이려면 도구 선택 범위를 제한하고, 행동을 검증하는 가드레일을 설치하세요
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

7. 에이전트의 미래 전망

김개발 씨의 스터디 발표가 드디어 마무리 단계에 이르렀습니다. "그렇다면, AI 에이전트는 앞으로 어떻게 발전할까요?" 이 마지막 질문에 답하기 위해, 김개발 씨는 최신 연구 동향을 정리하기 시작했습니다.

박시니어 씨가 커피를 내려주며 말했습니다. "미래를 예측하는 가장 좋은 방법은, 현재의 추세를 이해하는 거예요."

AI 에이전트의 미래는 다중 에이전트 협업, 자율적 의사결정, 도메인 특화 에이전트 등의 방향으로 발전하고 있습니다. 마치 하나의 똑똑한 인재가 아니라, 각자 전문성을 가진 팀이 협업하는 것과 같습니다.

에이전트 생태계의 진화가 가속화되고 있습니다.

다음 코드를 살펴봅시다.

# 다중 에이전트 협업 시스템의 기본 구조
class AgentTeam:
    def __init__(self):
        # 각 에이전트의 전문 역할을 정의합니다
        self.agents = {
            "planner": {"role": "계획 수립", "task": "작업을 분해합니다"},
            "coder": {"role": "코드 작성", "task": "코드를 구현합니다"},
            "reviewer": {"role": "코드 리뷰", "task": "코드를 검토합니다"},
            "tester": {"role": "테스트 실행", "task": "코드를 테스트합니다"},
        }

    def collaborate(self, user_request):
        pipeline = ["planner", "coder", "reviewer", "tester"]
        context = user_request
        results = {}

        for agent_name in pipeline:
            agent = self.agents[agent_name]
            print(f"[{agent['role']}] {agent['task']}")
            # 각 에이전트가 이전 결과를 바탕으로 작업합니다
            results[agent_name] = f"{agent_name}: {context} 처리 완료"
            context = results[agent_name]

            # 리뷰어가 문제를 발견하면 코더에게 되돌려보냅니다
            if agent_name == "reviewer" and "수정 필요" in context:
                print("[피드백] 코더에게 수정을 요청합니다")
                pipeline_after = ["coder", "reviewer", "tester"]
                for sub_agent in pipeline_after:
                    sub = self.agents[sub_agent]
                    results[sub_agent] = f"{sub_agent}: 수정 후 재처리"
                break

        return results

# 팀이 협업하여 사용자 요청을 처리합니다
team = AgentTeam()
result = team.collaborate("로그인 API를 만들어 주세요")

"AI 에이전트 완전 정복 - Hello Agents" 코스에서 우리는 지금까지 AI 에이전트의 기원부터 LLM 기반 에이전트까지, 발전의 궤적을 따라가 보았습니다. 기호주의에서 시작된 AI의 역사는 전문가 시스템, 머신러닝, 강화학습을 거쳐 LLM 기반 에이전트에 이르기까지 끊임없이 진화해 왔습니다.

이번 카드에서는 에이전트의 미래를 전망해 보겠습니다. 가장 주목받는 방향 중 하나는 **다중 에이전트 시스템(Multi-Agent System)**입니다.

단일 에이전트도 강력하지만, 복잡한 실제 문제를 해결하려면 여러 전문가가 협업해야 합니다. 쉽게 비유하자면, 건축 프로젝트를 생각해 보세요.

설계사가 설계하고, 시공사가 건설하고, 감리사가 검사합니다. 각자의 전문 분야가 다르지만, 협업하면 완성도 높은 건물을 세울 수 있습니다.

다중 에이전트 시스템도 마찬가지입니다. 계획 에이전트가 작업을 분해하고, 실행 에이전트가 각 작업을 수행하며, 검토 에이전트가 결과를 평가하는 식의 분업이 가능합니다.

위의 코드를 한 줄씩 살펴보겠습니다. AgentTeam 클래스는 다중 에이전트 협업의 기본 구조를 보여줍니다.

계획자, 코더, 리뷰어, 테스터 네 가지 역할의 에이전트가 순차적으로 작업을 수행합니다. 각 에이전트는 이전 에이전트의 결과를 입력으로 받아 자신의 작업을 수행하고, 그 결과를 다음 에이전트에게 전달합니다.

특히 리뷰어가 문제를 발견하면 코더에게 되돌려보내는 피드백 루프가 구현되어 있습니다. 이 패턴은 실제 소프트웨어 개발 프로세스와 유사합니다.

두 번째 방향은 에이전트의 자율성 향상입니다. 현재의 LLM 기반 에이전트는 대부분 사람의 지시가 있어야 움직입니다.

하지만 미래의 에이전트는 더 높은 수준의 자율성을 갖출 것입니다. 스스로 목표를 설정하고, 작업을 계획하며, 실행하고, 결과를 평가하는 자율 루프를 완성하는 것이 목표입니다.

AutoGPT 같은 초기 시도가 보여주듯, 이 방향은 기술적으로 아직 많은 과제가 있지만, 연구 속도는 매우 빠릅니다. 세 번째 방향은 도메인 특화 에이전트입니다.

만능 에이전트보다 특정 분야에 최적화된 에이전트가 더 실용적일 수 있습니다. 의료 분야의 진단 에이전트, 법률 분야의 판례 분석 에이전트, 금융 분야의 투자 분석 에이전트처럼, 각 도메인의 깊은 지식과 전문 도구를 갖춘 에이전트들이 등장하고 있습니다.

이런 특화 에이전트들은 RAG를 통해 최신 도메인 지식을 활용하고, MCP(Model Context Protocol) 같은 표준 프로토콜로 다른 시스템과 통신합니다. 네 번째 방향은 안전성과 제어 가능성입니다.

에이전트가 더 강력해질수록, 안전 문제는 더 중요해집니다. 에이전트의 행동을 모니터링하고, 위험한 행동을 차단하고, 인간의 개입이 필요한 시점을 판단하는 가드레일 기술이 핵심이 됩니다.

또한 에이전트의 결정 과정을 투명하게 만드는 **설명 가능성(XAI)**도 중요한 연구 방향입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다.

스터디 발표를 마친 김개발 씨는 박수를 받았습니다. "에이전트 발전사를 이렇게 쉽게 정리하다니!" 팀원들의 반응이 좋았습니다.

박시니어 씨가 마지막으로 조언했습니다. "에이전트의 미래를 준비하려면, 지금부터 LLM의 기초를 탄탄히 다져야 해요.

모든 에이전트의 뇌가 되는 건 결국 LLM이니까요." 김개발 씨는 고개를 끄덕이며 다음 스터디 주제를 메모했습니다. "대규모 언어모델(LLM) 기초".

에이전트의 두뇌를 이해하는 여정이 곧 시작됩니다.

실전 팁

💡 - 다중 에이전트 시스템에서는 에이전트 간의 명확한 역할 분담과 통신 프로토콜 설계가 핵심입니다

에이전트의 자율성을 높이면서도 안전성을 유지하는 밸런스가 가장 중요한 연구 과제입니다
다음 카드뉴스에서는 "대규모 언어모델(LLM) 기초"를 다룹니다. 에이전트의 두뇌를 이해하는 핵심 편입니다
이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다

이상으로 학습을 마칩니다. 위 내용을 직접 코드로 작성해보면서 익혀보세요!

#Python#AIAgent#LLM#SymbolicAI#MachineLearning#AI,Agent,LLM

에이전트 발전사 기호주의에서 LLM까지

# 에이전트 발전사 기호주의에서 LLM까지 AI 에이전트의 기원부터 LLM 기반 에이전트까지 발전 과정을 이북 스타일로 살펴봅니다. 초보 개발자도 쉽게 이해할 수 있도록 비유와 스토리텔링으로 풀어냅니다. --- ## 목차 1. [초기_AI와_기호주의_접근법](#초기-ai와-기호주의-접근법) 2. [전문가_시스템과_규칙_기반_에이전트](#전문가-시스템과-규칙-기반-에이전트) 3. [머신러닝_시대의_에이전트_발전](#머신러닝-시대의-에이전트-발전) 4. [강화학습_기반_에이전트의_등장](#강화학습-기반-에이전트의-등장) 5. [대규모_언어모델의_혁신](#대규모-언어모델의-혁신) 6. [LLM_기반_에이전트의_탄생과_발전](#llm-기반-에이전트의-탄생과-발전) 7. [에이전트의_미래_전망](#에이전트의-미래-전망) --- ## 1. 초기_AI와_기호주의_접근법 어느 날 김개발 씨가 회사 사내 스터디에서 AI의 역사에 대해 발표하게 되었습니다. "AI는 그냥 최근에 뜬 거 아닌가요?"라는 질문에 정확한 답을 하지 못했던 김개발 씨, 오늘은 제대로 준비해 보려고 합니다. **기호주의(Symbolic AI)**는 인간의 사고를 기호와 규칙으로 표현하려는 초기 AI 접근법입니다. 마치 수학 공식을 풀듯, 정해진 규칙에 따라 기호를 조작하여 문제를 해결합니다. 현대 AI의 뿌리를 이해하는 데 필수적인 개념입니다. 다음 코드를 살펴봅시다. ```python # 기호주의 AI의 핵심: 규칙 기반 추론 class SymbolicReasoner: def __init__(self): # 지식을 규칙으로 정의합니다 self.rules = { "비가 온다": "우산을 가져간다", "온도가 낮다": "겉옷을 입는다", "비가 온다": "장화를 신는다", } def reason(self, situation): # 주어진 상황에 대해 규칙을 적용합니다 actions = [] for condition, action in self.rules.items(): if condition in situation: actions.append(action) return actions # "비가 온다" 상황에서 추론 실행 reasoner = SymbolicReasoner() result = reasoner.reason("오늘 비가 온다") print(result) # ['우산을 가져간다', '장화를 신는다'] ``` "AI 에이전트 완전 정복 - Hello Agents" 코스의 두 번째 카드뉴스에 오신 것을 환영합니다. 지난 첫 번째 카드뉴스에서는 에이전트의 정의와 유형, 그리고 다양한 패러다임을 살펴보았습니다. 이번에는 그 에이전트가 어떤 과정을 거쳐 발전해 왔는지, 역사의 시간선을 따라가 보겠습니다. 김개발 씨는 최근 챗봇과 AI 코딩 도구에 매료되어 "AI는 원래부터 이렇게 똑똑했을까?"라는 궁금증을 품게 되었습니다. 사내 스터디에서 AI 역사 발표를 맡게 된 김개발 씨, 선배 박시니어 씨에게 도움을 청했습니다. 박시니어 씨는 빈 웃음을 지으며 말했습니다. "AI의 역사는 생각보다 훨씬 깁니다. 1950년대로 거슬러 올라가야 해요." 그렇다면 **기호주의**란 정확히 무엇일까요? 쉽게 비유하자면, 기호주의는 마치 **요리 레시피**와 같습니다. "토마토 2개를 썰고, 올리브유를 두르고, 불을 약하게 줄인다"처럼 모든 과정을 정확한 규칙으로 기록해 두는 방식입니다. 이 레시피를 그대로 따르면 누구나 같은 요리를 만들 수 있습니다. 기호주의 AI도 마찬가지입니다. 개발자가 모든 규칙을 미리 정해두면, 컴퓨터는 그 규칙을 기호로 변환하여 논리적으로 문제를 해결합니다. 기호주의가 없던 시절에는 어땠을까요? 물론 기호주의 이전에도 사람들은 "기계가 생각할 수 있을까?"라는 질문을 던졌습니다. 하지만 구체적인 방법론이 없었습니다. 1956년, 다트머스 회의에서 Allan Newell과 Herbert Simon이 **Logic Theorist**를 발표하면서 상황이 바뀝니다. 이 프로그램은 수학적 정리를 스스로 증명하는 데 성공했고, 사람들은 "기계가 논리적으로 생각할 수 있다"는 가능성을 보게 되었습니다. 이후 기호주의는 AI 연구의 주류로 자리 잡았습니다. 연구자들은 지식을 **If-Then 규칙**의 형태로 체계적으로 정리했습니다. "만약 A라면 B다"라는 형태로, 수많은 규칙을 컴퓨터에 입력하면 복잡한 문제도 해결할 수 있다고 믿었습니다. 위의 코드를 한 줄씩 살펴보겠습니다. 먼저 `SymbolicReasoner` 클래스를 정의합니다. 이 클래스는 상황과 행동의 매핑 규칙을 사전 형태로 저장합니다. `reason` 메서드에서는 주어진 상황 문자열에 규칙의 조건이 포함되어 있는지 확인하고, 일치하는 모든 행동을 수집하여 반환합니다. 상황이 "오늘 비가 온다"이고 규칙에 "비가 온다" 조건이 있으므로, 해당 행동들이 순서대로 수집됩니다. 실제 현업에서는 어떻게 활용할까요? 은행의 대출 심사 시스템을 예로 들 수 있습니다. "신용등급이 700 미만이면 대출을 거절한다", "소득이 3천만 원 이상이면 금리를 0.5% 낮춘다"처럼 명확한 비즈니스 규칙이 있는 곳에서 기호주의 접근법은 여전히 유효합니다. 실제로 많은 금융 시스템의 뼈대에는 이런 규칙 기반 엔진이 남아 있습니다. 하지만 주의할 점도 있습니다. 기호주의의 가장 큰 한계는 **모든 상황을 미리 규칙으로 정의해야 한다는 점**입니다. 현실 세계는 너무 복잡해서, 발생할 수 있는 모든 경우의 수를 규칙으로 만들 수 없습니다. 또한 규칙이 많아질수록 규칙 간의 충돌이 발생하고, 시스템을 유지보수하기가 점점 어려워집니다. 이 한계가 훗날 새로운 AI 패러다임을 탄생시키는 계기가 됩니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. 박시니어 씨의 설명을 들은 김개발 씨는 고개를 끄덕였습니다. "그러니까, 초기 AI는 사람이 규칙을 모두 만들어주면 기계가 그것을 따르는 방식이었군요!" 기호주의는 AI의 첫걸음이었습니다. 완벽하지는 않았지만, "기계가 논리적으로 추론할 수 있다"는 것을 증명한 거대한 첫걸음이었습니다. **실전 팁** 💡 - 기호주의는 현실 세계의 복잡성을 모두 규칙으로 표현하기 어렵다는 근본적 한계가 있습니다 - 오늘날에도 규칙이 명확한 도메인(금융, 법률 등)에서는 기호주의적 접근이 유효하게 사용됩니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 2. 전문가_시스템과_규칙_기반_에이전트 김개발 씨가 스터디 준비를 하던 중, 흥미로운 사실을 발견했습니다. 1980년대에 이미 AI가 의사의 진단을 돕는 시스템이 상용화되었다는 것입니다. "그때 이미 그런 게 있었다고요?" 놀란 김개발 씨, 박시니어 씨에게 자세히 물어보기로 했습니다. **전문가 시스템(Expert System)**은 특정 분야 전문가의 지식을 규칙으로 추출하여 컴퓨터에 구현한 시스템입니다. 마치 경험 많은 선배의 머릿속 지식을 그대로 복사해 놓은 것과 같습니다. 기호주의의 한계를 규칙의 양과 질로 극복하려 했던 대표적 시도입니다. 다음 코드를 살펴봅시다. ```python # 전문가 시스템의 핵심: 조건부 규칙 엔진 class MedicalExpertSystem: def __init__(self): self.rules = [ {"conditions": ["발열", "기침"], "confidence": 0.8, "diagnosis": "감기", "advice": "충분한 휴식과 수분 섭취"}, {"conditions": ["발열", "호흡곤란"], "confidence": 0.95, "diagnosis": "폐렴 의심", "advice": "즉시 응급실 방문"}, {"conditions": ["두통", "메스꺼움"], "confidence": 0.7, "diagnosis": "편두통", "advice": "안정을 취하며 경과 관찰"}, ] def diagnose(self, symptoms): results = [] for rule in self.rules: match = all(s in symptoms for s in rule["conditions"]) if match: results.append(rule) # 신뢰도가 높은 순으로 정렬합니다 return sorted(results, key=lambda r: r["confidence"], reverse=True) # 환자 증상으로 진단 수행 doctor = MedicalExpertSystem() result = doctor.diagnose(["발열", "기침", "두통"]) for r in result: print(f"{r['diagnosis']} (신뢰도: {r['confidence']}) - {r['advice']}") ``` 기호주의 AI가 "기계도 생각할 수 있다"는 가능성을 보여준 후, 연구자들은 더 큰 질문을 던졌습니다. "이걸 실제로 쓸 수는 없을까?" 이 질문에 답한 것이 바로 **전문가 시스템**입니다. 1960년대 후반부터 1980년대까지, 전문가 시스템은 AI 실용화의 최전선에 서 있었습니다. 가장 유명한 사례는 **MYCIN**입니다. 스탠퍼드 대학에서 개발된 MYCIN은 감염성 질환을 진단하고 항생제를 처방하는 시스템이었습니다. 의사들의 진단 결과와 비교했을 때, MYCIN의 정확도는 의사들보다 높았다고 합니다. 하지만 "컴퓨터가 사람의 생명을 결정할 수는 없다"는 윤리적 문제로 인해 실제 임상에 투입되지는 못했습니다. 쉽게 비유하자면, 전문가 시스템은 마치 **경력 30년의 요리사가 남긴 레시피 노트**와 같습니다. 초보 요리사가 이 노트를 보면, 경험 많은 요리사와 비슷한 수준의 요리를 만들 수 있습니다. 전문가 시스템도 마찬가지입니다. 분야 전문가가 수십 년간 쌓은 지식을 "규칙"의 형태로 컴퓨터에 입력하면, 그 컴퓨터가 전문가처럼 판단할 수 있습니다. 전문가 시스템의 구조를 살펴보면 크게 세 가지 핵심 요소로 이루어집니다. 첫째, **지식 베이스(Knowledge Base)**입니다. 이것은 전문가의 지식이 저장되는 곳입니다. 의료 전문가 시스템이라면 "발열이 있고 기침이 동반되면 감기일 가능성이 높다" 같은 수천 개의 규칙이 여기에 저장됩니다. 둘째, **추론 엔진(Inference Engine)**입니다. 이것은 지식 베이스의 규칙을 바탕으로 새로운 결론을 도출하는 핵심 모듈입니다. 사용자가 입력한 증상과 규칙을 매칭하여, 가장 적절한 진단을 찾아냅니다. 셋째, **사용자 인터페이스**입니다. 사용자가 증상을 입력하고, 시스템이 진단 결과를 보여주는 창구입니다. 위의 코드를 한 줄씩 살펴보겠습니다. `MedicalExpertSystem` 클래스는 의료 전문가 시스템을 간단히 모방한 것입니다. 각 규칙은 `conditions`(증상 조건), `confidence`(신뢰도), `diagnosis`(진단명), `advice`(조언)로 구성됩니다. `diagnose` 메서드는 환자의 증상이 주어지면, 모든 규칙을 검사하여 조건이 일치하는 결과를 신뢰도 순으로 정렬하여 반환합니다. 실제 현업에서는 어떻게 활용할까요? 1980년대에는 DEC사의 **XCON**이라는 전문가 시스템이 큰 성공을 거두었습니다. XCON은 컴퓨터 주문을 자동으로 구성하는 시스템이었는데, 매년 4천만 달러 이상의 비용을 절감했습니다. 이 성공으로 전문가 시스템 시장은 폭발적으로 성장했고, 수많은 기업이 도입을 시도했습니다. 하지만 주의할 점도 있습니다. 전문가 시스템의 치명적인 한계는 **지식 획득의 병목**이었습니다. 전문가의 머릿속 지식을 규칙으로 추출하는 과정이 생각보다 훨씬 어려웠습니다. 전문가들은 자신이 어떻게 판단하는지 명확히 설명하지 못하는 경우가 많았고, "알 수 없지만 경험적으로 알고 있다"는 암묵지를 규칙으로 변환하는 것은 거의 불가능에 가까웠습니다. 또한 규칙이 수천 개를 넘어가면 관리가 불가능해지고, 예상치 못한 상황에는 전혀 대처하지 못하는 **취약성**이 드러났습니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. 박시니어 씨는 말했습니다. "전문가 시스템은 규칙만으로는 한계가 있다는 것을 보여준 중요한 교훈이에요. 사람의 지식을 모두 규칙으로 표현할 수 없다는 걸 깨닫게 해주었죠." 김개발 씨는 노트에 적었습니다. "규칙 기반 접근의 한계를 극복하려면, 기계가 스스로 학습해야 한다." 이 문장은 다음 단계로 향하는 열쇠가 됩니다. **실전 팁** 💡 - 전문가 시스템은 지식 획득 병목(Knowledge Acquisition Bottleneck)이라는 근본적 한계를 가집니다 - 규칙이 많아질수록 유지보수가 어려워지며, 예상치 못한 상황에 대처하지 못합니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 3. 머신러닝_시대의_에이전트_발전 김개발 씨는 스터디에서 전문가 시스템의 한계를 발표한 후, 팀원에게 이런 질문을 받았습니다. "그럼 규칙을 사람이 만들지 말고, 기계가 스스로 배우게 하면 되지 않을까요?" 김개발 씨는 이 질문이 사실 다음 시대의 문을 여는 열쇠라는 것을 곧 알게 됩니다. **머신러닝(Machine Learning)**은 데이터에서 스스로 패턴을 학습하여 문제를 해결하는 접근법입니다. 마치 아이가 수많은 고양이 사진을 보며 "이게 고양이구나"라고 스스로 깨닫는 것과 같습니다. 규칙을 사람이 직접 만들던 기호주의의 한계를 극복한 혁명적 전환입니다. 다음 코드를 살펴봅시다. ```python # 머신러닝의 핵심: 데이터에서 패턴 학습하기 from sklearn.linear_model import Perceptron from sklearn.model_selection import train_test_split # 에이전트 행동 데이터 준비합니다 # 특성: [사용자 감정(0=부정,1=긍정), 질문 복잡도(0-10), 이전 대화 수] X = [ [0, 2, 1], [0, 3, 2], [0, 1, 1], # 부정 감정 [1, 5, 3], [1, 8, 5], [1, 4, 2], # 긍정 감정 [0, 7, 4], [1, 9, 6], [0, 6, 3], # 혼합 상황 ] # 정답: 0=단순 응답, 1=상세 응답 y = [0, 0, 0, 1, 1, 0, 1, 1, 1] # 데이터를 학습용과 테스트용으로 분리합니다 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 퍼셉트론 모델로 학습합니다 model = Perceptron(max_iter=1000) model.fit(X_train, y_train) # 새로운 상황에서 에이전트 응답 예측 prediction = model.predict([[1, 7, 4]]) # 긍정, 복잡, 대화 경험 있음 print(f"예측 응답: {'상세 응답' if prediction[0] == 1 else '단순 응답'}") ``` 전문가 시스템이 "사람이 규칙을 만든다"는 방식의 한계에 부딪혔을 때, 연구자들은 근본적으로 다른 접근을 고민하기 시작했습니다. "만약 컴퓨터가 스스로 규칙을 발견하게 한다면 어떨까?" 이 아이디어가 바로 **머신러닝**의 핵심입니다. 1950년대 Arthur Samuel이 "기계가 스스로 학습할 수 있도록 하는 연구 분야"라고 정의한 이 개념은, 수십 년의 침체기를 거친 후 2000년대와 2010년대에 폭발적인 성장을 이룩합니다. 쉽게 비유하자면, 머신러닝은 마치 **아이가 자전거 타는 법을 배우는 과정**과 같습니다. 부모가 "왼쪽 페달을 밟고, 오른쪽 핸들을 15도 꺾고..."라고 규칙을 일일이 가르치는 것이 아닙니다. 아이는 넘어지고 다시 일어서는 과정을 반복하면서, 자신만의 규칙을 몸으로 체득합니다. 머신러닝도 마찬가지입니다. 수많은 데이터를 경험하면서, 데이터 속에 숨겨진 패턴을 스스로 발견합니다. 머신러닝이 에이전트 발전에 미친 영향은 결정적이었습니다. 기존의 규칙 기반 에이전트는 "사용자가 X라고 말하면 Y라고 응답한다"는 식의 고정 규칙만 따랐습니다. 하지만 머신러닝 기반 에이전트는 사용자의 행동 패턴, 선호도, 맥락을 데이터에서 학습하여 **점점 더 똑똑해지는** 것이 가능해졌습니다. 머신러닝의 발전을 이끈 세 가지 핵심 요소가 있습니다. 첫째, **데이터의 폭발적 증가**입니다. 인터넷의 보급으로 학습에 사용할 데이터가 기하급수적으로 늘어났습니다. 1990년대에 수천 개였던 데이터 포인트는 2010년대에 수십억 개로 증가했습니다. 둘째, **컴퓨팅 파워의 향상**입니다. 특히 GPU(그래픽 처리 장치)가 병렬 연산에 탁월한 성능을 발휘하면서, 대규모 데이터를 빠르게 처리할 수 있게 되었습니다. 셋째, **알고리즘의 발전**입니다. 신경망(Neural Network)을 기반으로 한 **딥러닝(Deep Learning)**이 등장하면서, 이미지 인식, 음성 인식, 자연어 처리 등에서 인간 수준 이상의 성능을 보이기 시작했습니다. 위의 코드를 한 줄씩 살펴보겠습니다. 먼저 에이전트의 행동을 결정하는 특성 데이터를 준비합니다. 사용자 감정, 질문 복잡도, 이전 대화 수를 특성으로 사용하고, 단순 응답과 상세 응답을 분류하는 문제를 설정합니다. `train_test_split`으로 데이터를 분리한 후, `Perceptron` 모델에 학습 데이터를 입력합니다. 학습이 완료되면 새로운 상황에 대해 에이전트가 어떤 응답을 선택할지 예측할 수 있습니다. 실제 현업에서는 어떻게 활용할까요? 추천 시스템이 대표적입니다. 넷플릭스, 유튜브, 아마존의 추천 시스템은 머신러닝을 기반으로 합니다. 사용자의 시청 기록, 클릭 패턴, 체류 시간 등의 데이터를 학습하여 "이 사용자에게 이 콘텐츠를 추천하면 좋겠다"고 예측합니다. 이것은 사실상 매우 정교한 형태의 에이전트입니다. 사용자의 행동을 관찰하고, 패턴을 학습하며, 최적의 행동을 선택하는 것이죠. 하지만 주의할 점도 있습니다. 머신러닝 모델은 **학습 데이터의 품질에 크게 의존**합니다. 편향된 데이터로 학습하면 편향된 결과를 내놓습니다. 또한 모델이 어떻게 결정을 내렸는지 설명하기 어렵다는 **블랙박스 문제**가 있습니다. 의료나 법률 같은 분야에서는 이 설명 가능성(Explainability)이 매우 중요한데, 이 문제는 아직도 활발한 연구 주제입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. "그러니까, 전문가 시스템은 사람이 규칙을 만들고, 머신러닝은 기계가 데이터에서 규칙을 발견하는 거군요!" 김개발 씨의 눈이 반짝였습니다. 박시니어 씨는 고개를 끄덕이며 덧붙였습니다. "맞아요. 그리고 이 발전은 더 큰 도약, 바로 에이전트가 환경과 직접 상호작용하며 학습하는 방식으로 이어집니다." **실전 팁** 💡 - 머신러닝은 "규칙을 프로그래밍"하는 것이 아니라 "데이터에서 규칙을 학습"하는 패러다임 전환입니다 - 데이터의 질과 양이 모델의 성능을 결정하므로, 데이터 수집과 전처리가 가장 중요합니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 4. 강화학습_기반_에이전트의_등장 김개발 씨가 최근 알파고에 대한 다큐멘터리를 보았습니다. "기계가 어떻게 바둑 기사를 이길 수 있었을까요?" 이 질문의 답은 단순히 "더 많이 계산해서"가 아니었습니다. 핵심은 에이전트가 환경과 상호작용하며 스스로 전략을 학습하는 **강화학습**에 있었습니다. **강화학습(Reinforcement Learning)**은 에이전트가 환경과 상호작용하며 보상을 최대화하는 행동 전략을 스스로 학습하는 방법입니다. 마치 강아지가 간식을 보상받으며 명령을 배우는 것과 같습니다. 에이전트가 자율적으로 의사결정을 내리는 능력의 핵심입니다. 다음 코드를 살펴봅시다. ```python # 강화학습의 핵심: Q-Learning으로 미로 탈출 에이전트 import numpy as np # 4x4 미로 환경을 정의합니다 (0=빈칸, 1=장애물, 2=목표) maze = np.array([ [0, 0, 0, 0], [0, 1, 0, 1], [0, 0, 0, 0], [1, 0, 2, 0], ]) # Q-테이블 초기화: 상태(16) x 행동(상하좌우) q_table = np.zeros((16, 4)) # 학습 파라미터 learning_rate = 0.1 discount = 0.95 epsilon = 0.1 # 탐험 확률 def get_reward(state): row, col = divmod(state, 4) if maze[row][col] == 2: return 100 # 목표 도달 보상 if maze[row][col] == 1: return -50 # 장애물 충돌 페널티 return -1 # 한 걸음 이동 비용 # 에이전트가 미로를 탐험하며 학습합니다 for episode in range(500): state = 0 # 시작 위치 for step in range(50): # epsilon-greedy: 무작위 탐험 vs 경험 활용 if np.random.random() < epsilon: action = np.random.randint(4) else: action = np.argmax(q_table[state]) # Q-값 업데이트: 미래 보상을 고려하여 학습합니다 next_state = (state + [4, -4, 1, -1][action]) % 16 reward = get_reward(next_state) best_next = np.max(q_table[next_state]) q_table[state][action] += learning_rate * ( reward + discount * best_next - q_table[state][action] ) state = next_state if reward == 100: break print("학습 완료! 최적 Q-값 경로가 형성되었습니다.") ``` 머신러닝이 "데이터에서 패턴을 발견"하는 능력을 부여했다면, **강화학습**은 에이전트에게 "행동하고 그 결과를 통해 배우는" 능력을 부여했습니다. 이것은 에이전트 발전사에서 매우 중요한 전환점입니다. 강화학습의 아이디어는 놀라울 정도로 직관적입니다. 심리학의 **행동주의**에서 영감을 받았는데, "좋은 행동에는 보상을, 나쁜 행동에는 벌을" 주면 개체가 최적의 행동을 학습한다는 원리입니다. 쉽게 비유하자면, 강화학습은 마치 **비디오 게임을 처음 하는 사람**과 같습니다. 처음에는 버튼을 아무렇게나 누르다가, 점수가 올라가는 버튼 조합을 발견하고, 더 높은 점수를 위해 전략을 수정합니다. 죽으면(벌), 다른 방법을 시도하고, 클리어하면(보상), 그 방법을 기억합니다. 강화학습 에이전트도 똑같은 방식으로 학습합니다. 강화학습의 핵심 구조를 이해하려면 **MDP(Markov Decision Process)**라는 개념을 알아야 합니다. MDP는 다섯 가지 요소로 구성됩니다. **상태(State)**는 에이전트가 현재 처한 상황입니다. **행동(Action)**은 에이전트가 선택할 수 있는 행동입니다. **전이(Transition)**는 행동에 따라 상태가 어떻게 변하는지를 나타냅니다. **보상(Reward)**은 행동의 결과로 얻는 점수입니다. 그리고 **할인율(Discount Factor)**은 미래의 보상을 현재 가치로 환산하는 비율입니다. 위의 코드를 한 줄씩 살펴보겠습니다. 먼저 4x4 미로 환경을 정의합니다. 빈칸, 장애물, 목표 지점으로 구성된 미로에서 에이전트는 목표를 찾아야 합니다. `q_table`은 각 상태에서 각 행동의 가치를 저장하는 표입니다. 학습 과정에서 에이전트는 `epsilon-greedy` 전략을 사용합니다. 10%의 확률로 무작위 행동을 하여 새로운 경로를 탐험하고, 90%의 확률로 현재까지 배운 최적의 행동을 선택합니다. Q-값 업데이트 공식은 "현재 보상 + 미래 보상의 예상값 - 현재 Q-값" 만큼 Q-값을 조정합니다. 2016년, **알파고(AlphaGo)**가 이 세상에 등장했습니다. DeepMind가 개발한 알파고는 강화학습과 딥러닝을 결합하여 바둑의 세계 챔피언 이세돌을 4대1로 이겼습니다. 바둑은 경우의 수가 우주의 원자 수보다 많다고 알려진 게임입니다. 전문가 시스템으로는 도저히 해결할 수 없는 문제였습니다. 알파고는 수천만 번의 자기 대국을 통해, 인간이 수천 년간 발견하지 못한 새로운 수를 찾아냈습니다. 이후 알파고의 후속작인 **AlphaZero**는 인간의 바둑 기보를 전혀 학습하지 않고, 오직 강화학습만으로 바둑, 체스, 장기의 최고 수준에 도달했습니다. 이것은 "기계가 스스로 세상의 규칙을 발견할 수 있다"는 것을 입증한 상징적 사건입니다. 실제 현업에서는 어떻게 활용할까요? 자율주행 자동차가 대표적입니다. 자율주행 에이전트는 도로 환경(상태)을 인식하고, 조향과 속도 제어(행동)를 결정하며, 안전 운전(보상)을 최대화하도록 학습합니다. 또한 로봇 공학에서 로봇이 물체를 잡고 옮기는 행동을 강화학습으로 학습하고, 데이터센터에서는 전력 소모를 최소화하는 냉각 시스템을 강화학습으로 최적화합니다. 하지만 주의할 점도 있습니다. 강화학습의 가장 큰 문제는 **보상 설계(Reward Design)**입니다. 에이전트는 우리가 원하는 것이 아니라, 우리가 정해준 보상을 최대화합니다. 보상을 잘못 설정하면 예상치 못한 행동을 학습합니다. 예를 들어, "코인을 많이 먹어라"라는 보상을 준 게임 에이전트가 코인 바로 앞에서 죽었다가 부활하여 코인을 다시 먹는 행동을 반복한 사례도 있습니다. 이를 **보상 해킹(Reward Hacking)**이라고 부릅니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. "에이전트가 환경과 상호작용하며 스스로 학습한다니, 정말 놀랍네요!" 김개발 씨는 스터디 발표 자료에 이 문장을 크게 적었습니다. "강화학습은 에이전트가 자율적으로 행동할 수 있게 해준 핵심 기술이다." 박시니어 씨가 말했습니다. "하지만 강화학습 에이전트도 한계가 있어요. 미리 정해진 환경에서는 훌륭하지만, 복잡한 언어나 추론이 필요한 상황에서는 부족했죠. 그리고 그 한계를 깨뜨린 것이 바로..." **실전 팁** 💡 - 강화학습에서는 보상 설계가 가장 중요합니다. 잘못된 보상은 보상 해킹이라는 의도치 않은 결과를 낳습니다 - 탐험(Exploration)과 활용(Exploitation)의 균형을 맞추는 것이 강화학습 에이전트의 핵심 딜레마입니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 5. 대규모_언어모델의_혁신 김개발 씨의 팀에 새로운 AI 비서가 도입되었습니다. "이 코드를 리뷰해 줘", "이 버그의 원인을 분석해 줘"라고 말하면 마치 팀원처럼 정확한 답변을 돌려줍니다. 김개발 씨는 이 기술의 정체가 궁금해졌습니다. "이게 어떻게 가능한 거죠?" 박시니어 씨의 답은 짧았습니다. "LLM이에요." **대규모 언어모델(LLM, Large Language Model)**은 수조 개의 파라미터로 학습된 거대한 신경망으로, 인간의 언어를 이해하고 생성하는 능력을 갖춘 모델입니다. 마치 전 세계의 책을 읽고 요약한 초지식 인재와 같습니다. AI 에이전트의 뇌 역할을 하는 혁신적 기술입니다. 다음 코드를 살펴봅시다. ```python # LLM 기반 에이전트의 핵심: 프롬프트로 행동 제어하기 import openai def create_agent_response(user_message, system_context): """LLM을 에이전트의 두뇌로 사용합니다""" response = openai.chat.completions.create( model="gpt-4", messages=[ {"role": "system", "content": system_context}, {"role": "user", "content": user_message}, ], temperature=0.7, ) return response.choices[0].message.content # 에이전트의 페르소나와 행동 규칙을 정의합니다 AGENT_CONTEXT = """ 당신은 친절한 코딩 멘토 에이전트입니다. 사용자의 질문에 코드 예제를 포함하여 답변하세요. 초보자도 이해할 수 있도록 쉽게 설명하세요. """ # 사용자 질문에 에이전트가 응답합니다 question = "Python에서 리스트와 튜플의 차이점이 뭔가요?" answer = create_agent_response(question, AGENT_CONTEXT) print(answer) ``` 2017년, Google의 연구팀이 **"Attention is All You Need"**라는 논문을 발표했습니다. 이 논문에서 제안한 **Transformer** 아키텍처는 AI 역사상 가장 중요한 발명 중 하나로 꼽힙니다. 그리고 이 Transformer를 기반으로 탄생한 것이 바로 **대규모 언어모델(LLM)**입니다. 이전까지의 언어 모델은 문장을 단어 순서대로 처리했습니다. 하지만 Transformer는 **Self-Attention**이라는 메커니즘을 사용하여, 문장의 모든 단어를 동시에 보고 단어 간의 관계를 파악합니다. "나는 사과를 좋아하고, 바나나도 좋아한다"라는 문장에서 "나는"이 "좋아한다"와 어떤 관계인지, "사과"와 "바나나"가 왜 같은 범주인지를 한 번에 파악합니다. 쉽게 비유하자면, LLM은 마치 **전 세계 도서관의 책을 모두 읽은 초지식 인재**와 같습니다. 어떤 질문을 해도, 수십억 권의 책에서 관련 지식을 찾아내어 자연스러운 문장으로 답변합니다. 단순히 정보를 검색하는 것이 아니라, 맥락을 이해하고 추론하며, 새로운 문장을 생성합니다. LLM의 발전을 이끈 핵심 원리는 **Scale Law(스케일 법칙)**입니다. OpenAI의 연구에 따르면, 모델의 파라미터 수, 학습 데이터의 크기, 컴퓨팅 파워를 늘리면 모델의 성능이 예측 가능하게 향상합니다. 2018년 GPT-1은 1억 1천만 개의 파라미터를 가졌고, 2019년 GPT-2는 15억 개, 2020년 GPT-3는 1,750억 개로 증가했습니다. 이 스케일업은 **부작용 없는 성능 향상(Emergent Abilities)**이라는 놀라운 현상을 낳았습니다. 작은 모델에서는 전혀 할 수 없었던 번역, 요약, 코딩 같은 능력이, 모델이 일정 크기를 넘어서면 갑자기 나타나는 것입니다. 위의 코드를 한 줄씩 살펴보겠습니다. `create_agent_response` 함수는 LLM API를 호출하여 에이전트의 응답을 생성합니다. 핵심은 **system context**입니다. 시스템 메시지에 에이전트의 역할, 행동 규칙, 응답 스타일을 정의하면, LLM이 그 페르소나를 따라 응답합니다. 사용자의 질문이 들어오면, LLM은 시스템 컨텍스트와 사용자 질문을 함께 고려하여 적절한 답변을 생성합니다. `temperature`는 응답의 다양성을 조절하는 파라미터로, 낮을수록 결정적이고 높을수록 창의적인 응답을 만듭니다. LLM이 에이전트에 가져온 변화는 혁명적이었습니다. 이전의 에이전트는 미리 정의된 규칙이나 제한된 환경에서만 동작했습니다. 하지만 LLM 기반 에이전트는 **자연어**로 지시만 하면 어떤 작업이든 수행할 수 있습니다. "이메일을 작성해 줘", "코드를 리뷰해 줘", "데이터를 분석해 줘"처럼 사람의 언어로 명령하면, LLM이 그 의도를 이해하고 적절한 행동을 선택합니다. 하지만 주의할 점도 있습니다. LLM은 **환각(Hallucination)** 현상을 보입니다. 자신 있는 어조로 사실이 아닌 정보를 말하는 것입니다. 또한 수학적 계산이나 논리적 추론에서 오류를 범할 수 있습니다. 최신 정보에 접근할 수 없다는 점도 한계입니다. 이런 한계를 극복하기 위해 **RAG(Retrieval-Augmented Generation)**, **Chain-of-Thought** 같은 기법이 개발되었고, 이것은 다음 카드에서 다룰 LLM 기반 에이전트의 핵심 기술이 됩니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. "LLM이 에이전트의 두뇌 역할을 한다고요? 그러면 LLM에 도구를 연결하면 진짜 뭔가를 할 수 있는 에이전트가 되는 건가요?" 박시니어 씨가 빛나는 눈으로 대답했습니다. "정확해요. 그게 바로 LLM 기반 에이전트의 핵심이에요." **실전 팁** 💡 - LLM의 성능은 모델 크기와 학습 데이터 규모에 비례하여 향상하는 스케일 법칙을 따릅니다 - 환각 현상을 방지하려면 RAG나 체인 오브 생각 같은 기법을 활용하는 것이 좋습니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 6. LLM_기반_에이전트의_탄생과_발전 김개발 씨의 팀에서 주목하는 프로젝트가 하나 있습니다. "LLM이 직접 웹 검색을 하고, 코드를 실행하고, 이메일까지 보내는 에이전트를 만들 수 없을까?" 이 아이디어는 단순한 상상이 아니었습니다. 2023년 이후, 전 세계의 개발자들이 바로 이것을 현실로 만들고 있었습니다. **LLM 기반 에이전트**는 대규모 언어모델을 두뇌로 삼고, 외부 도구와 API를 활용하여 복잡한 작업을 자율적으로 수행하는 시스템입니다. 마치 똑똑한 비서에게 도구 사용법을 알려주면 스스로 업무를 처리하는 것과 같습니다. AI 에이전트의 궁극적 형태에 가장 가까운 패러다임입니다. 다음 코드를 살펴봅시다. ```python # LLM 기반 에이전트: 도구 사용과 추론 루프 import json class ToolUsingAgent: def __init__(self, llm_client, tools): self.llm = llm_client self.tools = tools # 사용 가능한 도구 목록 def run(self, task, max_steps=5): messages = [{"role": "user", "content": task}] for step in range(max_steps): # LLM이 다음 행동을 결정합니다 response = self.llm.chat(messages) thought = response.get("thought", "") if "최종 답변" in thought: return response["answer"] # 도구 호출이 필요한 경우 실행합니다 if "도구" in response: tool_name = response["tool_name"] tool_input = response["tool_input"] # 에이전트가 도구를 사용하여 환경과 상호작용합니다 result = self.tools[tool_name](**tool_input) messages.append({ "role": "assistant", "content": f"생각: {thought}\n도구 사용: {tool_name}" }) messages.append({ "role": "tool", "content": f"결과: {json.dumps(result, ensure_ascii=False)}" }) return "최대 단계 수에 도달했습니다." # 도구 정의: 에이전트가 사용할 수 있는 능력 tools = { "search": lambda query: {"results": [f"{query} 관련 검색 결과"]}, "calculate": lambda expr: {"result": eval(expr)}, } # 에이전트에게 복잡한 작업을 맡깁니다 agent = ToolUsingAgent(llm_client=None, tools=tools) ``` LLM이 언어를 이해하고 생성할 수 있다는 것을 알게 된 후, 연구자들은 자연스럽게 다음 질문을 던졌습니다. "이 언어 이해 능력을 활용해 에이전트를 만들 수 있다면?" 2022년 말 ChatGPT가 등장하면서, 이 질문에 대한 답이 현실로 다가왔습니다. LLM이 이전의 어떤 시스템보다도 자연스럽게 인간의 의도를 이해하고, 적절한 응답을 생성하는 능력을 보여주었습니다. 그리고 2023년, 연구자들은 LLM을 **에이전트의 두뇌**로 사용하는 본격적인 시도를 시작했습니다. 이 패러다임의 핵심 아이디어는 간단합니다. LLM은 생각할 줄 아는데, 행동할 수는 없습니다. 그러니까 **도구(Tool)**를 연결해 주자는 것입니다. 검색 엔진, 코드 실행기, 계산기, 데이터베이스, API 같은 도구를 LLM에 연결하면, LLM이 스스로 어떤 도구를 사용할지 결정하고, 도구의 결과를 바탕으로 다음 행동을 계획합니다. 쉽게 비유하자면, LLM 기반 에이전트는 마치 **전화로 지시를 받으며 현장에서 작업하는 프로젝트 매니저**와 같습니다. 본사(사용자)에서 "다음 주 회의 일정을 잡아 줘"라고 전화를 걸면, 프로젝트 매니저는 참석자 일정을 확인하고(도구 사용), 회의실을 예약하고(도구 사용), 초대 이메일을 보내고(도구 사용), 최종적으로 "회의가 예약되었습니다"라고 보고합니다. 가장 영향력 있는 초기 연구 중 하나가 **ReAct(Reasoning + Acting)**입니다. 2022년 Yao 등이 발표한 ReAct는 에이전트가 "생각(Thought)"과 "행동(Action)"을 번갈아 반복하는 프레임워크입니다. 에이전트는 문제를 해결하기 위해 먼저 생각을 정리하고, 필요한 도구를 사용하며, 도구의 결과를 바탕으로 다시 생각을 수정합니다. 이 **추론-행동 루프**는 LLM 기반 에이전트의 기본 패턴이 되었습니다. 2023년에는 더 야심찬 프로젝트들이 등장했습니다. **AutoGPT**는 사용자가 목표만 주면 스스로 작업을 분해하고 실행하는 자율 에이전트를 시도했습니다. **BabyAGI**는 작업 목록을 관리하며 순차적으로 작업을 수행하는 에이전트를 구현했습니다. 이들 프로젝트는 완벽하지는 않았지만, LLM 기반 에이전트의 가능성을 전 세계에 보여주었습니다. 위의 코드를 한 줄씩 살펴보겠습니다. `ToolUsingAgent` 클래스는 LLM 기반 에이전트의 핵심 구조를 보여줍니다. `__init__`에서 LLM 클라이언트와 사용 가능한 도구 목록을 받습니다. `run` 메서드는 추론-행동 루프를 구현합니다. LLM의 응답에 "최종 답변"이 포함되면 작업을 종료하고, "도구"가 필요하면 해당 도구를 실행하여 결과를 메시지 히스토리에 추가합니다. 이 과정을 최대 단계 수만큼 반복하면서 에이전트는 점진적으로 문제를 해결합니다. 실제 현업에서는 어떻게 활용할까요? **LangChain**과 **LlamaIndex** 같은 프레임워크가 이 패러다임을 실용화했습니다. LangChain의 Agent 모듈은 LLM, 도구, 메모리를 쉽게 결합할 수 있는 인터페이스를 제공합니다. 많은 기업에서 고객 지원 챗봇, 문서 분석 시스템, 코드 리뷰 자동화에 이 프레임워크를 활용하고 있습니다. GitHub Copilot도 사실 LLM을 두뇌로 삼고 코드 편집기를 도구로 사용하는 에이전트의 일종입니다. 하지만 주의할 점도 있습니다. LLM 기반 에이전트의 가장 큰 문제는 **안정성**입니다. 동일한 입력에도 다른 도구를 선택하거나, 불필요한 루프에 빠지거나, 환각으로 인해 존재하지 않는 도구를 호출하려는 시도를 합니다. 또한 **비용** 문제도 무시할 수 없습니다. 복잡한 작업을 수행하려면 수십 번의 LLM API 호출이 필요하고, 이는 누적되면 상당한 비용이 됩니다. 에이전트의 행동을 제어하고 안정성을 높이는 것은 현재도 활발한 연구 주제입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. "LLM에 도구를 연결하면 진짜 뭔가를 할 수 있는 에이전트가 되는 거군요!" 김개발 씨의 스터디 노트는 이제 거의 완성되어 가고 있었습니다. 기호주의에서 전문가 시스템, 머신러닝, 강화학습, 그리고 LLM 기반 에이전트까지. AI 에이전트의 발전사가 한눈에 보이는 흐름도가 완성되었습니다. **실전 팁** 💡 - ReAct 패턴(생각-행동-관찰 루프)은 LLM 기반 에이전트의 가장 기본적이고 중요한 패턴입니다 - 에이전트의 안정성을 높이려면 도구 선택 범위를 제한하고, 행동을 검증하는 가드레일을 설치하세요 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- --- ## 7. 에이전트의_미래_전망 김개발 씨의 스터디 발표가 드디어 마무리 단계에 이르렀습니다. "그렇다면, AI 에이전트는 앞으로 어떻게 발전할까요?" 이 마지막 질문에 답하기 위해, 김개발 씨는 최신 연구 동향을 정리하기 시작했습니다. 박시니어 씨가 커피를 내려주며 말했습니다. "미래를 예측하는 가장 좋은 방법은, 현재의 추세를 이해하는 거예요." **AI 에이전트의 미래**는 다중 에이전트 협업, 자율적 의사결정, 도메인 특화 에이전트 등의 방향으로 발전하고 있습니다. 마치 하나의 똑똑한 인재가 아니라, 각자 전문성을 가진 팀이 협업하는 것과 같습니다. 에이전트 생태계의 진화가 가속화되고 있습니다. 다음 코드를 살펴봅시다. ```python # 다중 에이전트 협업 시스템의 기본 구조 class AgentTeam: def __init__(self): # 각 에이전트의 전문 역할을 정의합니다 self.agents = { "planner": {"role": "계획 수립", "task": "작업을 분해합니다"}, "coder": {"role": "코드 작성", "task": "코드를 구현합니다"}, "reviewer": {"role": "코드 리뷰", "task": "코드를 검토합니다"}, "tester": {"role": "테스트 실행", "task": "코드를 테스트합니다"}, } def collaborate(self, user_request): pipeline = ["planner", "coder", "reviewer", "tester"] context = user_request results = {} for agent_name in pipeline: agent = self.agents[agent_name] print(f"[{agent['role']}] {agent['task']}") # 각 에이전트가 이전 결과를 바탕으로 작업합니다 results[agent_name] = f"{agent_name}: {context} 처리 완료" context = results[agent_name] # 리뷰어가 문제를 발견하면 코더에게 되돌려보냅니다 if agent_name == "reviewer" and "수정 필요" in context: print("[피드백] 코더에게 수정을 요청합니다") pipeline_after = ["coder", "reviewer", "tester"] for sub_agent in pipeline_after: sub = self.agents[sub_agent] results[sub_agent] = f"{sub_agent}: 수정 후 재처리" break return results # 팀이 협업하여 사용자 요청을 처리합니다 team = AgentTeam() result = team.collaborate("로그인 API를 만들어 주세요") ``` "AI 에이전트 완전 정복 - Hello Agents" 코스에서 우리는 지금까지 AI 에이전트의 기원부터 LLM 기반 에이전트까지, 발전의 궤적을 따라가 보았습니다. 기호주의에서 시작된 AI의 역사는 전문가 시스템, 머신러닝, 강화학습을 거쳐 LLM 기반 에이전트에 이르기까지 끊임없이 진화해 왔습니다. 이번 카드에서는 에이전트의 미래를 전망해 보겠습니다. 가장 주목받는 방향 중 하나는 **다중 에이전트 시스템(Multi-Agent System)**입니다. 단일 에이전트도 강력하지만, 복잡한 실제 문제를 해결하려면 여러 전문가가 협업해야 합니다. 쉽게 비유하자면, 건축 프로젝트를 생각해 보세요. 설계사가 설계하고, 시공사가 건설하고, 감리사가 검사합니다. 각자의 전문 분야가 다르지만, 협업하면 완성도 높은 건물을 세울 수 있습니다. 다중 에이전트 시스템도 마찬가지입니다. **계획 에이전트**가 작업을 분해하고, **실행 에이전트**가 각 작업을 수행하며, **검토 에이전트**가 결과를 평가하는 식의 분업이 가능합니다. 위의 코드를 한 줄씩 살펴보겠습니다. `AgentTeam` 클래스는 다중 에이전트 협업의 기본 구조를 보여줍니다. 계획자, 코더, 리뷰어, 테스터 네 가지 역할의 에이전트가 순차적으로 작업을 수행합니다. 각 에이전트는 이전 에이전트의 결과를 입력으로 받아 자신의 작업을 수행하고, 그 결과를 다음 에이전트에게 전달합니다. 특히 리뷰어가 문제를 발견하면 코더에게 되돌려보내는 **피드백 루프**가 구현되어 있습니다. 이 패턴은 실제 소프트웨어 개발 프로세스와 유사합니다. 두 번째 방향은 **에이전트의 자율성 향상**입니다. 현재의 LLM 기반 에이전트는 대부분 사람의 지시가 있어야 움직입니다. 하지만 미래의 에이전트는 더 높은 수준의 자율성을 갖출 것입니다. 스스로 목표를 설정하고, 작업을 계획하며, 실행하고, 결과를 평가하는 **자율 루프**를 완성하는 것이 목표입니다. AutoGPT 같은 초기 시도가 보여주듯, 이 방향은 기술적으로 아직 많은 과제가 있지만, 연구 속도는 매우 빠릅니다. 세 번째 방향은 **도메인 특화 에이전트**입니다. 만능 에이전트보다 특정 분야에 최적화된 에이전트가 더 실용적일 수 있습니다. 의료 분야의 진단 에이전트, 법률 분야의 판례 분석 에이전트, 금융 분야의 투자 분석 에이전트처럼, 각 도메인의 깊은 지식과 전문 도구를 갖춘 에이전트들이 등장하고 있습니다. 이런 특화 에이전트들은 **RAG**를 통해 최신 도메인 지식을 활용하고, **MCP(Model Context Protocol)** 같은 표준 프로토콜로 다른 시스템과 통신합니다. 네 번째 방향은 **안전성과 제어 가능성**입니다. 에이전트가 더 강력해질수록, 안전 문제는 더 중요해집니다. 에이전트의 행동을 모니터링하고, 위험한 행동을 차단하고, 인간의 개입이 필요한 시점을 판단하는 **가드레일** 기술이 핵심이 됩니다. 또한 에이전트의 결정 과정을 투명하게 만드는 **설명 가능성(XAI)**도 중요한 연구 방향입니다. 다시 김개발 씨의 이야기로 돌아가 봅시다. 스터디 발표를 마친 김개발 씨는 박수를 받았습니다. "에이전트 발전사를 이렇게 쉽게 정리하다니!" 팀원들의 반응이 좋았습니다. 박시니어 씨가 마지막으로 조언했습니다. "에이전트의 미래를 준비하려면, 지금부터 LLM의 기초를 탄탄히 다져야 해요. 모든 에이전트의 뇌가 되는 건 결국 LLM이니까요." 김개발 씨는 고개를 끄덕이며 다음 스터디 주제를 메모했습니다. "대규모 언어모델(LLM) 기초". 에이전트의 두뇌를 이해하는 여정이 곧 시작됩니다. **실전 팁** 💡 - 다중 에이전트 시스템에서는 에이전트 간의 명확한 역할 분담과 통신 프로토콜 설계가 핵심입니다 - 에이전트의 자율성을 높이면서도 안전성을 유지하는 밸런스가 가장 중요한 연구 과제입니다 - 다음 카드뉴스에서는 "대규모 언어모델(LLM) 기초"를 다룹니다. 에이전트의 두뇌를 이해하는 핵심 편입니다 - 이 카드뉴스는 "AI 에이전트 완전 정복 - Hello Agents" 코스의 2/16편입니다 --- 이상으로 학습을 마칩니다. 위 내용을 직접 코드로 작성해보면서 익혀보세요!

카테고리: AI,Agent,LLM

언어: Python

태그: Python, AIAgent, LLM, SymbolicAI, MachineLearning, AI,Agent,LLM

작성자: AI Generated

프리미엄 콘텐츠 - 3개월 무료 체험 가능

CodeDeck

에이전트 발전사 기호주의에서 LLM까지

목차

1. 초기 AI와 기호주의 접근법

2. 전문가 시스템과 규칙 기반 에이전트

3. 머신러닝 시대의 에이전트 발전

4. 강화학습 기반 에이전트의 등장

5. 대규모 언어모델의 혁신

6. LLM 기반 에이전트의 탄생과 발전

7. 에이전트의 미래 전망

이 카드뉴스가 포함된 코스

AI 에이전트 완전 정복 - Hello Agents

댓글 (0)

함께 보면 좋은 카드 뉴스

에이전트 클래식 패러다임 구현 완벽 가이드

Value Embeddings 완벽 분석 ResFormer 아키텍처

Flash Attention 3과 Rotary Embeddings 완벽 분석

GPT 모델 아키텍처 완벽 분석 - CausalSelfAttention부터 GPT까지

AutoResearch 개요 AI 자율 연구 에이전트 완벽 가이드