Building Agentic Flows: A Hands-On Project Plan

I've been putting together a plan to build and teach a series of hands-on Agentic Flow projects. As someone who's been working across software development, AI research, and QA automation, I've always wanted to bridge the gap between theory and practice — especially around the concepts that are rapidly reshaping how we build software: AI Agents, Agentic Flows, and Multi-Agent systems.

This time, I'm designing ten tiered projects, each one progressively more complex. The goal is to make these usable both as a personal portfolio and as lecture material — covering both non-developers and developers, with real tools and real workflows.

Here's the plan:

• Goal (Must Have): Design and implement hands-on Agentic Flow projects, each explicitly structured around three core components — Model, Tools, and Orchestration.
• Stretch Goal: Package these into a full lecture curriculum and eventually publish a course on Inflearn targeting both developer and non-developer audiences.
• Period: Roughly 8–12 weeks, building and validating one level at a time.
• How: Claude Pro (claude.ai, Claude Desktop) for Level 1, Gemini 3.1 Flash Lite (free API) from Level 2 onward, with n8n for visual orchestration, LangGraph for code-based orchestration, and Claude Code for agent-native orchestration.
• Why: Two reasons. First, to build real, demonstrable Agentic Flow skills — not just wrappers around a chat interface. Second, to create lecture content grounded in actual implementation experience, not slides.

The Projects

Before diving in, one thing I want to be deliberate about: every project in this series will explicitly define three components — Model, Tools, and Orchestration. This isn't just for teaching clarity. It's the right mental model for thinking about Agents. Without all three, you don't have an Agent — you just have a chatbot.

Level 1.1 — Single Agent (Connector)

Goal: Build an AI assistant that reads Google Calendar and Gmail with a single click. Tool: claude.ai Connector / 💰 $0

• Model: Claude Sonnet (claude.ai)
• Tools: Google Calendar, Gmail (one-click Connector)
• Orchestration: claude.ai single Agent loop (automatic)
• Dev Tool: None

The entry point. No installation, no config files — just clicking "Connect" in claude.ai settings and watching Claude gain the ability to read your calendar and summarize your emails. It sounds simple, but this is where the core concept clicks: connect a Tool to a Model, and you get an Agent.

Level 1.2 — Single Agent (MCP)

Goal: Rebuild the same AI assistant at the protocol level by writing the MCP config directly. Tool: Claude Desktop + MCP / 💰 $0

• Model: Claude Sonnet (Claude Desktop)
• Tools: Google Calendar MCP, Gmail MCP, Filesystem MCP
• Orchestration: Claude Desktop manages MCP server list + runs Agent loop
• Dev Tool: Cursor

Same task as 1.1, but this time we open the config file and wire it up ourselves. The point isn't the complexity — it's the contrast. After doing 1.1 and 1.2 back to back, you understand the difference between a black box and a protocol. That distinction matters a lot as you go deeper.

Level 2 — Agentic Flow (External Orchestration)

Goal: Build a workflow that receives an email, lets an AI decide the action, and auto-sends a Slack message — implemented three ways. Tool: n8n / LangChain / LangGraph + Gemini API / 💰 $0

2.1 — n8n - Model: Gemini 3.1 Flash Lite (free API) - Tools: Webhook, HTTP Request, Slack Webhook - Orchestration: n8n — Trigger → Flask server (Gemini call) → Action

2.2 — LangChain - Model: Gemini 3.1 Flash Lite (langchain-google-genai) - Tools: Slack Webhook (requests.post) - Orchestration: FastAPI (trigger) + chain = prompt | llm | parser + requests

2.3 — LangGraph - Model: Gemini 3.1 Flash Lite (langchain-google-genai) - Tools: Slack Webhook (requests.post) - Orchestration: FastAPI (trigger) + LangGraph (add_node / add_edge) + requests

Here the Orchestration moves outside the Model. The same 3-node pipeline (receive → judge → send) is built three ways, showing how each tool expresses the same architecture differently. The key insight from 2.2 vs 2.3: LangChain chains steps sequentially in code, LangGraph declares nodes and edges explicitly — the same concept as drawing wires on an n8n canvas.

Level 3 — Agentic Loop (ReAct)

Goal: Build a research bot that autonomously searches, summarizes, and saves results by looping Think → Act → Observe — implemented two ways. Tool: n8n / LangGraph + Gemini API + Tavily / 💰 $0

