잠자는 동안에도 일하는 AI 에이전트 만들기

Adam Lucek 구독자 20,200명

요약

이 영상에서는 딥 에이전트(Deep Agents)라는 언어 모델 기반 에이전트 시스템을 살펴봅니다. 딥 에이전트는 상세한 시스템 프롬프트, To-do 리스트 도구, 퍼시스턴트 파일 시스템, 동적 서브 에이전트 네 가지 요소로 구성되어 장기 과제를 효과적으로 수행합니다. 이어서 LangChain Deep Agents 패키지를 활용해 경쟁사 분석용 딥 에이전트를 설계·구축하고, 35분 만에 Linear과 Asana를 비교한 상세 보고서를 자동 생성하는 과정을 시연합니다. 이 과정을 통해 딥 에이전트가 복잡한 워크플로우를 자동화해 생산성을 극대화하는 방식을 제시합니다.

주요 키워드

Deep Agent System Prompt Few-shot Prompting Planning Tool Context Management Sub-Agent Long-Horizon Task Pseudo File System LangChain Deep Agents package

하이라이트

🔑 딥 에이전트는 단순한 한두 단계 작업을 넘어 수십 분~시간 단위의 장기 과제(long-horizon tasks)를 처리하도록 설계됐다.
⚡️ 수백 줄에 달하는 상세하고 명확한 시스템 프롬프트(system prompt)가 모델의 톤, 스타일, 행동과 도구 사용 방식을 정교히 안내한다.
🌟 To-do 리스트 도구(planning tool)를 통해 모델이 초기 계획을 상시 참조·갱신해 대화 흐름에서 목표를 잃지 않도록 한다.
📌 가짜 파일 시스템(pseudo file system)을 활용해 컨텍스트를 파일 단위로 압축·관리하고, 필요할 때만 불러와 대규모 토큰 소모를 방지한다.
🚀 서브 에이전트(sub-agents)를 동적으로 생성해 전문화된 소단위 작업을 병렬 처리함으로써 모듈화, 효율성, 전문성을 높인다.
💡 LangChain Deep Agents 패키지로 직접 구축한 경쟁사 분석 에이전트는 35분 실행에 7백만 토큰, 287회 웹 검색을 거쳐 Linear와 Asana 보고서를 완벽 생성했다.

용어 설명

Deep Agent

장기 과제 처리에 특화된 언어 모델 기반의 에이전트 시스템

System Prompt

에이전트의 역할·스타일·행동·도구 사용 방식을 수백 줄로 구체 정의한 초기 지침

Few-shot Prompting

모델에 특정 행동 예시를 몇 개 제공해 원하는 출력을 유도하는 기법

Planning Tool

에이전트가 실행해야 할 단계별 작업 목록(To-do 리스트)을 관리·갱신하는 메커니즘

Pseudo File System

파일 생성·수정·검색 기능으로 대화 컨텍스트를 외부에 저장·재사용하는 구조

Sub-Agent

메인 에이전트가 동적으로 호출해 특정 소작업을 수행하는 독립 실행형 에이전트

Long-Horizon Task

여러 단계와 긴 시간을 필요로 하는 복잡한 업무 또는 과제

LangChain Deep Agents

LangChain 커뮤니티가 제공하는 딥 에이전트 구축용 오픈소스 패키지

딥 에이전트가 무엇인지 정의하고, 언어 모델 기반 시스템이 간단한 텍스트 변환을 넘어 장기 과제를 처리하도록 진화하는 맥락을 설명한다.

[00:00] 아담 러스크가 딥 에이전트(장기적 작업을 수행하는 언어모델 기반 에이전틱 시스템)에 대해 소개하며, 구글의 딥 리서치에서 시작되어 ChatGPT, Claude 등 다양한 AI 애플리케이션으로 확산된 기술임을 설명합니다.

[00:29] 장기적 작업(long horizon tasks)의 정의를 설명하며, 1-2분 이상의 시간에 걸쳐 여러 단계를 요구하는 복잡한 작업을 의미한다고 합니다. 이는 언어모델 애플리케이션 발전의 자연스러운 진화 과정이라고 강조합니다.

[01:13] 언어모델이 인간의 디지털 작업 방식을 모방하도록 설계되는 과정을 설명하며, 초기에는 위키피디아 검색, 단어 카운팅 같은 간단한 작업에서 시작하여 점차 알고리즘 데이터 중복 제거, Docker 컨테이너 구성 같은 복잡한 작업으로 발전했다고 합니다.

[02:38] 딥 에이전트의 최종 목표는 언어모델의 지능을 활용해 점점 더 어려운 작업을 자동화하는 것이며, 시간이 지나며 이런 장기 실행 에이전틱 시스템 개발에 공통적인 접근 방식이 나타났다고 설명합니다.

[03:03] 딥 에이전트의 네 가지 핵심 특징을 설명합니다: 상세한 시스템 프롬프트, 계획 도구, 파일 시스템, 하위 에이전트 사용. 이후 경쟁사 분석용 딥 에이전트를 직접 구축해볼 예정입니다.

딥 에이전트의 네 가지 특징—상세한 시스템 프롬프트, 계획 도구, 파일 시스템 기반 컨텍스트 관리, 서브 에이전트—를 전체 흐름에서 개괄한다.

[03:50] 딥 에이전트 시스템의 첫 번째 구성 요소인 시스템 프롬프트를 살펴봅니다. 장기 실행 에이전트일수록 더 상세하고 정교한 시스템 프롬프트를 가지고 있다는 특징을 확인했습니다.

수백 줄로 구성된 정교한 프롬프트 작성법, few-shot 예시 활용, 톤·스타일·가치관 정의, 도구 사용 지침 및 좋은/나쁜 예시를 통한 모범 사례를 다룬다.

[04:09] Claude Code의 시스템 프롬프트 사례를 통해 실제 구현을 분석합니다. 약 191줄의 기본 프롬프트에 도구 설명까지 포함하면 수백 줄에 이르는 상세한 구성을 보여줍니다.

[04:59] 프롬프팅의 중요성을 강조하며, 언어 모델에게 더 구체적이고 상세한 지시를 제공할수록 더 나은 결과를 얻을 수 있다고 설명합니다. 퓨샷 프롬프팅 기법과 의사 예제 활용 방법도 소개합니다.

[05:55] 행동 참조 플레이스홀더의 활용과 매우 구체적인 퓨샷 프롬프팅의 단점에 대해 설명합니다. 언어 모델이 예제를 너무 정확히 모방하는 경향이 있다는 문제점을 지적합니다.

[06:07] 언어 모델이 예시를 정확히 모방하는 경향에 대해 설명하며, 예시를 느슨하게 유지하고 미래 행동을 참조하여 원하는 상호작용을 보여주는 것이 더 나은 결과를 제공한다고 언급합니다.

[06:25] 시스템 프롬프트에 스타일과 가치 요소들이 포함되는 것의 중요성을 설명합니다. 매니저 시스템의 예시를 들며 투명성, 지속적 개선, 정확성, 소통 스타일 등의 가치들을 언급합니다.

[06:43] 에이전트가 단순한 기술적 도구나 특정 실행 예시가 아니라 다양한 특성들을 통해 안내받는 것이 효과적인 작업 수행에 필요한 개성을 부여한다고 설명합니다.

[06:59] 개별화된 프롬프트의 중요성을 강조하며 Cursor 에이전트의 코드 스타일 가이드 예시를 제시합니다. 인간 검토를 고려한 높은 가독성, 정적 타입 언어 사용 등의 구체적인 지침들을 소개합니다.

[07:30] 효과적인 프롬프트 작성의 네 가지 모범 사례를 제시합니다. 프롬프트가 명확하고 체계적이면 길고 복잡해도 괜찮으며, 시스템 프롬프트가 일반적인 프롬프트보다 훨씬 클 수 있다고 설명합니다.

[08:11] 명확한 계층 구조의 중요성을 설명하며, 에이전트 소개, 톤과 행동 설정, 기능 설명의 순서로 구성하는 것과 XML 태그 사용의 지속적인 활용에 대해 언급합니다.

[08:33] 퓨샷 프롬프팅의 효과에 대해 설명하며, 정확한 예시보다는 행동의 일반적 개요와 미래 행동 참조가 더 유용하다고 강조합니다. 인터넷 문화의 별표 스타일과의 유사성을 지적하며 너무 구체적이지 않은 것의 중요성을 언급합니다.

[09:24] 특정한 프롬프트가 역효과를 낼 수 있으며, 모델이 모든 시나리오에서 정확히 모방하게 될 수 있다. 이는 툴링에서 더욱 중요하게 작용한다.

[09:33] 시스템 프롬프트에서는 읽기 어렵지만, 언제 왜 툴을 사용해야 하는지에 대한 다양한 시나리오를 보여주는 자세한 주석이 달린 툴들이 거의 모든 시스템에 깊이 포함되어 있다.

[09:50] 좋은 예시뿐만 아니라 나쁜 예시도 함께 보여주어 더 효과적인 가이드를 제공한다. 프롬프팅은 여전히 감에 의존하며, 중요한 포인트들은 여러 번 반복된다.

[10:14] 여러 회사들은 1인칭 대 3인칭 프롬프팅에 대한 서로 다른 선호도를 보이며, 커서처럼 통일된 프롬프트부터 메나스처럼 자유로운 프롬프트까지 다양한 접근법을 사용한다.

[10:30] 에이전트 시스템을 테스트할 때 여전히 느슨하고 유연한 조직화가 필요하다. 경쟁사 분석 딥 에이전트 프롬프트 예시와 함께 클로드 코드, 커서, 메나스의 링크된 프롬프트들을 확인할 것을 권한다.

To-do 리스트 형식의 계획 도구를 도입해 모델이 초기 계획을 잃지 않도록 주기적으로 참조·업데이트하며, 어텐션 메커니즘을 활용해 목표를 유지하는 방식을 설명한다.

[11:05] 4가지 기능 중 두 번째인 계획 툴에 대해 설명한다. 모든 시스템에서 일관되게 계획 또는 할 일 목록 툴을 포함하고 적극 사용하는 경향이 있다.