3.1 — n8n - Model: Gemini 3.1 Flash Lite (free API) - Tools: Tavily Search API (web search) - Orchestration: n8n (loop control: If:false → loopback) + Flask server

3.2 — LangGraph - Model: Gemini 3.1 Flash Lite (langchain-google-genai) - Tools: Tavily Search API (web search) - Orchestration: FastAPI + LangGraph (add_conditional_edges + route function)

This is where the internal loop appears for the first time. n8n fires the trigger, but once the Agent starts, it drives itself — searching, evaluating results, deciding whether to dig deeper or stop. The key difference between 3.1 and 3.2: n8n's loopback is a visual wire on the canvas; LangGraph's is add_conditional_edges in code.

Level 4 — Multi-Agent Flow + HITL

Goal: Build a lecture plan generator where multiple specialized Agents collaborate in parallel and sequential rounds, with a Human-in-the-Loop approval gate — implemented three ways. Tool: Claude Code / n8n / LangGraph + Gemini API + Tavily / 💰 $0

Scenario: User inputs topic, audience level, duration, delivery method, platform/tools, and constraints. The system generates a complete lecture plan in four rounds: parallel research → sequential writing → parallel review → Human-in-the-Loop gate (if quality threshold not met).

4.1 — Claude Code - Model: Claude Sonnet (subagents, via Claude Code) - Tools: WebSearch (researcher subagent), Read/Write (writer, save subagents) - Orchestration: CLAUDE.md (entry point, 3 lines) + .claude/agents/orchestrator.md (full pipeline logic) + 8 specialized subagents - HITL: Reviewer scores draft; if below 80, writer rework loop (max 2x, automatic) - Logging: settings.json hooks (SubagentStart/SubagentStop) → subagent_log.csv

The key distinction from previous levels: no Python code, no visual canvas. Orchestration is expressed entirely in natural language instruction files. Parallel execution is Task tool multi-call within a single message. The CLAUDE.md is 3 lines — it just says "hand off to orchestrator." All pipeline logic lives in orchestrator.md.

4.2 — n8n + HITL - Model: Gemini 3.1 Flash Lite (free API) - Tools: Tavily Search API - Orchestration: n8n (node branching + Merge + Wait node) + Flask server (Python) - HITL: Wait node pauses workflow on score < 80; Slack notification sent with approve/reject options; human POSTs decision to resume webhook

Two parallel rounds on canvas: researcher batch (Split Out → HTTP Request → Merge) and reviewer fan-out (3 branches → Merge with "Wait for All Inputs"). The Wait node is n8n's HITL primitive — the workflow freezes at that node until a human sends a POST to the resume URL.

4.3 — LangGraph + HITL - Model: Gemini 3.1 Flash Lite (langchain-google-genai) - Tools: Tavily Search API - Orchestration: FastAPI + LangGraph (Send API + add_edge fan-out + interrupt() + MemorySaver) - HITL: interrupt() pauses graph at hitl_node; thread_id tracks state; /resume endpoint accepts human decision and continues execution

Two parallel patterns: Send API for dynamic N researchers, add_edge multi-target for fixed 3 reviewers. interrupt() is LangGraph's HITL primitive — same concept as n8n's Wait node, declared in code. MemorySaver stores state per thread_id so the workflow can be resumed at any time.

Agentic Flow — Concept Progression

L1.1  Single Agent — click to connect (Connector)
L1.2  Single Agent — protocol-level config (MCP)
L2.1  Orchestration outside the Model — visual (n8n)
L2.2  Orchestration outside the Model — chain (LangChain)    ← compare
L2.3  Orchestration outside the Model — graph (LangGraph)    ← compare
L3.1  Internal loop: ReAct — visual (n8n)
L3.2  Internal loop: ReAct — graph (LangGraph)               ← compare
L4.1  Multi-Agent + parallel — agent-native (Claude Code)
L4.2  Multi-Agent + parallel + HITL — visual (n8n)           ← compare
L4.3  Multi-Agent + parallel + HITL — graph (LangGraph)      ← compare

Each level introduces one new concept. Each "compare" pair shows the same concept expressed differently — giving a direct view of what each tool hides and what it exposes.

What's Next

I'll be building each level one at a time and writing up the implementation details, lessons learned, and how the Model / Tools / Orchestration breakdown held up in practice.

---

Agentic Flow 구현해보기