[11:21] 모델이 계획을 자주 업데이트하며 필요한 단계와 행동들을 세분화한다. 계획 단계 포함은 새로운 것은 아니지만, 언어 모델의 정확도와 능력을 크게 향상시킨다는 것이 증명되었다.

[11:50] 특정 컨텍스트 트릭이 추가되는데, 작업이 길어지고 복잡해질수록 초기 계획이 대화 진행과 함께 잊히는 경향이 있다는 것이 발견되었다.

[12:11] 이를 해결하기 위해 할 일 목록 툴 사용을 장려하여, 언어 모델이 여러 지점에서 일관되게 참조하고 개선하며 진행상황을 기록할 수 있게 한다.

[12:26] 딥 에이전트가 실행 과정 전반에 걸쳐 현재 목표와 작업들을 대화의 앞쪽으로 끌어올려 컨텍스트를 관리하는 방법을 설명합니다. 지속적으로 해야 할 일과 완료된 일을 참조하고 관찰함으로써 모델이 실제 목표와 계획에 더 잘 맞춰지게 유지합니다.

[12:53] 계획 도구는 실제로 아무것도 하지 않는 순수한 어텐션 메커니즘 활용 트릭이라고 설명합니다. 대부분의 함수들이 API를 호출하거나 행동을 취하는 것과 달리, 이 도구는 단순히 투두리스트를 정의하고 실행 계획을 반복적으로 표면화하는 역할만 합니다.

[13:19] 개인적인 경험을 바탕으로 투두리스트의 중요성을 설명합니다. 상세한 투두리스트를 지속적으로 참고하고 완료된 작업을 체크하는 것이 집중력 유지에 도움이 되며, 이와 동일한 접근 방식이 언어 모델이 주제에 집중하고 작업을 진행하는 데도 효과적임을 강조합니다.

[13:51] 세 번째 핵심 요소인 의사 파일 시스템을 소개합니다. 에이전트가 실행되고 더 많은 작업을 수행할수록 관리해야 할 컨텍스트의 양이 급격히 증가하여 언어 모델의 컨텍스트 윈도우 한계를 쉽게 넘어서게 된다는 문제점을 제기합니다.

가짜 파일 시스템을 통해 파일 생성·쓰기·검색 기능으로 컨텍스트를 외부에 보관하고 필요 시 불러와 대화창 토큰 사용량을 최적화하는 기법을 소개한다.

[14:30] 작업 복잡성 증가와 컨텍스트 관리의 어려움을 구체적 예시로 설명합니다. 코딩 에이전트는 여러 코드 파일을, 리서치 에이전트는 여러 웹사이트를 다뤄야 하므로 로드되는 파일이나 웹사이트가 많아질수록 컨텍스트 양이 빠르게 증가한다고 설명합니다.

[14:58] 컨텍스트 한계 해결 방안으로 파일 시스템에서 영감을 얻은 접근법을 제시합니다. 모든 컨텍스트를 직접 로드하는 대신, 파일 생성, 작성, 편집, 검색 기능을 통해 필요한 정보를 저장하고 참조할 수 있는 방법을 에이전트에게 제공한다고 설명합니다.

[15:37] Deep Agent의 파일 시스템은 컨텍스트를 효율적으로 관리하며, 필요하지 않을 때는 오프로드하되 파일 경로나 고유 식별자를 통해 언어모델이 참조된 내용을 알 수 있도록 합니다.

[16:05] 이 시스템은 압축 가능하고 복원 가능하며 에이전트 실행 전반에 걸쳐 지속되는 고유한 메모리 시스템을 제공합니다.

[16:15] 서브 에이전트는 Deep Agent의 가장 강력한 기능으로, 메인 에이전트가 동적으로 생성하고 특정 작업을 위임할 수 있는 전문화된 에이전트입니다.

메인 에이전트가 함수 호출 형태로 동적·병렬로 서브 에이전트를 생성해 전문화된 작업을 수행하고, 모듈화·효율성·전문화된 결과를 메인으로 반환하는 과정을 다룬다.

[16:36] 메인 Deep Agent는 함수 호출을 통해 서브 에이전트를 지정하고 특정 지시사항을 제공하며, 서브 에이전트는 작업을 완료한 후 결과를 반환합니다.

[17:16] 이는 미리 정의된 에이전트들을 조율하는 감독자 시스템과 다르며, 서브 에이전트들은 필요에 따라 즉석에서 생성되는 서브루틴 방식입니다.

[17:49] 서브 에이전트는 컨텍스트 관리, 모듈성, 전문화, 효율성의 이점을 제공하며, 각각 독립적인 컨텍스트 윈도우에서 작동합니다.

[18:21] 서브 에이전트는 작업을 완전히 격리된 환경에서 수행하고 가장 중요한 컨텍스트만 메인 시스템으로 전달하여 시스템 오염을 방지합니다.

[18:51] 딥 에이전트는 중간 단계들을 추가하지 않고 모듈성과 특수화를 제공한다. 특정 작업에 맞는 서브 에이전트를 정의해서 더 좁은 범위의 프롬프팅과 맞춤형 도구로 성능을 향상시킬 수 있다.

[19:23] 서브 에이전트를 병렬로 호출해서 여러 개가 동시에 여러 작업을 진행할 수 있어 엄청난 효율성 향상을 가져다준다. Anthropic이 Claude에서 서브 에이전트 시스템을 연구하고 통합해왔다.

[19:55] 상세한 시스템 프롬프트, 공통 할 일 목록, 컨텍스트 관리용 파일 시스템, 서브 에이전트 사용 능력이 결합되어 딥 에이전트가 장기간 작업을 수행할 수 있게 한다.

[20:18] 이론을 바탕으로 실제 딥 에이전트를 구축해보자. 경쟁 분석 딥 에이전트 아이디어로, 딥 리서치 에이전트를 경쟁 분석 시나리오에 적용하는 것이다.

LangChain Deep Agents 패키지와 웹 검색 툴을 활용해 Linear와 Asana 비교용 경쟁사 분석 에이전트를 설계·코딩하고, 주요 프롬프트 및 서브 에이전트 설정 방식을 설명한다.

[20:58] 경쟁 분석을 수행하는 딥 에이전트를 만들 예정이다. 회사 연구, 주요 비교, 웹 검색을 통한 정보 수집, 보고서 편집 등의 작업을 수행할 것이다.

[21:20] LangChain Crew의 새로운 Deep Agents 패키지를 사용할 것이다. 이는 놀라운 오픈소스 패키지로, 일반 웹 연구 에이전트 예시도 포함하고 있으며 매우 쉽게 설치할 수 있다.

[22:06] Deep Agents 설치 방법과 Tavily 웹 검색 클라이언트 설정에 대한 기본적인 안내를 제공합니다.

[22:14] 시스템 프롬프트 정의의 중요성을 강조하며, 430줄에 달하는 체계적이고 철저한 경쟁 분석 프롬프트 작성 과정을 소개합니다.

[22:45] 시스템 프롬프트의 구조적 접근법을 설명하며, 시나리오 정의부터 정체성과 행동 방식, 워크플로우까지의 체계적인 구성 방법을 제시합니다.

[23:15] 연구 접근 방식의 구체적인 구조를 설명하며, XML 태그를 활용한 명확한 구분과 회사 프로필, 경쟁 인텔리전스 수집 방법론을 다룹니다.

[23:46] 두 개의 분리된 결과물 파일 구조와 품질 체크리스트의 중요성을 설명하며, 각 섹션별 구체적인 기대사항을 명시합니다.

[24:07] 도구 사용의 좋은 예시와 나쁜 예시를 통한 학습 방법론을 제시하며, 연구 에이전트와 비평 에이전트의 프롬프팅 기법을 설명합니다.

[24:33] 시스템 프롬프트의 완성도를 위한 리마인더 설정과 제약사항 정의, 그리고 연구 과정에서 발생할 수 있는 다양한 도전과제들에 대한 대응 방안을 제시합니다.

[25:03] 하위 에이전트들의 역할 분담을 설명하며, 연구 에이전트의 웹 검색 기능과 구체적인 세분화된 연구 작업 수행 능력을 강조합니다.

[25:23] 딥 에이전트의 구성 요소로 구체적인 연구 작업을 수행하는 연구 서브 에이전트와 보고서를 검토하고 개선사항을 제안하는 비판 에이전트를 포함시켰다고 설명합니다.

[25:32] 연구 서브 에이전트 프롬프트는 Manis의 시스템 프롬프트와 유사하게 핵심 기능, 연구 접근 방식, 구체적인 구조와 정보 깊이, 품질 기준 등을 다루지만 세부 형식은 너무 구체적으로 명시하지 않는다고 합니다.

[26:00] 회사 궤적이나 기능, 역량 같은 특정 항목들에 대해 어떻게 행동하고 무엇을 찾아야 하는지에 대한 구체적 사항들을 제시하며, 응답이 완전하고 독립적이어야 한다고 강조합니다.

[26:20] 에이전트 자체가 구체적인 지시사항과 함께 프롬프트를 제공하며, 이 프롬프트는 서브 연구를 수행하기 위한 지시사항들과 함께 첨부된다고 설명합니다.

[26:34] 비판 서브 에이전트 프롬프트는 경쟁 정보 보고서를 어떻게 비판해야 하는지를 다루며, 서브 연구 에이전트와 유사하게 파일 위치와 맥락 정보를 제공하지만 높은 수준의 비판이 가능하도록 너무 구체적이지 않게 설계했다고 합니다.

[27:07] 딥 에이전트 시스템 설정 작업의 핵심은 프롬프트를 명확하게 정의하는 것이며, 이는 프로젝트와 에이전트에 대한 요구사항과 기대 결과를 정의하는 연습이라고 설명합니다.

[27:25] 딥 에이전트 내에서 정확한 행동과 기능을 명확히 정의하는 것은 성능 향상과 직접적으로 연관되므로 많은 사전 작업이 필요하다고 강조합니다.

[27:41] 함수 형태의 웹 검색 도구를 구축하고, 딥 에이전트 패키지를 사용하여 이름, 설명, 프롬프트, 도구로 구성된 서브 에이전트들을 패키징한 후 메인 프롬프트와 도구와 결합하여 딥 에이전트를 생성한다고 설명합니다.

[28:04] 서브 에이전트들의 설명은 메인 에이전트가 각 서브 에이전트의 기능을 파악할 수 있도록 전달되므로 구체적인 사항을 포함하는 것이 좋다고 합니다.

[28:19] 모든 구성 요소를 Jupyter 노트북이 아닌 별도로 깔끔하게 패키징하며, 경쟁 분석 에이전트로 동일한 디렉토리와 리포지토리에 구성했다고 설명합니다.

[28:34] Langraph 플랫폼용 설정 파일 구성을 설명하며, 모든 코드를 하나로 통합하고 GPT-4 모델을 사용하도록 구성하는 방법을 안내합니다.

[29:07] Deep Agents UI를 사용한 권장 설정 방법을 소개하고, Langraph 서버와 프론트엔드를 함께 실행하여 에이전트와 상호작용할 수 있는 환경을 구축하는 과정을 설명합니다.

[30:14] Linear와 Asana의 경쟁 분석을 요청하는 구체적인 쿼리를 실행하며, 딥 에이전트가 할 일을 생성하고 서브 에이전트들을 병렬로 실행하는 과정을 시연합니다.

[30:52] 35분간 실행된 에이전트의 결과를 분석하며, Linear와 Asana에 대한 완전한 회사 프로필과 경쟁 분석 보고서가 생성되었음을 확인하고, 병렬 작업 처리와 서브 에이전트의 특정 연구 수행 과정을 설명합니다.

35분 실행 결과 잔실 웹 검색 287회, 7백만 토큰 처리, 12개 서브 에이전트 활용, 약 9달러 비용으로 완성된 상세 회사 프로필과 SWAT 분석 보고서를 검토한다.

[32:06] Deep Agent가 Linear 회사 조사를 위해 여러 서브 에이전트들을 병렬로 실행하여 날짜, 위치, 인원수 등 상세한 정보를 수집하고 있습니다. 약 10개의 서브 에이전트가 동시에 작동하며 각각 4-10분 정도 소요됩니다.

[32:53] 서브 에이전트들은 자체 반성 기능을 갖추고 있어 사용하는 도구를 검토하고 완전한 답변을 얻을 때까지 지속적으로 작업합니다. 회사 프로필 조사 결과 다양한 링크와 상세한 정보를 제공하는 고품질 결과물을 생성했습니다.

[33:28] 메인 시스템은 서브 에이전트들로부터 정보를 수집한 후 필요시 추가 에이전트를 실행하거나 최종 결과물인 경쟁 분석과 회사 프로필 작성을 시작합니다. 이 과정에서 할 일 목록을 지속적으로 업데이트하고 관리합니다.

[34:09] 비평 에이전트를 호출하여 모든 파일을 검토하고 편집하며, 누락된 정보를 찾기 위해 추가 인터넷 검색을 수행합니다. 36분 후 모든 작업이 완료되어 최종 결과물이 제공됩니다.

[34:45] 최종 출력물의 품질이 매우 우수합니다. Linear의 포지셔닝, 타겟 마켓, 제품, 가격, 기술, 고객, 투자 정보, 강약점, 고객 감정, 리뷰 점수 등 상세한 회사 프로필과 Asana에 대한 동일한 수준의 정보가 포함된 최종 경쟁 분석 보고서가 완성되었습니다.

[35:25] 딥 에이전트가 생성한 경쟁 분석 결과물을 소개하며, 회사 비교부터 SWOT 분석까지 포함된 상세한 보고서의 품질에 만족감을 표현합니다.

[35:49] 35분이라는 실행 시간에도 불구하고 결과물의 유용성과 구체성이 혼자서는 불가능한 수준이라고 평가하며, 딥 에이전트 시스템이 기존 챗봇을 넘어선 패러다임 변화를 보여준다고 설명합니다.

[36:27] 35분간의 실행 통계를 상세히 분석하여 700만 개 토큰 처리, 198번의 언어모델 호출, 12개 서브 에이전트 생성, 287번의 웹 검색이 이뤄졌으며 평균 7.2초마다 검색이 수행되는 초인적 속도를 보여줬다고 설명합니다.

[37:11] 시스템의 비용 분석을 제시하며 한 번의 35분 실행에 9달러, 시간당 15달러의 비용이 발생했다고 설명하면서도 경제성과 생산성 향상의 균형점을 찾는 것이 중요하다고 언급합니다.

딥 에이전트를 통한 복잡 장기 과제 자동화의 생산성·효율성 이점과 비용 이슈를 정리하고, 추가 활용 사례 및 리소스 탐색을 권장한다.

타임라인 정보가 없습니다.

[00:00] 안녕하세요 여러분, 아담 러스크입니다.

[00:01] 오늘은 딥 에이전트, 즉 언어모델 기반 에이전틱 시스템에 대해 얘기해보겠습니다.

[00:02] 이 시스템들은 장기적인 작업이나 오래 실행되는 작업을 해결하도록 설계되었죠.

[00:05] 이런 AI 엔지니어링 방식은 딥 리서치 같은 것들로 인기를 얻게 되었습니다.

[00:07] 구글이 제미나이 인터페이스에서 처음 출시했던 것이죠.

[00:10] 그리고 지금은 ChatGPT Claude와 다른 여러 AI 애플리케이션에서도 널리 사용되고 있습니다.

[00:12] 특히 더 에이전틱한 코딩 애플리케이션들에서 말이죠.

[00:14] Claude 코드 커서 에이전트 같은 것들에서요.

[00:17] 딥 에이전트의 핵심 아이디어는

[00:19] 문제를 훨씬 오래, 그리고 훨씬 철저하게 작업할 수 있는

[00:22] 언어모델 기반 시스템을 만드는 것입니다.

[00:25] 더 얕은 스타일의 설정들보다 말이죠.

[00:27] 우리는 이런 작업들을 장기적 작업이라고 부릅니다.

[00:29] 본질적으로 1-2분보다 더 긴 기간에 걸쳐

[00:32] 여러 단계를 요구하는 작업을 말하죠.

[00:35] 그리고 이것은 언어모델 애플리케이션이 구축되는 방식의

[00:37] 자연스러운 진화인 것 같습니다.

[00:40] 언어모델의 능력과 유용성에 대한 더 많은 탐구와 연구를 통해

[00:43] 우리는 즉시 그들이 아주 작고

[00:46] 초기의 간단한 작업들을 수행하는 가치를 깨달았습니다.

[00:49] 빠른 웹 검색이나

[00:52] 리스트로 변환하거나 기사를 요약하는 것 같은

[00:55] 텍스트 변환 작업들 말이죠.

[00:57] 하지만 그런 작업들이 최종 사용자에게

[00:59] 주는 실제 가치는 다소 제한적인 경향이 있습니다.

[01:01] 그래서 이런 딥 에이전트 시스템들은

[01:04] 단순한 작업 실행을 넘어서

[01:06] 언어모델이 훨씬 복잡하고

[01:08] 훨씬 유용한 문제들을 해결할 수 있도록 하는 것을 목표로 합니다.

[01:10] 그리고 제 생각에는 이것은 자연스러운 진화입니다.

[01:13] 언어모델이 인간이 실제로

[01:16] 다양한 디지털 작업에 접근하고 수행하는 방식을

[01:20] 따라하고 모방하도록 포지셔닝되는 방식을 보면 말이죠.

[01:22] 언어모델의 작업 완료 능력을

[01:25] 같은 작업을 완료하는 인간의 시간과 비교한 연구를 보면

[01:28] 초기 시스템들이 일부 간단한 작업들을

[01:30] 완료하는 데 상당히 성공적이었다고 나타났습니다.

[01:32] 위키피디아 연구나 패시지에서

[01:35] 단어 출현 횟수를 세는 것 같은 작업들이죠.

[01:37] 그리고 이런 언어모델들이 진화하고

[01:39] 더 똑똑하고 유능해지면서

[01:41] 점점 더 복잡하거나

[01:43] 오래 실행되는 작업들을 해결할 수 있게 되었습니다.

[01:45] 완료하는 데 훨씬 많은 인간의 시간이 필요한 작업들 말이죠.

[01:48] 알고리즘 데이터 중복 제거나

[01:50] 프록시용 Docker 컨테이너 구성 같은

[01:53] 훨씬 복잡하거나 어려운 작업들이요.

[01:55] 일반적으로 인간이 더 많은 단계와 시간을 필요로 하는

[01:58] 최종 결과물을 실제로 완료하기 위한 작업들이죠.

[02:00] 최종 목표는 일반적으로

[02:02] 언어모델의 지능을 활용해서

[02:04] 점점 더 어려운 작업들을

[02:05] 자동화된 방식으로 완료하는 것입니다.

[02:07] 그리고 시간이 지나면서 더 많은 연구와 사람들이

[02:10] 이런 오래 실행되는

[02:13] 에이전틱 시스템을 개발함에 따라

[02:15] 공통적인 스캐폴드와 접근 방식이 나타났습니다.

[02:18] 우리가 여기서 광범위하게

[02:21] 딥 에이전트나 딥 에이전틱 시스템이라고 부르는 것이죠.

[02:23] 하지만 알고 보니

[02:26] 딥 에이전트의 네 가지 주요

[02:28] 특성이 있습니다.

[02:31] 일반적으로 매우 상세하고

[02:33] 복잡한 시스템 프롬프트를 포함하는 경향이 있습니다.

[02:36] 그들은 일반적으로

[02:38] 언어모델의 지능을 활용하여

[02:41] 점점 더 어려운 작업들을

[02:43] 자동화된 방식으로 완료하려고 합니다.

[02:45] 그리고 시간이 지남에 따라 더 많은 연구와

[02:48] 사람들이 이런 오래 실행되는

[02:50] 에이전틱 시스템을 개발하면서

[02:52] 공통적인 스캐폴드와 접근 방식이 등장했습니다.

[02:55] 우리가 여기서 딥 에이전트 또는

[02:58] 딥 에이전틱 시스템이라고 부르는 것이죠.

[03:01] 하지만 알고 보니

[03:03] 딥 에이전트의 네 가지 주요