AI Agent와 Agentic Flow 프로젝트들을 직접 구현해보기 위한 계획을 세웠다. 소프트웨어 개발, AI 연구, QA 자동화를 넘나들며 일해온 입장에서, 이론과 실습 사이의 간극을 메우고 싶다는 생각을 늘 해왔다.

이번에는 난이도별로 10개의 실습 프로젝트를 설계했다. 개인 포트폴리오로도, 강의 자료로도 활용할 수 있도록 — 비개발자와 개발자 모두를 커버하고, 실제 툴과 실제 워크플로우를 기반으로 구성했다.

계획은 다음과 같다:

• 목표 (필수): Agentic Flow 실습 프로젝트를 설계하고 구현한다. 각 프로젝트는 Model, Tools, Orchestration 세 가지 핵심 구성 요소를 명확히 정의한다.
• 추가 목표: 이 내용을 강의 커리큘럼으로 패키징하고, 최종적으로는 개발자/비개발자 대상 인프런 강의로 출시한다.
• 기간: 레벨 하나씩 구현하고 검증하며, 대략 8~12주를 목표로 한다.
• 방법: Level 1은 Claude Pro (claude.ai, Claude Desktop), Level 2부터는 Gemini 3.1 Flash Lite (무료 API)를 기본으로, n8n을 시각적 오케스트레이션 도구로, LangGraph를 코드 기반 오케스트레이션 도구로, Claude Code를 에이전트 네이티브 도구로 활용한다.
• 이유: 두 가지다. 첫째는 챗봇 래퍼 수준이 아닌, 진짜 Agentic Flow 구현 역량을 쌓는 것. 둘째는 실제 구현 경험을 기반으로 한 강의 콘텐츠를 만드는 것이다. 슬라이드가 아니라 코드로 증명하는 강의를 만들고 싶다.

프로젝트 목록

들어가기 전에 한 가지 원칙을 명확히 하고 싶다. 이 시리즈의 모든 프로젝트는 Model, Tools, Orchestration 세 가지 구성 요소를 반드시 명시한다. 세 가지가 갖춰지지 않으면 Agent가 아니라 그냥 챗봇이다.

Level 1.1 — Single Agent (Connector)

목표: Google Calendar와 Gmail을 읽고 요약하는 AI 비서를 클릭 한 번으로 만든다. 툴: claude.ai Connector / 💰 $0

• Model: Claude Sonnet (claude.ai)
• Tools: Google Calendar, Gmail (클릭 연결)
• Orchestration: claude.ai 단일 Agent 루프 (자동)
• 개발 도구: 없음

Level 1.2 — Single Agent (MCP)

목표: MCP 설정 파일을 직접 작성해서 같은 AI 비서를 프로토콜 레벨로 구현한다. 툴: Claude Desktop + MCP / 💰 $0

• Model: Claude Sonnet (Claude Desktop)
• Tools: Google Calendar MCP, Gmail MCP, 파일시스템 MCP
• Orchestration: Claude Desktop이 MCP 서버 목록 관리 + Agent 루프 실행
• 개발 도구: Cursor

Level 2 — Agentic Flow (External Orchestration)

목표: 이메일 수신 → AI 판단 → Slack 자동 발송 파이프라인을 세 가지 방식으로 구현한다. 툴: n8n / LangChain / LangGraph + Gemini API / 💰 $0

2.1 — n8n - Orchestration: n8n (시각적 노드) + Flask 서버 (Gemini 호출)

2.2 — LangChain - Orchestration: FastAPI + chain = prompt | llm | parser + requests

2.3 — LangGraph - Orchestration: FastAPI + LangGraph (add_node / add_edge) + requests

여기서부터 Orchestration이 Model 바깥으로 나온다. 동일한 3-노드 파이프라인(수신 → 판단 → 발송)을 세 가지 방식으로 구현해서 각 도구가 같은 구조를 어떻게 다르게 표현하는지 직접 비교한다. LangChain은 파이프라인을 코드에서 순서대로 실행하고, LangGraph는 노드와 엣지를 명시적으로 선언한다 — n8n 캔버스에서 선을 그리는 것과 동일한 개념을 코드로 표현한 것이다.

Level 3 — Agentic Loop (ReAct)

목표: 주제를 입력하면 스스로 검색·요약·저장을 반복하는 리서치 봇을 두 가지 방식으로 구현한다. 툴: n8n / LangGraph + Gemini API + Tavily / 💰 $0