[03:05] 특징이 있다는 것이 밝혀졌습니다.

[03:08] 매우 상세하고 구체적인

[03:10] 시스템 프롬프트를 포함하고,

[03:13] 계획 수립이나 할 일 목록 도구,

[03:15] 컨텍스트 관리를 위한 파일 시스템,

[03:18] 그리고 하위 에이전트 사용이 특징입니다.

[03:20] 오늘 이에 대해

[03:22] 좀 더 자세히 살펴볼 예정입니다.

[03:24] 이 네 가지 구성 요소가

[03:26] 실제로 어떻게 함께 작동하는지,

[03:28] 그리고 마지막에는 이 모든 것을 결합하여

[03:31] 우리만의 경쟁사 분석 딥 에이전트를

[03:33] 만들어보겠습니다. 이 에이전트는

[03:36] 상세하고 정확한 기업 프로파일을 작성하고

[03:38] 이들을 비교하여 완전한 보고서를 만들 수 있습니다.

[03:41] 과정에서 인기 있는 딥 에이전틱

[03:43] 설정들의 다양한 예제를 보여주고

[03:44] 오픈소스 패키지를 활용해 구축하겠습니다.

[03:47] 딥 에이전트 시스템의 첫 번째 구성 요소인

[03:50] 시스템 프롬프트부터 시작하겠습니다.

[03:52] 시스템 프롬프트의 독특한 점은

[03:55] 이런 에이전틱 설정에서

[03:56] 더 오래 실행되는 에이전트일수록

[03:58] 놀랍도록 상세하고 매우 정교한

[04:01] 시스템 프롬프트를 가지고 있다는 것입니다.

[04:03] Claude Code 시스템 프롬프트의

[04:07] 이 스냅샷을 빠르게 살펴보면

[04:09] 일반적으로 약

[04:12] 191줄 정도라는 것을 알 수 있습니다.

[04:14] 그리고 이것은

[04:16] 모든 도구 설명과 프롬프트를 포함하지 않은 것입니다.

[04:21] 여기서 보시는 바와 같이

[04:23] 이것은 상당히 많은 스크롤을 필요로 합니다.

[04:25] 그리고 몇 가지 다른 도구에 대해

[04:30] 더 긴 것들도 있습니다.

[04:33] 이 모든 것이 결합하여

[04:35] 매우 상세하고 구체적인

[04:38] 시스템 프롬프트를 만듭니다.

[04:41] 일반적으로 이런 프롬프트들은

[04:43] 약 200줄 정도의 코드로 구성되어 있고

[04:46] 도구 지시사항은 포함하지 않은 상태에서

[04:49] 톤, 스타일, 행동, 도구 사용 등

[04:51] 많은 구체적인 내용을 포함하며

[04:53] 수백 줄에 걸쳐 모든 것이

[04:56] 조화롭게 결합되어 있습니다.

[04:59] 프롬프팅이 언어 모델의 행동을

[05:02] 가이드하고 정렬하는 데 매우 중요하다는 것을

[05:04] 우리는 항상 알고 있었지만

[05:06] 이는 언어 모델이 생성하길 원하는 것에 대해

[05:09] 더 구체적이고 상세하며 정교할수록

[05:11] 실제로 더 나은 결과를 얻을 수 있다는 것을

[05:13] 확실히 보여줍니다.

[05:15] 그리고 사용되고 있는

[05:17] 흥미로운 기법들이 있습니다.

[05:19] 일반적으로 퓨샷 프롬프팅이라고 불리는

[05:20] 방법이 많이 사용되고 있습니다.

[05:22] 특정 행동이나 특정 도구가

[05:24] 어떻게 사용되어야 하는지에 대한

[05:26] 많은 예제를 제공하는 것입니다.

[05:28] Claude Code를 보면

[05:31] 언어 모델의 행동이

[05:34] 어떻게 이루어져야 하는지를 나타내는

[05:35] 의사 예제라고 제가 부르는 것들을 제공합니다.

[05:38] 이 추출된 예제에서

[05:41] 사용자가 새로운 기능에 대한 도움을 요청하면

[05:43] 어시스턴트가 할 일 목록을

[05:45] 만들어야 한다는 가이드를 볼 수 있습니다.

[05:48] 그리고 여기에는

[05:50] 미래 행동의 플레이스홀더 같은 것들도

[05:52] 포함되어 있습니다.

[05:55] 행동을 참조하는 이런 다양한 플레이스홀더의 사용은

[05:58] 이 예제들에서 여전히 유용합니다.

[06:00] 왜냐하면 매우 구체적인 퓨샷의

[06:03] 단점 중 하나가 바로

[06:05] 언어 모델이 예제를 정확히

[06:07] 예시들은 언어 모델이

[06:09] 예시를 정확히 모방하는 경향이 있다는 것입니다.

[06:13] 그래서 이러한 것들을 느슨하게 유지하고

[06:15] 미래 행동을 참조하며

[06:18] 원하는 상호작용이 어떤 것인지 보여주면

[06:22] 더 나은 최종 결과를 제공하는 것으로 나타납니다.

[06:25] 또한 스타일이나 가치 같은 요소들의

[06:27] 포함도 볼 수 있습니다. 매니저

[06:30] 시스템 프롬프트에는 내가 지키는 가치들,

[06:33] 역량에 대한 투명성,

[06:35] 지속적인 개선, 정확성과

[06:38] 신뢰성, 그리고 소통

[06:40] 스타일 같은 것들이 있습니다.

[06:43] 즉, 단순한 기술적 에이전트가 아니며

[06:46] 순수한 특정 실행 예시만이 아니라

[06:49] 이러한 다양한 특성들을 통해 안내하는 것이

[06:52] 에이전트에게 작업을 효과적으로

[06:54] 수행하는 데 필요한 개성을

[06:57] 조금 더 부여하는 데 도움이 됩니다.

[06:59] 물론 이런 것들은 최종 결과가

[07:02] 어떤 것이어야 하는지에 따라

[07:04] 매우 개인화되는 경향이 있습니다. Cursor

[07:07] 에이전트 같은 경우 전체 코드 스타일 가이드가 있어서

[07:10] 코드가 인간에 의해 검토될 것이라고 명시하고

[07:12] 그 후 에이전트가 실제로

[07:15] 코드를 작성할 때 따라야 하는

[07:19] 모든 종류의 것들을 제공하며,

[07:21] 높은 가독성, 정적 타입

[07:24] 언어 사용, TODO 주석 피하기와

[07:26] 구현 등을 확인하도록 합니다.

[07:30] 저는 여기 이 네 가지 요점으로 고수준의

[07:33] 모범 사례들을 요약했습니다.

[07:36] 본질적으로 프롬프트는 명확하고

[07:38] 체계적으로 구성되어 있다면 길고

[07:41] 복잡해도 괜찮다는 것입니다. 저는 이러한

[07:44] 시스템 프롬프트들 중 많은 것들이

[07:47] 일회성 프롬프트나 AI 우선

[07:50] 개발자들이 실제로 만드는 경향이 있는

[07:53] 더 작은 시스템들에서 보는 것보다

[07:56] 훨씬 크다고 주장할 것입니다. 그러나 프롬프트의

[07:59] 길이는 모든 것이 매우 명확하고

[08:02] 체계적으로 구성되어 상호작용에

[08:05] 어떤 가치를 제공한다면

[08:07] 반드시 해로운 것은 아닙니다. 다시 말해,

[08:09] 낭비되는 공간이 거의 없다는 것입니다.

[08:11] 또한 에이전트가 무엇인지와

[08:13] 프롬프트 시작 부분의 전반적인 기능을

[08:15] 소개하는 명확한 계층 구조가 있고,

[08:17] 톤과 행동을 설정한 다음

[08:19] 명확한 예시와 함께 모든 기능을

[08:22] 설명합니다. 또한 XML 태그와 같은 것들,

[08:25] 코드 스타일을 대괄호에 넣거나

[08:27] 예시를 대괄호에 넣는 것이

[08:30] 프롬프팅 전반에서 여전히 많이 사용되고 있습니다.

[08:33] 둘째로, 방금 몇 초 전에 언급했듯이

[08:35] 퓨샷 프롬프팅과 예시 제공은

[08:38] 행동을 강화하고 가지고 있는

[08:41] 도구들을 사용하는 방법을

[08:44] 이해하는 데 도움이 됩니다. 그리고 언급했듯이

[08:47] 이것들은 보통 매우 정확한 예시가 아니라

[08:51] 행동의 일반적인 개요와

[08:54] 미래 행동에 대한 참조입니다.

[08:57] 이것이 흥미롭다고 생각한 이유는

[08:58] 거기서 행동을 하는 별표 스타일과

[09:00] 매우 유사하기 때문인데, 이는 일반적인

[09:04] 인터넷 문화의 글쓰기 스타일입니다.

[09:06] 하지만 이를 위해 반복되는

[09:08] 한 가지 조언은

[09:10] 너무 너무 구체적이지 말라는 것입니다.

[09:12] 일반적인 개요를 가지고

[09:15] 다양한 행동을 참조하는 것이

[09:18] 행동을 안내하고 다양한

[09:19] 작업들로 일반화하는 데

[09:21] 도움이 될 수 있습니다. 너무 구체적이면

[09:24] 역효과를 낼 수 있습니다. 모델이

[09:26] 모든 시나리오에서 당신이 하려는 것을

[09:28] 정확히 모방하게 될 수 있죠. 이는

[09:30] 툴링에서 더욱 많이 사용됩니다. 시스템 프롬프트에서

[09:33] 보여드린 것처럼, 이 한 줄로는

[09:35] 잘 읽히지 않지만,

[09:38] 언제 그리고 왜 툴을 사용해야 하는지에 대한

[09:41] 다양한 시나리오를 보여주는 자세히 주석이 달린 툴을

[09:44] 이 시스템들 거의 모든 곳에

[09:48] 깊이 포함시키고 있습니다.

[09:50] 또한 툴을 언제 사용해야 하는지에 대한

[09:53] 좋은 예시뿐만 아니라

[09:55] 툴을 언제 사용하지 말아야 하는지에 대한

[09:58] 나쁜 예시도 보여줍니다. 좋은 것과

[10:00] 나쁜 것을 모두 포함하면 더욱

[10:03] 효과적으로 가이드할 수 있습니다. 그리고

[10:06] 마지막으로, 프롬프팅은 여전히

[10:08] 어느 정도 감에 의존합니다. 중요한

[10:10] 포인트들은 여전히 여러 다른 줄에서

[10:12] 여러 번 반복됩니다.

[10:14] 여러 회사들의 1인칭 대 3인칭

[10:16] 프롬프팅에 대한 선호도를 볼 수 있습니다.

[10:19] 서로 다른 툴에서는 다른 관점들이

[10:21] 사용됩니다. 커서

[10:23] 시스템 프롬프트처럼 훨씬 더 통일된 프롬프트도 있고,

[10:25] 메나스의 시스템 프롬프트처럼

[10:27] 좀 더 자유로운 것들도 있습니다. 따라서

[10:30] 아직도 상당한 양의 느슨하고 유연한

[10:34] 조직화가 필요하며, 이를

[10:36] 에이전트 시스템을 테스트하면서 파악해야 합니다.

[10:40] 여기서는 제가 마지막에

[10:42] 경쟁사 분석 딥 에이전트를 위해

[10:44] 만든 프롬프트를 살펴보겠습니다. 하지만

[10:47] 클로드 코드, 커서, 그리고 메나스에 대해

[10:48] 여기 링크된 프롬프트들을

[10:50] 확인해보시길 권합니다

[10:52] 아이디어와 더 구체적인

[10:55] 전체 프롬프트의 예시와 어떻게

[10:57] 설정되는지를 얻기 위해서입니다. 에이전트 시스템을

[11:00] 매일 프롬프팅한다면 매우 독특하고

[11:02] 매우 가치 있습니다. 이제

[11:05] 프롬프트는 끝났으니,

[11:06] 4가지 기능 중 두 번째로

[11:08] 넘어가겠습니다. 계획 툴의

[11:11] 포함입니다. 이 모든

[11:14] 시스템들에서 일관되게 흥미로운 점 중 하나는

[11:16] 계획 또는 할 일 목록

[11:19] 툴을 포함하고 적극적으로 사용하는 경향이 있다는 것입니다.

[11:21] 모델이 어떤 형태의 계획을 거쳐

[11:24] 이 계획을 자주 업데이트하며

[11:26] 모델이 취해야 할 다양한 단계와

[11:29] 요청에 접근하거나 해결하기 위해

[11:31] 취해야 할 다양한 행동들을

[11:32] 세분화합니다. 이제

[11:35] 이런 종류의 계획 단계를 수행하는 것은

[11:38] 새로운 것이 아닙니다. 지난

[11:40] 몇 년간 계획 단계를

[11:42] 포함하는 것이 언어

[11:45] 모델의 정확도와 능력을 크게 향상시킨다는 것을

[11:48] 봐왔습니다. 하지만 이것은

[11:50] 특정 컨텍스트 트릭을 추가합니다.

[11:53] 가장 큰 것은 발견된 것으로

[11:56] 작업의 길이와 복잡성이 증가할 때

[11:58] 처음에 계획이 만들어지면

[12:01] 대화가 진행되고 더 많은

[12:04] 단계와 더 많은 것들이

[12:07] 언어 모델의 컨텍스트에 로드되면서

[12:09] 계획이 잊히는 경향이 있습니다. 따라서

[12:11] 이를 해결하는 방법은

[12:13] 할 일 목록 툴의 사용을

[12:15] 장려하는 것입니다. 언어 모델이

[12:17] 일관되게 참조하고, 개선하고, 진행 중인 것과

[12:19] 실제로 완료된 것을 여러 지점에서

[12:22] 기록할 수 있게 합니다

[12:24] throughout

[12:26] 전체 실행 과정에서 말이죠.

[12:30] 이것은 실제 컨텍스트와

[12:33] 현재 목표와 다양한 작업들을

[12:35] 대화의 맨 앞으로 끌어올립니다.

[12:38] 그리고 지속적으로

[12:40] 참고하고 관찰하고

[12:43] 해야 할 일과

[12:45] 완료된 일을 재관찰함으로써

[12:48] 모델이 실제 목표와 계획에

[12:50] 더 잘 맞춰지게 유지합니다. 이건 거의

[12:53] 어텐션 메커니즘을 활용하는

[12:56] 순수한 트릭입니다. 왜냐하면 실제

[12:59] 도구 자체를 자세히 보면

[13:01] 실제로는 아무것도 하지 않거든요.

[13:04] 대부분의 함수들은 호출될 때

[13:05] API를 호출하고, 어떤 행동을 취하고,

[13:08] 정보를 반환합니다.

[13:09] 하지만 이건 그냥 투두리스트 도구를 정의할 뿐이고

[13:12] 유일한 목적은 실제 실행 계획을

[13:16] 다시 표면화하고 반복하는 것입니다.

[13:19] 저는 이걸 좀 더 개인적인

[13:21] 일화적 관점에서 생각해보고 싶어요.

[13:24] 저는 제대로 집중하려면

[13:26] 매우 상세한 투두리스트가 필요한 사람이에요.

[13:28] 그리고 저는 계속해서

[13:31] 투두리스트를 참고하고 메모를 추가하고

[13:33] 완료한 것들을 체크합니다.

[13:36] 그것이 제가 집중을 유지하고 다음에

[13:38] 해야 할 일을 알고 아직

[13:40] 진행 중인 것이 무엇인지 아는 데 도움이 됩니다.

[13:42] 흥미로운 점은 똑같은 접근 방식과 스타일이

[13:45] 언어 모델이 주제에 집중하고

[13:47] 작업을 계속 진행하는 데도 도움이 된다는 것입니다.

[13:51] 자, 이것이 계획 도구였습니다. 이제

[13:53] 세 번째 부분으로 넘어가면, 여기서도

[13:56] 의사 파일 시스템을 사용한 또 다른

[13:59] 컨텍스트 관리 트릭이 있습니다.

[14:02] 에이전트와 에이전틱 시스템을 다뤄본

[14:04] 사람이라면 누구나 알겠지만, 에이전트가

[14:08] 실행되고 더 많은 행동을 취하고

[14:10] 더 많은 출력을 생성하거나 더 많은

[14:13] 컨텍스트를 받아들일수록

[14:15] 실제로 관리해야 할 컨텍스트의 양이

[14:18] 급격히 늘어납니다. 그래서 언어 모델들은

[14:21] 컨텍스트 윈도우라고 부르는

[14:23] 꽤 큰 용량을 가지고 있는데, 이는

[14:26] 언어 모델이 한계에 도달하기 전까지 넣을 수 있는 토큰의 양입니다.

[14:30] 하지만 작업의 복잡성이 증가하고

[14:32] 관리해야 할 컨텍스트의 양이 증가하면

[14:35] 이러한 컨텍스트 윈도우의 한계를

[14:38] 쉽게 넘어서게 됩니다. 이는 특히

[14:41] 장시간 실행되는 딥 에이전트 시스템에서 더욱 그렇습니다.

[14:43] 코딩 에이전트 같은 것들을 보면

[14:45] 여러 코드 파일을 살펴봐야 할 수도 있고

[14:47] 리서치 에이전트는

[14:49] 여러 웹사이트를 살펴봐야 하는데

[14:51] 로드되는 웹사이트가 많아질수록

[14:54] 또는 로드되는 파일이 많아질수록

[14:55] 사용되는 컨텍스트의 양이 빠르게 증가합니다.

[14:58] 따라서 이 모든 컨텍스트를

[15:01] 컨텍스트 윈도우에 직접

[15:03] 로드해 두는 것은 현실적이지 않습니다.

[15:06] 이 한계를 해결하기 위해

[15:08] 파일 시스템에서 영감을 얻어

[15:10] 파일에 쓰고 다양한 파일을

[15:13] 열고 닫는 기능을 사용하여

[15:15] 그 안의 컨텍스트를 참조하는 방법을

[15:18] 사용하게 됩니다. 이는 유용한 정보를

[15:21] 운영하고 저장하는 방법이면서 동시에

[15:24] 미래에 참조할 수 있는 방법이기도 합니다.

[15:26] 간단히 말해, 에이전트에게는 보통

[15:28] 생성, 작성, 편집, 그리고

[15:30] 다양한 파일에 대한 검색

[15:32] 방법이 제공됩니다. 따라서 이것들을 사용해서

[15:35] 관련 파일 정보를 컨텍스트로 로드합니다.

[15:37] 컨텍스트를 불러오고, 이는 필요하지 않을 때

[15:40] 쉽게 오프로드할 수 있습니다. 하지만

[15:43] 파일 경로 URL이나 고유 식별자는

[15:46] 해당 컨텍스트가 있어야 할 대화 기록에

[15:49] 여전히 로드되어 있습니다. 이를 통해

[15:52] 언어 모델이 어떤 답변이나

[15:54] 어떤 행동을 위해 무엇이

[15:56] 참조되었는지 알 수 있고

[15:59] 쉽게 돌아가서 해당 파일을

[16:01] 열어서 컨텍스트를 다시 로드할 수 있습니다.

[16:05] 결국 이는 압축 가능하고

[16:07] 복원 가능하며

[16:09] 특정 에이전트의 실행 전반에 걸쳐

[16:11] 지속되는 고유한 메모리 시스템을 제공합니다.

[16:15] 네 번째이자 마지막이며 아마도 가장

[16:18] 강력한 부분은 우리가

[16:21] 서브 에이전트라고 부르는 것의 사용입니다.

[16:24] 서브 에이전트는 본질적으로

[16:27] 에이전틱 시스템의 서브루틴입니다.

[16:30] 메인 딥 에이전트가 호출할 수 있는

[16:32] 전문화된 개별 도구 호출 에이전트에 불과합니다.

[16:36] 작동 방식은 메인 딥 에이전트 시스템이

[16:39] 어떤 형태의 서브 에이전트를

[16:41] 사용할 수 있다는 것을 알고

[16:44] 동적으로 생성하여 각각의

[16:47] 서브 에이전트에게 개별화된 전문 작업을