3.1 — n8n - Orchestration: n8n (If:false → 루프백) + Flask 서버

3.2 — LangGraph - Orchestration: FastAPI + LangGraph (add_conditional_edges + route 함수)

처음으로 내부 루프가 등장하는 레벨이다. n8n이 트리거를 발사하지만, Agent가 시작되고 나면 스스로 구동한다. 3.1의 루프백은 캔버스에서 선이 뒤로 연결되는 모습으로 보이고, 3.2의 루프백은 add_conditional_edges로 코드에 선언된다.

Level 4 — Multi-Agent Flow + HITL

목표: 여러 전문 에이전트가 병렬+순차로 협업해 강의계획서를 자동 생성하고, 품질 미달 시 사람이 개입하는 파이프라인을 세 가지 방식으로 구현한다. 툴: Claude Code / n8n / LangGraph + Gemini API + Tavily / 💰 $0

시나리오: 주제/대상자/일수/방식/플랫폼/제약조건을 입력하면 4라운드로 강의계획서를 생성한다. 서브토픽 분해(순차) → 서브토픽별 웹 검색(병렬) → 초안 작성(순차) → 내용/시간배분/난이도 검토(병렬) → 점수 미달 시 HITL 게이트.

4.1 — Claude Code - Orchestration: CLAUDE.md (진입점, 3줄) + orchestrator.md + 서브에이전트 8개 - HITL: 자동 재작업 루프 (AI가 판단, 최대 2회) - 병렬: Task tool 동시 호출

코드 없이 자연어 지시 파일만으로 멀티에이전트 파이프라인을 구현한다. CLAUDE.md는 "orchestrator에게 위임해라"만 담당하고, 모든 파이프라인 로직은 orchestrator.md에 있다.

4.2 — n8n + HITL - Orchestration: n8n (노드 분기 + Merge + Wait 노드) + Flask 서버 (Python) - HITL: Wait 노드로 실행 정지 → Slack 알림 → 사람이 resume webhook으로 결정 전달 - 병렬: Split Out + 배치 실행 (동적 N개) / 노드 3개 분기 + Merge (고정 3개)

Wait 노드가 이 레벨의 핵심 신규 개념이다. 워크플로우가 중요한 분기점에서 멈추고, 사람의 판단을 기다렸다가 이어서 실행된다.

4.3 — LangGraph + HITL - Orchestration: FastAPI + LangGraph (Send API + add_edge 다중 분기 + interrupt() + MemorySaver) - HITL: interrupt()로 실행 정지 → thread_id로 상태 저장 → /resume 엔드포인트로 재개 - 병렬: Send API (동적 N개) + add_edge 다중 분기 (고정 3개)

n8n Wait 노드가 interrupt()로, n8n 내부 DB가 MemorySaver로 대응된다. 같은 HITL 개념을 코드로 표현했을 때 어떤 모습인지 4.2와 직접 비교할 수 있다.

Agentic Flow — 개념 진화 흐름

L1.1  Single Agent — 클릭으로 연결 (Connector)
L1.2  Single Agent — 프로토콜 레벨 설계 (MCP)
L2.1  Orchestration이 Model 바깥으로 분리 — 시각적 (n8n)
L2.2  Orchestration이 Model 바깥으로 분리 — 체인 (LangChain)    ← 비교
L2.3  Orchestration이 Model 바깥으로 분리 — 그래프 (LangGraph)  ← 비교
L3.1  내부 루프 등장: ReAct — 시각적 (n8n)
L3.2  내부 루프 등장: ReAct — 그래프 (LangGraph)                 ← 비교
L4.1  멀티에이전트 + 병렬 — 에이전트 네이티브 (Claude Code)
L4.2  멀티에이전트 + 병렬 + HITL — 시각적 (n8n)                 ← 비교
L4.3  멀티에이전트 + 병렬 + HITL — 그래프 (LangGraph)           ← 비교

각 레벨은 새로운 개념 하나를 추가한다. 각 "비교" 쌍은 동일한 개념이 도구마다 어떻게 다르게 표현되는지를 보여준다 — 각 도구가 무엇을 숨기고 무엇을 드러내는지 직접 확인할 수 있다.

다음 단계

레벨 하나씩 구현하고, 각 레벨마다 구현 상세, 배운 것들, 그리고 Model / Tools / Orchestration 구조가 실제로 어떻게 작동했는지를 별도 포스트로 정리할 예정이다.