[16:49] 위임합니다. 이는 보통

[16:52] 함수 호출 형태로 이루어지며

[16:54] 딥 에이전트가 함수를 호출하여

[16:56] 사용하고자 하는 서브 에이전트를 지정하고

[16:59] 이는 개발자나 시스템에 의해

[17:01] 정의되었으며 해당 서브 에이전트를 위한

[17:04] 특정 지시사항을 생성합니다.

[17:06] 그러면 서브 에이전트는

[17:08] 나가서 필요한 작업을 수행하고

[17:11] 딥 에이전트 시스템에 완전한 답변을

[17:14] 다시 제공합니다. 이는

[17:16] 더 인기 있는 멀티 에이전트 설정들과는

[17:18] 조금 다릅니다. 예를 들어 많은

[17:21] 미리 정의된 에이전트들과 그들 간의

[17:24] 커뮤니케이션을 조율하는

[17:26] 감독자 시스템들과 다르죠. 왜냐하면

[17:29] 이들은 더 서브루틴에 가깝고

[17:31] 동적으로 시작되며, 하나 또는 여러 개의

[17:34] 다양한 종류의 서브 에이전트들이

[17:37] 본질적으로 즉석에서 특정 작업을

[17:40] 수행하기 위해 생성되기 때문입니다.

[17:42] 이는 미리 정의된 시스템과

[17:44] 언어 모델을 통한 라우팅 로직에

[17:46] 의존하는 것과는 다릅니다. 그런데

[17:49] 서브 에이전트의 이점은 무엇일까요?

[17:53] 기본적으로 컨텍스트 관리, 모듈성,

[17:56] 전문화, 그리고 효율성의 이점을 제공합니다.

[17:59] 다시 말해, 서브 에이전트들과 함께

[18:02] 컨텍스트 관리 트릭들을 활용하는데

[18:05] 각 서브 에이전트는 자체적으로

[18:07] 정의된 컨텍스트 윈도우 내에서 작동합니다.

[18:10] 따라서 전체 시스템 프롬프팅으로

[18:13] 오염되지 않고 가지고 있는 도구들과 함께

[18:16] 당면한 특정 작업에만 집중할 수

[18:18] 있습니다. 이를 통해

[18:21] 가장 중요한 컨텍스트만 최종 답변에서

[18:24] 딥 에이전트 시스템으로 다시

[18:26] 전달할 수 있으며, 수행되고 있는

[18:29] 모든 세부적인 행동이나

[18:31] 참조된 모든 컨텍스트가 메인 시스템을

[18:33] 오염시킬 필요가 없습니다.

[18:37] 다시 말해, 작업을 해결하기 위해

[18:39] 완전히 격리되어 실행되고

[18:41] 그다음 정보를 다시 제공합니다.

[18:44] 이 접근법은 순전히 에이전트를

[18:47] 도구로 사용하는 방식으로 시작시키면

[18:49] 최종 결과를 받게 됩니다. 중간 단계나

[18:51] 중간 단계들이나 딥 에이전트의

[18:53] 메인 실행에 대한 어떤 것도 다시

[18:56] 추가하지 않습니다. 이를 통해 많은

[18:58] 모듈성과 특수화를 제공할 수 있습니다.

[19:01] 특정 작업에 맞는 서브 에이전트를 정의해서

[19:05] 시스템에서 수행해야 하는 특정

[19:07] 작업의 성능을 크게 향상시키고

[19:10] 더 좁은 범위의 프롬프팅과

[19:12] 맞춤형 도구들을 포함해서

[19:15] 작업을 더 직접적으로 처리하고

[19:18] 달성하려는 목표의 특정 부분을

[19:21] 해결할 수 있습니다. 그리고 이 모든 것에 더해

[19:23] 일반적인 접근법은 서브 에이전트를

[19:26] 병렬로 호출할 수 있다는 것입니다. 여러 개가

[19:29] 동시에 여러 미해결 작업을

[19:31] 진행할 수 있어서 엄청난

[19:34] 효율성 향상을 가져다 줍니다. 약간의 역사를

[19:37] 살펴보면, Anthropic이 서브 에이전트를

[19:39] 연구하고 Claude 코드 같은 것에

[19:41] 직접 통합하는데 힘쓰고 있는 회사입니다.

[19:43] 그리고 1년 전에 처음으로

[19:46] Claude 3 Opus에서 경제 분석가로서

[19:48] 이런 식으로 여러 작업을 수행하는

[19:52] 서브 에이전트 시스템의 초기 도입을 선보였습니다.

[19:55] 자, 이 네 가지 서로 다른 기법들,

[19:58] 상세한 시스템 프롬프트, 공통 할 일

[20:01] 목록, 컨텍스트 관리를 위한 파일 시스템,

[20:04] 그리고 서브 에이전트를 사용하고

[20:06] 생성할 수 있는 능력이 모두 결합되어

[20:09] 우리의 딥 에이전트 시스템이

[20:12] 훨씬 더 장기간의 작업을 수행하도록 돕습니다.

[20:14] 그럼 이제 실제로 하나를 만들어보겠습니다.

[20:18] 이론은 이제 끝났으니

[20:19] 이 모든 것을 결합하고 몇 가지

[20:21] 패키지를 사용해서 딥 에이전트를 구축하고 실행해보겠습니다.

[20:23] 제가 생각한 아이디어는 앞서 몇 번 언급했듯이

[20:28] 경쟁 분석 딥 에이전트입니다.

[20:30] 딥 리서치 같은 것들이 도입되면서

[20:32] 저는 항상 웹 검색 능력과

[20:35] 이런 특정 웹 연구 스타일 작업을

[20:36] 어떻게 더 활용하거나 더 맞춤화해서

[20:39] 더 구체적인 분야로 만들 수 있을지에

[20:42] 관심이 있었습니다. 그래서 딥 리서치 에이전트를

[20:45] 경쟁 분석 시나리오에 적용하는

[20:49] 아이디어가 나왔습니다. 딥 리서치 에이전트를

[20:52] 가져와서 경쟁 분석

[20:56] 시나리오에 적용하는 것이죠. 개괄적으로

[20:58] 이런 경쟁 분석을 수행할 수 있는

[21:00] 딥 에이전트를 만들고 싶습니다.

[21:03] 회사 연구 같은 것들을 더 깊이 파고들어야 하고

[21:05] 주요 비교를 제공하고, 웹 검색

[21:08] 도구를 사용해서 관련 정보를

[21:09] 웹 전체에서 찾아보고 탐색한 다음

[21:12] 그것들을 어떤 형태의

[21:14] 보고서로 편집해야 합니다.

[21:17] 이를 위해 LangChain Crew에서 나온

[21:20] 새로운 패키지 중 하나인

[21:23] Deep Agents 패키지를 사용할 것입니다.

[21:25] 이 패키지는 정말 놀랍습니다.

[21:27] 가서 확인해보세요. 그들에게 사랑을 보내고

[21:30] 별표도 주고 소스 코드도 보세요.

[21:32] 저보다 훨씬 똑똑한 사람들이

[21:35] 이런 놀라운 프레임워크를

[21:37] 멋진 오픈 소스 방식으로 설정했기 때문입니다.

[21:40] 그리고 여기에서 뛰어난 패키지를 제공했을 뿐만 아니라

[21:43] 몇 가지 예시도 제공했습니다.

[21:45] 그 중 하나가 일반 웹 연구 에이전트입니다.

[21:48] 제가 다룰 내용의 대부분은

[21:51] LangChain에서 영감을 받고 일부 코드를 재사용한 것이지만

[21:54] 그래도 딥 에이전트를

[21:57] 아주 쉽게 설치할 수 있습니다

[22:00] 그리고

[22:04]

[22:06] uv나 pip 같은 여러분이 선호하는 패키지 매니저를 사용해서

[22:08] 설치할 수 있습니다. 그리고 그 위에

[22:12] 웹 검색 클라이언트로 Tavily를 사용할 예정입니다.

[22:14] 이제 시작하기 위해

[22:17] 시스템 프롬프트를 정의하고

[22:20] 배운 내용을 적용해서

[22:22] 체계적이고 철저한

[22:25] 경쟁 분석 프롬프트를 만들어 보겠습니다.

[22:27] 이 프롬프트는 약 430줄 정도 되는데

[22:30] 모든 내용을 다 다루지는 않겠습니다.

[22:32] 물론 이 모든 코드는 링크가 되어 있고

[22:34] 아래 설명란에서 자유롭게 사용할 수 있습니다.

[22:38] 하지만 주요 포인트들을 살펴보고

[22:40] 여러 다른 기법들을 어디에

[22:43] 프롬프트에 적용했는지 보여드리겠습니다.

[22:45] 당연히 시나리오 정의부터 시작해서

[22:48] 시스템의 주요 기능이 무엇인지 정의하고

[22:50] 그 다음 바로 정체성과

[22:54] 행동 방식으로 넘어가서

[22:56] 우리가 잘하는 것들과

[22:59] 보유한 다양한 워크플로우를 보여줍니다.

[23:02] 그리고 경쟁 분석에 필요한

[23:05] 하위 작업들을 더 구체적으로 정의합니다.

[23:08] XML 태그 같은 것을 사용해서

[23:11] 정의하는 부분을 명확히 구분합니다.

[23:15] 연구 접근 방식 같은 것들이 있죠.

[23:18] 회사 프로필과

[23:20] 경쟁 인텔리전스 수집이

[23:22] 어떻게 이루어져야 하는지 보여주고

[23:25] 그 다음 각기 다른 결과물들이

[23:27] 실제로 어떻게 포맷될지도 보여줍니다.

[23:30] 두 개의 분리된 파일이 있는데

[23:32] 하나는 회사 프로필을 포함하고

[23:35] 그리고 마지막 끝에는 경쟁 분석이 있습니다.

[23:40]

[23:44]

[23:46] 바로 여기 파일 2와 함께

[23:49] 결과물의 각 섹션에 대해

[23:51] 기대되는 모든 것에 대한

[23:54] 매우 구체적인 내용들이 있습니다.

[23:57] 그 위에 품질 체크리스트가 있어서

[24:00] 우리가 기대하는 기준에

[24:03] 부합하는지 확인할 수 있습니다.

[24:05] 그리고 마지막으로

[24:07] 도구 사용의 좋은 예시와 나쁜 예시로 넘어갑니다.

[24:11] 이 경우에는 다양한

[24:13] 연구 에이전트와 비평 에이전트를 실행하는 것인데

[24:15] 잠시 후에 정의할 예정입니다.

[24:18] 좋은 예시들과 나쁜 예시들을 보여주고

[24:20] 실제로 어떻게 잘 프롬프트를 작성하는지 보여줍니다.

[24:23] 계속해서 위에서 정의한

[24:26] 일부 리마인더들을 반복합니다.

[24:28] 항상 해야 할 것들,

[24:31] 절대 하지 말아야 할 것들,

[24:33] 사용자의 원래 요청을 따르는 것 같은

[24:36] 일반적인 언어 요구사항들,

[24:39] 그리고 누락된 정보나

[24:41] 상충되거나 제한된 정보 같은

[24:43] 여러분이 연구 과정에서 마주할 수 있는

[24:47] 다양한 도전과제들을 어떻게 다룰지에 대한 내용입니다.

[24:50] 보시다시피 매우 정의가 잘 되어 있고

[24:53] 꽤 체계적이며 매우 구체적인

[24:55] 시스템 프롬프트로

[24:57] 이전에 봤던 것들의

[25:00] 다양한 특성들을 많이 가지고 있습니다.

[25:03] 이것과 함께 여기서 언급된

[25:05] 비평 에이전트와 연구 에이전트를 위한

[25:09] 몇 가지 프롬프트를 더 작성해야 합니다.

[25:11] 두 가지 형태의 하위 에이전트가 있을 건데

[25:13] 하나는 당연히 연구 스타일로

[25:16] 딥 에이전트가 실행할 수 있는

[25:18] 대부분의 웹 검색 기능을 가지고 있어서

[25:21] 더 구체적인 세분화된 연구 작업을 수행합니다.

[25:23] 구체적이고 세밀한 연구 작업을 수행합니다. 그리고

[25:26] 보고서를 검토하고 개선사항을

[25:28] 제안할 수 있는 비판 에이전트도

[25:30] 마지막에 포함시켰습니다.

[25:32] 연구 서브 에이전트 프롬프트를 보면

[25:34] 이것은 Manis의 시스템 프롬프트와

[25:35] 조금 더 유사한데, 핵심 기능과

[25:38] 연구 접근 방식에 대해

[25:40] 설명하고 있습니다. 구체적인 구조와

[25:42] 정보 깊이를 개괄적으로 설명하고

[25:45] 품질 기준과 몇 가지 예시도

[25:48] 보여주지만, 정확한 형식이나

[25:50] 세부적인 구성 방법에 대해서는

[25:53] 너무 구체적으로 명시하지 않습니다.

[25:56] 다만 어떻게 행동해야 하고 무엇을

[26:00] 찾아야 하는지에 대한 몇 가지

[26:03] 구체적인 사항들은 제시합니다.

[26:04] 회사의 궤적이나 기능, 역량 같은

[26:07] 특정한 것들을 찾을 때 말이죠.

[26:09] 우리가 반복적으로 강조하는

[26:11] 중요한 점들 중 하나는 응답이

[26:13] 완전하고 독립적이어야 한다는

[26:15] 것입니다. 최종 출력물만이

[26:17] 딥 에이전트로 반환되기 때문입니다.

[26:20] 또한 주목할 점은 에이전트 자체가

[26:22] 구체적인 지시사항과 함께 이것을

[26:26] 프롬프트할 것이라는 점입니다. 따라서 이 프롬프트는

[26:29] 그러한 지시사항들과 함께 첨부되어

[26:31] 서브 연구를 수행하게 됩니다.

[26:34] 이와 함께, 여기에는 비판 서브 에이전트

[26:36] 프롬프트도 있는데, 이는 경쟁 정보

[26:39] 보고서를 어떻게 비판해야 하는지에

[26:42] 대해 다룹니다.

[26:45] 이것은 서브 연구 에이전트와

[26:47] 꽤 유사한데, 어떻게 수행해야 하는지를

[26:50] 보여주며, 이러한 파일들이

[26:52] 실제로 어디에 위치해 있는지를

[26:54] 알려주어 다양한 맥락을 살펴보고

[26:58] 확인할 수 있도록 합니다. 일부 형식도

[27:01] 포함되어 있지만, 너무 구체적으로 만들지는

[27:04] 않았습니다. 그래야 더 높은 수준의

[27:05] 비판을 할 수 있기 때문입니다.

[27:07] 하지만 아마 깨닫기 시작하겠지만, 이러한

[27:10] 딥 에이전트 시스템을 설정하는

[27:12] 작업의 대부분은 실제로는

[27:15] 프롬프트를 명확하게 정의하는 것입니다.

[27:18] 이는 여러분의 요구사항과 기대하는

[27:20] 결과를 프로젝트와 보유하고 있는

[27:23] 에이전트에 대해 정의하는

[27:25] 연습이라고 할 수 있습니다. 따라서

[27:27] 이러한 것들을 명확하게 정의하고

[27:29] 정확한 행동과 정확한 기능을

[27:33] 딥 에이전트 내에서 명확히 개괄하는

[27:36] 것은 정말 좋고, 많은 사전 작업이

[27:39] 투입되어야 합니다. 이는 성능 향상과

[27:41] 항상 연관되기 때문입니다. 그 외에도

[27:44] 함수 형태의 빠른 웹 검색 도구를

[27:46] 만들었습니다. 그리고 딥 에이전트

[27:49] 패키지를 사용해서 이름, 설명,

[27:52] 프롬프트, 도구가 포함된 서브 에이전트들을

[27:54] 패키징할 것입니다. 그리고 이 모든 것을

[27:57] 메인 프롬프트와 도구와 함께 결합하여

[28:01] 딥 에이전트를 만들어낼 것입니다.

[28:04] 여기에 있는 설명들 또한

[28:06] 딥 에이전트, 즉 메인 에이전트에게

[28:10] 전달될 것입니다. 그래야 특정 서브

[28:13] 에이전트들이 무엇을 할 수 있는지

[28:16] 알 수 있기 때문입니다. 따라서

[28:19] 여기에도 몇 가지 구체적인 사항을

[28:21] 넣는 것이 좋습니다. 물론 이 모든 것을

[28:24] 깔끔하게 패키징할 것이며, Jupyter

[28:28] 노트북에서 실행하지는 않을 것입니다.

[28:30] 이 노트북이 있는 같은 디렉토리와

[28:34] 리포지토리에 이 모든 것이 경쟁 분석 에이전트로 구성되어 있습니다.

[28:34] 폴더가 있어서 모든 것을 하나의 파일로

[28:37] 통합하고 Langraph 플랫폼을 위해

[28:40] 모든 것을 구성하는 방법을 보여줍니다.

[28:43] 기본적으로 우리가 방금 본

[28:45] 모든 코드를 여기에 함께

[28:47] 모아놓은 것입니다. 그리고 유일한

[28:49] 차이점은 끝 부분에

[28:52] 특정 모델을 정의한다는 것입니다.

[28:55] 여기서는 GPT-4를 모델로 사용할 것이고

[28:59] 그런 다음 이 모든 것을 깔끔하게

[29:01] Langraph JSON 구성과 경쟁 분석 에이전트에 대한 경로로 패키지화합니다.

[29:05] 물론 코드에는 전체

[29:07] 권장 설정도 있습니다.

[29:10] 이 에이전트를 설정하고 직접 실행하고 싶다면 말이죠.

[29:13] 제가 추천하는 것은 Langchain의

[29:16] 추가 패키지 중 하나인

[29:18] Deep Agents UI를 사용하는 것입니다.

[29:20] 이는 정의한 딥 에이전트와

[29:23] 상호작용할 수 있는 멋진 프론트엔드를 제공합니다.

[29:26] 아래 설명에 링크를

[29:28] 걸어둘 것입니다. 하지만 모든 것을

[29:29] 설정한 후에는 기본적으로

[29:31] 서버를 실행할 수 있습니다.

[29:35] 프론트엔드와 동시에 Langraph 서버도 실행할 수 있습니다.

[29:41] 그러면 Langraph 플랫폼이 열리고

[29:44] 우리의 경우 경쟁 분석

[29:47] 에이전트인 에이전트를 컴파일할 것입니다.

[29:50] 그리고 여기 localhost 3000으로

[29:52] 가면

[29:56] 여기 Deep Agents UI가 보입니다.

[29:59] 다시 말하지만, 메인 리포지토리의 경쟁 분석

[30:04] 에이전트 폴더에서 이것을 설정하는 방법에 대한

[30:06] 모든 것이 아래에 링크되어 있습니다.

[30:09] 하지만 우리가 시도해볼 쿼리는

[30:12] '제품 개발팀을 위한 프로젝트 관리 솔루션으로서

[30:14] Linear와 Asana를 비교하는

[30:19] 포괄적인 경쟁 분석을 만들어라'입니다.

[30:21] 그리고 우리는 이것을 딥 에이전트에

[30:23] 보낼 수 있고, 작업을 시작하는 것을

[30:25] 볼 수 있을 것입니다.

[30:28] 그리고 여기서 잠시 후에

[30:31] 할 일들이 나타나기 시작하고

[30:34] 서브 에이전트들도 바로 이렇게

[30:36] 실행되기 시작하는 것을 볼 수 있을 것입니다.

[30:40] 그래서 이것을 돌려두고

[30:43] 잠시 실행시켜놓은 다음

[30:46] 마지막에 무슨 일이 일어나는지

[30:50] 확인해보겠습니다. 미리 이것을

[30:52] 실행해두고 돌려놨습니다.

[30:55] 그리고 마지막에 뒤에 있는

[30:58] Langsmith의 전체 추적을 보면

[31:00] 무려 2,756초

[31:03] 또는 35분 가까이 실행되었고

[31:05] Linear와 Asana 모두에 대한

[31:10] 전체 회사 프로필 파일을 출력했으며

[31:13] 일부 링크와 함께 이 전체 경쟁 분석도

[31:17] 출력했습니다. 이 추적을 간단히 살펴보면

[31:20] 처음에 많은 할 일을 작성하고

[31:23] 그 다음 파일에 분석 요청

[31:25] 같은 것들을 작성하기 시작했습니다.

[31:28] 할 일을 현재 진행 중으로 업데이트하고

[31:30] 실제로 워터폴을 보면

[31:32] 여러 개의 다른 작업을

[31:35] 병렬로 전송했습니다.

[31:39] 이러한 작업들이 서브 에이전트를

[31:42] 보내서 특정 연구를 수행하게 한 곳입니다.

[31:45] 메인 시스템이 Linear 회사 프로필

[31:48] 심층 연구를 위해 시작한

[31:52] 것 같은 것을 볼 수 있습니다.

[31:54] 미션과 포지셔닝에 대해서 말이죠.

[31:58] 그리고 다시 돌아와서

[32:00] 날짜, 위치, 인원수

[32:03] 추정치와 출처를 제공했습니다.

[32:06] 날짜, 장소, 그리고 추정 인원 수를

[32:08] 출처와 함께 제공합니다. 그리고 보시면

[32:10] 여기서 수많은 인터넷 검색을

[32:13] 시작했습니다. 그래서

[32:16] 이러한 서브 에이전트들이 얼마나 유용한지

[32:19] 알 수 있습니다. 약 10개의 서브 에이전트가

[32:21] 메인 시스템으로부터 병렬로 호출되어

[32:24] 구체적으로 세분화된 할 일들을 처리합니다. 이 중

[32:28] 다음으로 호출된 것은

[32:30] Linear 제품 기능 텍스트와

[32:32] 통합 기능에 관한 것이었고

[32:34] 이런 식으로 계속됩니다. 이러한 특정

[32:37] 서브 에이전트들은 병렬로 실행되며

[32:40] 일부는 4분, 다른 것들은

[32:42] 5분 정도 소요되고

[32:45] 어떤 것들은 거의

[32:48] 10분까지 실행됩니다.

[32:51] 이들은 개별 서브 에이전트들이며

[32:53] 어떤 종류의 반성 기능을 가지고 있어서

[32:56] 사용 중인 도구들을 살펴보고

[32:59] 실제로 전체 질문에 답할 수

[33:02] 있었는지 확인하고

[33:04] 완벽한 정보를 얻을 때까지

[33:07] 계속하며 멈추지 않습니다. 회사 프로필을

[33:10] 살펴본 우리 모델의 경우

[33:13] 출력에서 수많은 링크와

[33:15] 함께 이 모든 구체적인

[33:18] 정보를 제공하는 것을 볼 수 있으며

[33:22] 이는 정말 좋은 자료입니다.

[33:26] 이 모든 것이 잠시 동안 계속되고

[33:28] 메인 시스템은 다양한

[33:31] 서브 에이전트들로부터 정보를

[33:33] 받기를 기다리며, 필요한 경우

[33:36] 더 많은 서브 에이전트를 시작하거나

[33:38] 돌아와서 우리가 요청한 최종

[33:42] 결과물을 생산하기 시작합니다.

[33:44] 이 경우 마침내 경쟁 분석과

[33:46] 회사 프로필을 작성할 파일을

[33:50] 쓰게 됩니다.

[33:52] 이 모든 과정에서 할 일 목록을

[33:55] 업데이트하고 완료된 모든 것이

[33:58] 완료 또는 진행 중으로

[34:01] 표시되었는지 확인하며

[34:04] 결국 다른 서브 에이전트인

[34:07] 비평 에이전트를 호출하여

[34:09] 실제로 모든 파일을 검토하고

[34:13] 편집하도록 하며, 이는 사용 가능한

[34:17] 파일들을 살펴보고 읽어서

[34:19] 정보를 제공합니다. 그 다음

[34:21] 약간의 상호작용이 있는데

[34:23] 비평 에이전트를 다시 호출하고

[34:24] 누락된 정보를 찾기 위해

[34:27] 일회성 인터넷 검색을 수행하며

[34:30] 36분 후에 모든 것이

[34:33] 완료되었다고 최종 결정하고

[34:36] 결과물을 제공했으며

[34:40] 출력의 품질이 실제로 매우 좋다는 것을

[34:45] 확인할 수 있습니다.

[34:47] 우리 회사 프로필은

[34:49] 매우 상세합니다. Linear의 포지셔닝,

[34:51] 타겟 마켓, 다양한 제품들,

[34:53] 가격 책정과 패키징, 기술과

[34:56] 통합 기능, 주목할 만한 고객들,

[34:59] 다양한 투자 정보, 강점,

[35:01] 약점, 고객 감정, 일반적인

[35:04] 불만사항, 신뢰할 수 있는

[35:06] 출처의 리뷰 점수, 그리고

[35:08] Asana에 대한 동일한 정보들에 대한

[35:11] 훌륭한 개요를 얻었습니다.

[35:16] 이 모든 것이 함께 결합되어

[35:18] 우리가 원했던 최종 경쟁 분석을

[35:21] 만들어냅니다. 여기에는

[35:23] 실행 요약과 간략한 개요가 포함됩니다

[35:25] 한눈에 보는 회사 비교,

[35:28] 포지셔닝 차이점 비교와

[35:31] 기능 및 타겟 마켓별 세부 분석,

[35:35] 가격 정보. 그리고 양쪽 회사 모두에 대한

[35:38] 강점과 약점,

[35:40] 기회와 위협을 다루는

[35:42] 완전한 SWOT 분석도 있어요. 경쟁

[35:44] 역학 관계, 권장사항, 결론,

[35:47] 심지어 맨 마지막에는 출처까지 있습니다.

[35:49] 무려 35분이나 실행되었지만,

[35:52] 결과물의 유용성과

[35:55] 구체성을 고려해보면

[35:57] 충분히 가치가 있다고 생각해요.

[35:59] 저 혼자서는 이렇게

[36:01] 엄청나게 상세하고

[36:03] 구체적인 분석을 같은 시간 안에

[36:07] 만들어낼 수는 없었을 거예요.

[36:09] 이것이 바로 이런 딥 에이전트 시스템들이

[36:12] 패러다임을 바꾸고 있다는 증거입니다.

[36:13] 피상적인 일회성 작업 실행 챗봇에서

[36:16] 언어모델 기반 시스템으로

[36:18] 진정한 가치를 제공하고

[36:20] 훨씬 더 복잡하고 장시간 실행되는

[36:24] 작업들을 처리할 수 있는 시스템으로 말이죠.

[36:27] 여기 있는 통계 요약을

[36:29] 분석해보면, 에이전트가 실행된 35분 동안

[36:32] 거의 700만 개의 토큰을 처리했고

[36:35] 198번의 언어모델 호출을 통해

[36:39] 총 690만 개의 입력 토큰과

[36:42] 22,000개의 출력 토큰을 사용했습니다.

[36:46] 12개의 특정 서브 에이전트를 생성했는데,

[36:49] 연구용으로 10개, 검토용으로 2개였어요.

[36:51] 그 과정에서

[36:53] 35분 동안 총 287번의 웹 검색이

[36:57] 이뤄졌는데,

[36:59] 평균적으로 7.2초마다

[37:02] 한 번씩 웹 검색을 한 셈입니다.

[37:06] 이런 시스템들이 실제로

[37:08] 작동하는 속도는 완전히 인간을 넘어섭니다.

[37:11] 물론 이런 이점들에는 대가가 따르죠.

[37:14] 단 한 번의

[37:16] 35분 실행에 드는 총 비용이

[37:21] 거의 9달러에 달했어요.

[37:24] 모든 작업에 GPT-4o를 사용했긴 하지만요.

[37:28] 여기서 최적화할 수 있는 부분이 있는데,

[37:30] 서브 에이전트들에는 더 작은 모델을 사용하고

[37:32] 오케스트레이션 부분에만

[37:34] 큰 모델을 사용하는 방법이 있어요.

[37:37] 하지만 비용을 제약으로 두지 않고

[37:40] 어떤 품질을 얻을 수 있는지 보고 싶었어요.

[37:42] 녹화 시점 기준으로 OpenAI의

[37:45] 최신 최고 모델을 사용해서 말이죠.

[37:47] 이걸 시간당으로 계산하면

[37:50] 약 15달러 27센트 정도가 나와요.

[37:52] 그래서 이런 시스템들의 경제성과

[37:55] 생산성 향상에 대해서는

[37:58] 많은 고려가 필요하지만,

[38:00] 이 부분은 추후 탐구와 연구를 위해

[38:03] 여러분의 숙제로 남겨두겠습니다.

[38:05] 어쨌든 우리는 딥 에이전트가

[38:07] 어떻게 작동하는지 정확히 설정하고 보여줬고

[38:10] 직접 만들어서 더 복잡하고 장시간 실행되는

[38:14] 작업에 성공적으로 실행했습니다.

[38:16] 물론 모든 리소스 링크와

[38:18] 추가 읽을거리, 블로그 포스트,

[38:20] 그리고 제가 LangChain

[38:22] 리포지토리에서 사용한

[38:24] 모든 자료들을 아래 설명란에

[38:26] 링크해 놓겠습니다. 그리고 다시 한 번,

[38:28] LangChain의 다른

[38:30] 리소스들도 꼭 확인해 보시길

[38:32] 강력히 권합니다. 이 자료를

[38:35] 만드는 과정에서 정말

[38:37] 유용했거든요. LangChain에게

[38:39] 큰 박수를 보냅니다. 결국

[38:41] 무언가를 배우셨고, 가져갈 수 있는

[38:43] 흥미로운 코드도 있고,

[38:45] 딥 에이전트를 적용할 수 있는

[38:47] 다양한 영역과 활용 사례들을

[38:49] 생각해보기 시작하셨기를 바라요.

[38:51] 영상이 마음에 들면 좋아요 눌러주시고,

[38:53] 질문이나 댓글이 있으면

[38:55] 아래 댓글란에 남겨주세요.

[38:56] 더 많은 영상을 보고 싶으시면

[38:58] 구독을 고려해주세요. 감사합니다.

[39:00] 좋은 하루 되세요.