Chapter 2: Complete Development Environment Setup Guide

Estimated Time: 15 minutes
After completing this chapter, you'll see an AI responding directly on your computer. In 15 minutes, you'll transform from 'someone who wants to try AI' into 'someone who has actually run AI'.

Introduction: Why Development Environment Setup Is the First Gateway

Many people say they want to build AI agents. But most never even start. The reason is simple: "They don't know where to begin." Complex programming languages? Difficult server configuration? Expensive equipment? None of that is necessary.

In this chapter, I'll guide you through every step so that even someone with zero coding experience can follow along. Just follow my instructions. In 15 minutes, you'll run a program that actually converses with AI.

1. Pre-Start Checklist: Verify What You Need

Just as you check ingredients before cooking, let's verify what you need before setting up your development environment. Fortunately, you don't need much.

✅ Essential Requirements

• Computer: Windows, Mac, or Linux—any will do. A standard laptop purchased within the last 5 years is sufficient.
• Internet Connection: A stable internet connection is required. AI runs on the cloud.
• Email Account: Needed to create an Anthropic account.
• Payment Method: A credit card or debit card is required. (Free credits may be provided upon initial signup)

✅ Mindset Checklist

• Do you have 15 focused minutes available?
• Are you ready to learn something new?
• Do you have the determination to not give up even if you get stuck?

Everything checked? Then let's begin!

2. Obtaining Your Anthropic API Key: Creating Your Personal Key

What is an API key? Simply put, it's a secret key to use the AI service. Just as you need a card key to enter a hotel room, you need an API key to use Claude AI. This key is yours alone, and you must never share it with anyone else.

Step 1: Access the Anthropic Console

Open your web browser and enter the following address in the address bar:

https://console.anthropic.com

The Anthropic login page will appear on your screen. If this is your first visit, click the "Sign Up" or "Create Account" button.

Step 2: Create Your Account

1. Enter your email address.
2. Set your password. (Include uppercase letters, lowercase letters, and numbers—minimum 8 characters)
3. Click the "Create Account" button.
4. A verification email will be sent to the email address you entered.
5. Open your email and click the verification link.

💡 Tip: If you don't receive the email, check your spam folder. If it's still not there, wait about 5 minutes and click the "Resend" button to request it again.

Step 3: Register Payment Information

Once email verification is complete, a screen to register payment information will appear. Don't worry! You're only charged for what you use, and initially you'll only spend a few cents for testing purposes.

1. Click "Add Payment Method" or the payment method addition option.
2. Enter your card number, expiration date, and CVC.
3. Enter your billing address.
4. Click the "Save" button.

Step 4: Generate Your API Key

Finally, the crucial step! Let's generate your API key.

1. Click "API Keys" in the left menu of the console.
2. Click the "Create Key" button in the top right corner of the screen.
3. Enter a key name. For example: "my-first-agent" (enter in English)
4. Click the "Create Key" button.

A long character string starting with sk-ant-api03-... will appear on the screen. This is your API key!

⚠️ Very Important: This key is shown only once on this screen. You must copy and save it somewhere. I strongly recommend pasting it into a text editor. Once you close this window, you won't be able to see it again!

Have you saved your API key in a safe place? Excellent! You've passed the first hurdle.

3. Installing Python: Learning the Language to Talk with AI

Python is a programming language. You might think, "Why do I need a programming language?" Python serves as an interpreter that allows us to send commands to AI and receive responses. Don't worry. You just need to install it!

Windows Users

1. Go to https://www.python.org/downloads in your web browser.
2. Click the yellow "Download Python 3.12.x" button. (The version number may be slightly different)
3. Run the downloaded installer file.
4. ⚠️ Important: Make sure to check the "Add Python to PATH" checkbox at the bottom of the installation screen!
5. Click "Install Now".
6. When the installation is complete, click "Close".

Mac Users

Mac may have Python pre-installed, but I recommend installing the latest version.

1. Go to https://www.python.org/downloads in your web browser.
2. Click the "Download Python 3.12.x" button.
3. Double-click the downloaded .pkg file.
4. Follow the installation wizard and click "Continue", "Agree", and "Install".
5. Enter your Mac password and complete the installation.

Verifying the Installation

Let's verify that Python is installed correctly.

Windows: Search for "cmd" in the Start menu to open Command Prompt.
Mac: Search for "Terminal" in Spotlight (Cmd + Space) to open Terminal.

In the black (or white) window that opens, enter the following command and press Enter:

python --version

Or if the above command doesn't work on Mac:

python3 --version

If version information like Python 3.12.x appears on the screen, you're successful!

💡 Troubleshooting: If you see a message saying "python not found", restart your computer and try again. If it still doesn't work, reinstall Python, making sure to check the "Add Python to PATH" option.

4. Installing Required Packages: Filling Your Toolbox

Now that you've installed Python, you need to install the tools to create an AI agent. This process is done through pip, a package manager. pip is automatically installed when you install Python.

Enter the following command in your terminal (or command prompt):

pip install anthropic python-dotenv

If you're a Mac user and the above command doesn't work:

pip3 install anthropic python-dotenv

Press Enter and the installation will begin. You'll see multiple lines of text moving quickly across the screen. This is normal!

When the installation is complete, you'll see a message like Successfully installed anthropic-x.x.x python-dotenv-x.x.x.

What you just installed:

• anthropic: The official library for communicating with Claude AI
• python-dotenv: A tool for safely managing API keys

5. Creating a Project Folder: Organizing Your Workspace

Now let's create a dedicated folder for your AI agent project. An organized workspace is the start of efficient development.

On Windows

mkdir ai-agent-project
cd ai-agent-project

On Mac

mkdir ai-agent-project
cd ai-agent-project

mkdir is the command to create a new folder, and cd is the command to navigate into that folder.

While you sleep, someone is running 21 employees without paying them a dime.

Think of a bakery. At 4 AM, you knead, ferment, bake, and display. The same routine every day. But what if the owner did all this herself? Burnout in 3 months. That's why smart owners buy a "kneading machine"—a device that automatically kneads with a single button press. That's a bot.

Bot = A digital employee performing repetitive work for you 24/7

Writing, creating images, uploading to social media, organizing data. If you repeat something 10 times, you need 1 bot. 100 times? 10 bots. Simple math.

I currently run 21 bots. Content planning bot, draft writing bot, image generation bot, blog posting bot, YouTube script bot... what these produce in a day is what took the old me 2 weeks alone. They work while I sleep. No complaints, no salary.

The core of this system is the AITF API Content Engine. It connects OpenAI, Claude, and image AI into a single automation pipeline. One command and the entire process—planning→writing→editing→publishing—runs automatically.

Even this article was drafted by a bot. You're still doing it by hand.

Is your company's chatbot still repeating "I'm sorry, I don't understand"?

That's a bot. Not an agent.

"A bot is an automated voice system following a preset script. An agent is a junior employee who thinks and acts on its own."

The core difference is the ReAct loop. Think (Reasoning) → Act (Action) → Observe (Observation). It runs this cycle endlessly. A bot ends with one "question-answer" exchange, but an agent repeats the loop until it achieves its goal.

Three weapons of an agent:

1. Memory – Remembers yesterday's conversation and last month's request
2. Judgment – Decides on its own, "That's the finance team's domain"
3. Tools – Directly executes Slack notifications, database queries, email sends

Real Case: Limitlessman Management Support Agent (Currently Operating)

One line Telegram command → 15,723 document Notion KB search → 9 autonomous Tool Use executions → result report. Example: "Summarize this month's meetings" → calendar check → meeting notes search → AI summary → Telegram send. If a person does it: 30 minutes. An agent does it: 8 seconds.

"Agents don't wait for 'perfect commands.' Give them a goal and they find their own path."

Looking at the Limitlessman team composition above, I see a pattern. Each agent and bot has one clear role. Management support makes decisions, content creates, email sends. This separation makes the system maintainable.

The 3 Types of Bots — Collector Bots, Generator Bots, Executor Bots

"Why does my bot always end up broken?"

When most people attempt automation, they make the same mistake first: putting every function into one bot. They try to do data collection, writing, and posting all at once. The result? Undebugable spaghetti code and giving up in 3 days.

Think of an army. Can an army win if scouts also fight battles and communications specialists also handle supplies? Absolutely not. An army without clear role division always loses.

Bots are the same. According to McKinsey's 2024 automation research, bot systems with clearly separated roles have 67% lower maintenance costs and 3.4x fewer errors compared to single integrated bots. Today, I'll help you perfectly understand the 3 roles of bots and walk away with practical code.

1. Collector Bot: The Scout's Role

The collector bot is the army's scout. It infiltrates enemy territory (the internet) and brings back intelligence (data). It doesn't fight directly. It only gathers information. And quietly returns.

"What happens when scouts also fight battles? They die. What happens when collector bots also generate? They crash."

Core functions of collector bots:

1. Web page crawling (news, blogs, communities)
2. API data collection (Twitter, YouTube, government open APIs)
3. RSS feed monitoring
4. Data cleaning and storage

According to a Gartner 2024 report, 89% of enterprise data is unstructured data (text, images, video). Just collecting and cleaning this data creates tremendous value.

Practical Python Code: News Headline Collector Bot

import requests
from bs4 import BeautifulSoup
import json
from datetime import datetime

class CollectorBot:
    """
    Collector bot: handles only data collection
    - No generation X, no posting X
    - Follows Single Responsibility Principle (SRP)
    """
    
    def __init__(self, source_name: str):
        self.source_name = source_name
        self.collected_data = []
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
    
    def collect_from_rss(self, rss_url: str) -> list:
        """Collect data from RSS feed"""
        try:
            response = requests.get(rss_url, headers=self.headers, timeout=10)
            response.raise_for_status()
            
            soup = BeautifulSoup(response.content, 'xml')
            items = soup.find_all('item')
            
            for item in items[:10]:  # Latest 10 only
                data = {
                    'title': item.find('title').text if item.find('title') else '',
                    'link': item.find('link').text if item.find('link') else '',
                    'description': item.find('description').text if item.find('description') else '',

Core principle: The collector bot never processes or publishes data. It collects → saves only. Following this principle ensures the next bot (generator bot) can be independently replaced.

"Think, act, and observe" — this is the core method by which AI agents solve complex problems. In this chapter, I'll help you understand the essence of the ReAct pattern and implement it directly.

📖 1. What is ReAct? — How a Detective Solves a Case

ReAct is a compound of "Reasoning + Acting". This pattern, announced by Google and Princeton University in 2022, enables LLMs to go beyond simply generating answers and think while acting.

AI agents work the same way. When a user asks "Tell me tomorrow's weather in Seoul," the agent:

1. Think: "I need weather information. I should call the weather API."
2. Act: Call the tool search_weather("Seoul", "tomorrow")
3. Observe: "Tomorrow in Seoul: clear, high 24°C, low 15°C"
4. Conclude: Provide the user with a friendly weather report

🔄 2. Thought → Action → Observation: Perfect Understanding of 3 Steps

💭 Step 1: Thought (Thinking)

At this stage, the LLM analyzes the current situation and reasons about what to do next. The key point is that this process becomes explicitly visible.

# Thought Example
"""
Thought: The user asked about the latest AI trends. 
My training data contains outdated information, so I need to 
search the web to get current information for an accurate answer.
"AI trends 2024" seems like an appropriate search query.
"""

⚡ Step 2: Action (Acting)

Based on my thinking, I call actual tools. Tools can take various forms: web search, file reading/writing, calculations, API calls, and more.

# Action Example
{
    "tool": "search_web",
    "parameters": {
        "query": "AI trends 2024",
        "num_results": 5
    }
}

👁️ Step 3: Observation (Observing)

I receive and analyze the results of tool execution. This result becomes the input for the next Thought.

# Observation Example
"""
Observation: I received 5 search results.
1. "2024 AI Trends: The Rise of Multimodal AI" - TechNews
2. "Generative AI Improves Corporate Productivity by 30%" - Forbes
3. "AI Agents Named Most Notable Technology of 2024" - Gartner
...
"""

💻 3. Practical Python Code: Implementing ReAct Loop Directly

Now I'll move beyond theory and implement an actual working ReAct agent. If you follow along step by step, you can create your own agent.

📦 3.1 Defining Tools

import json
import os
from datetime import datetime
from typing import Any, Callable
import anthropic

# =============================================================
# Tool Definition - Functions the agent can use
# =============================================================

def search_web(query: str, num_results: int = 3) -> str:
    """
    Simulates web search functionality
    In actual production, use Google Search API, Bing API, etc.
    """
    # Simulated search results (actual implementation calls API)
    simulated_results = {
        "AI trends 2024": [
            {"title": "2024 AI Trends Report", "snippet": "Multimodal AI and AI agents are gaining attention."},
            {"title": "Generative AI Market Outlook", "snippet": "Generative AI market expected to grow 40% year-over-year in 2024"},
            {"title": "AI Regulatory Trends", "snippet": "EU AI Act comes into full effect starting 2024."}
        ],
        "Python best practices": [
            {"title": "Python Best Practices", "snippet": "Type hinting and virtual environment usage recommended."}
        ]
    }
    results = simulated_results.get(query, [{"title": f"'{query}' search results", "snippet": "Found related information."}])
    return "\n".join([f"- {r['title']}: {r['snippet']}" for r in results[:num_results]])

🔄 3.2 ReAct while Loop — 3-Turn Implementation

Now for the core. This is the actual code that repeats think→act→observe in a while loop.
The loop terminates when Claude determines that no more tools are needed.

import anthropic, os

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

TOOLS_DEF = [{
    "name": "search_web",
    "description": "Search the internet for latest information",
    "input_schema": {
        "type": "object",
        "properties": {"query": {"type": "string", "description": "Search query"}},
        "required": ["query"]
    }
}]

def run_react_loop(task: str, max_turns: int = 5) -> str:
    """ReAct loop: think→act→observe repeated"""
    messages = [{"role": "user", "content": task}]
    turn = 0

    while turn < max_turns:
        turn += 1
        print(f"\n{'='*40}")
        print(f"[Turn {turn}] Claude thinking...")

        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=TOOLS_DEF,
            messages=messages
        )

        # ── Termination condition: final answer without tools ──
        if response.stop_reason == "end_turn":
            final = response.content[0].text
            print(f"[Complete] {final[:100]}...")
            return final

        # ── Tool call handling ──
        messages.append({"role": "assistant", "content": response.content})
        tool_results = []

        for block in response.content:
            if block.type == "tool_use":
                print(f"[Action] {block.name}({block.input})")      # Observation 1: Which tool?
                result = search_web(**block.input)                 # Execute actual tool
                print(f"[Observation] {result[:120]}...")           # Observation 2: Check result
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        messages.append({"role": "user", "content": tool_results})

    return "Maximum turns exceeded — failed to reach conclusion"

# Execution Example
if __name__ == "__main__":
    answer = run_react_loop("Search for the latest AI agent trends in 2026 and summarize in 3 lines")
    print(f"\nFinal Answer:\n{answer}")

📱 Chapter 4: Build Your First AI Agent Yourself in 10 Minutes

🔧 Before You Start: Pre-Flight Checklist

Let's prepare what you need before writing code. 5 minutes is plenty.

Getting Your Anthropic API Key

1. Visit console.anthropic.com
2. Sign up or log in
3. Click "Create Key" in the API Keys menu
4. Copy the generated key to a safe location (starts with sk-ant-)

Creating a Telegram Bot (2 minutes)

1. Search for @BotFather on Telegram and start a conversation
2. Enter /newbot
3. Enter a bot name (example: "My AI News Bot")
4. Enter a bot username (example: my_ai_news_bot) - must end with _bot
5. Save the token you receive (number:letter format)

Getting Your Telegram Chat ID

1. Send any message to the bot you just created
2. Access the following URL in your browser:
   https://api.telegram.org/bot{bot_token}/getUpdates
3. In the JSON response, find "chat":{"id":number} - that number is your chat ID

First, I'll install the required libraries. Run this in your terminal:

Now I'll create a function to collect news. I'll use Google News RSS to fetch AI-related news headlines.

import os
import anthropic
import requests
from bs4 import BeautifulSoup

def fetch_news_headlines(query="AI 인공지능", num_headlines=10):
    """Collect news headlines from Google News RSS"""
    url = f"https://news.google.com/rss/search?q={query}&hl=ko&gl=KR&ceid=KR:ko"
    try:
        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.content, 'xml')
        items = soup.find_all('item')[:num_headlines]
        headlines = []
        for item in items:
            title = item.title.text   if item.title   else ""
            link  = item.link.text    if item.link    else ""
            pub   = item.pubDate.text if item.pubDate else ""
            headlines.append({"title": title, "link": link, "date": pub})
        return headlines
    except Exception as e:
        print(f"Collection error: {e}")
        return []

def summarize_with_claude(headlines: list) -> str:
    """Summarize news in 3 lines with Claude Haiku — fast and affordable"""
    client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
    headline_text = "\n".join([f"- {h['title']}" for h in headlines])
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=500,
        messages=[{"role": "user",
                   "content": f"Summarize the following AI news headlines in 3 lines:\n{headline_text}"}]
    )
    return response.content[0].text

if __name__ == "__main__":
    print("Collecting AI news...")
    headlines = fetch_news_headlines("AI 인공지능", 10)
    if headlines:
        print(f"Collected {len(headlines)} headlines\n")
        print("Claude summary:\n", summarize_with_claude(headlines))
    else:
        print("Failed to collect news")

Prompt Chaining in Practice — A Output → B Input → C Output

Why does your prompt fall short every single time?

Because you're asking for everything at once.

It's like telling a bakery apprentice: "Mix the dough while making the cream and packaging at the same time." The result? Mediocre bread, messy cream, torn packaging.

Prompt chaining is different.

A's output becomes B's input, and B's output becomes C's input. Like a factory conveyor belt. Each step handles one job perfectly.

"Breaking down complex tasks into chains improves accuracy by an average of 47%" — Anthropic Prompt Engineering Guide 2024

By the end of this article, you'll have a system that takes one blog post and automatically produces SNS content and newsletter introductions.

1. Why Prompt Chaining is 3x Better — The Data Speaks

First, the uncomfortable truth.

The limitations of simple prompts (entering all requirements at once) are clear. According to Anthropic research, when handling complex tasks with a single prompt, accuracy often drops below 40%.

Why?

LLMs are vulnerable to "instruction overload." Once a prompt contains five or more requirements, the model ignores later instructions or produces results that don't add up.

Stanford HAI's 2024 report puts it this way:

"Most performance degradation in large language models stems not from model limitations themselves, but from prompt design issues."

Three overwhelmingly powerful advantages of chaining:

First, improved accuracy. According to Anthropic guidelines, breaking complex workflows into chains reduces errors at each step, resulting in an average 47% improvement in overall accuracy.

Second, debugging becomes easier. When results are wrong with a single prompt, where's the problem? With chaining, you immediately identify which step went wrong. It's like a factory's quality control process.

Third, reusability. Each step in a chain you build once can be reused in other projects. Build an "SNS summary node" once, and you just swap the input for any blog post.

McKinsey Digital 2024 Survey Results:

What did the top 20% of companies implementing AI have in common? They were using chaining-based workflows. Only companies going beyond simple "ask ChatGPT" are seeing real ROI.

Gartner's 2024 forecast is even more direct:

"By 2026, 70% of enterprise AI applications will adopt multi-step agent architecture."

You might be the only one who doesn't know. Right now, your competitors are using chaining to triple their content production speed.

2. 3-Step Chaining Python Code — Blog→SNS→Email

Theory is over. Now it's time for practice.

The code below is a complete, working program. You can copy and run it immediately.

Goal:

1. Generate blog post (1500 characters)
2. Blog post → SNS 3-line summary
3. SNS summary → Email newsletter introduction

import os
import anthropic

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def call_claude(prompt: str, max_tokens: int = 2000) -> str:
    """Claude API call helper"""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=max_tokens,
        system="You are a professional content writer.",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

# STEP 1: Generate blog post (1500 characters)
def generate_blog(topic: str) -> str:
    return call_claude(
        f"Write a 1500-character blog post on the following topic\nTopic: {topic}\nStructure: Introduction→3 main points→Conclusion"
    )

# STEP 2: Blog → SNS 3-line summary
def blog_to_sns(blog: str) -> str:
    return call_claude(
        f"Convert the following blog into a 3-line SNS summary (50 characters per line, 3 hashtags on the last line):\n{blog[:400]}",
        max_tokens=200
    )

# STEP 3: SNS → Email newsletter introduction
def sns_to_email(sns: str) -> str:
    return call_claude(
        f"Convert the following SNS into an email newsletter introduction (200 characters, designed to drive reader clicks):\n{sns}",
        max_tokens=300
    )

# Run pipeline
if __name__ == "__main__":
    topic = "How AI Agents Transform Work Automation"

    blog  = generate_blog(topic)
    print(f"[Blog] {len(blog)} characters complete\n")

    sns   = blog_to_sns(blog)
    print(f"[SNS]\n{sns}\n")

    email = sns_to_email(sns)
    print(f"[Email Introduction]\n{email}")
# Run: python chaining.py

Master the 4 Types of Agent Memory — Files, DB, Vector DB, Context

Why your AI agent is dumb. It has no memory. Same answer to the same question every time. Can't remember yesterday's conversation today. Forgets user names. This is dementia-level.

According to Anthropic's 2024 AI Agents report, 73% of production agents experience declining user satisfaction due to lack of memory systems. Conversely, agents with proper memory systems have 3.2x higher revisit rates.

The human brain also has different types of memory. Instant memory, short-term memory, long-term memory, semantic memory. AI agents work the same way. Once you understand the 4 memory systems, your agent can say things like "Oh, you're the person who asked me for coffee recommendations last time."

Let me explain with a bakery analogy. Imagine you're running a neighborhood bakery.

• Recipe book (file memory) — Regular customer names and allergy information written directly on paper. It stays in the drawer even after closing the shop.
• Employee note (DB memory) — Order ledger. When, who, what, and how much was purchased—systematically recorded and searchable. You can find records from 3 years ago.
• Customer preference card file (vector DB) — Search for "customers who like extra cream" and similar-preference customers come up in a list. Semantic search.
• Today's orders (context) — The conversation happening right in front of you now. It resets once the customer leaves.

Today I completely master these 4 systems with practical code.

1. Context Memory — How to Remember This Conversation Right Now

This is the most basic. But 90% of people use it wrong.

Context memory is memory that persists only during the current conversation session. The messages array in Claude API is exactly this. Once the conversation ends, it disappears. Close the browser tab, and it's gone.

"But isn't it a waste of tokens to send the entire conversation every time?"

That's right. So strategy is needed.

Practical Code for Maintaining Conversation with Claude API

import anthropic

client = anthropic.Anthropic()

# Manage conversation history as a list
conversation_history = []

def chat(user_message: str) -> str:
    """Function to continue conversation"""
    
    # Add user message
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    # Pass entire conversation history to Claude
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="You are a friendly coffee expert. Remember previous conversations.",
        messages=conversation_history
    )
    
    assistant_message = response.content[0].text
    
    # Add assistant response to history
    conversation_history.append({
        "role": "assistant", 
        "content": assistant_message
    })
    
    return assistant_message

# Actual usage
print(chat("I like americano"))
# → "I see you like americano! Do you prefer higher acidity?"

print(chat("Yeah, I like sourness"))  
# → "Got it! I'd recommend Ethiopian Yirgacheffe. 
#    Since you like americano and enjoy acidity, it's perfect for you."

print(chat("What did I say I like?"))
# → "You said you like americano and acidic coffee!"

The key is accumulation of the messages array. Every time you call the API, you send the entire previous conversation together. Claude reads this history and understands the context.

Token Management — Sliding Window

There's a problem. What if the conversation goes over 100 turns? Token explosion. Claude Sonnet 4.6's context window is 200K tokens, but it's not optimal in terms of cost and speed.

def manage_context_window(messages: list, max_messages: int = 20) -> list:
    """Keep only the last N conversations (sliding window)"""
    
    if len(messages) > max_messages:
        # Remove oldest conversation
        # But keep the first conversation as it may contain important context
        return [messages[0]] + messages[-(max_messages-1):]
    
    return messages

def chat_with_management(user_message: str) -> str:
    global conversation_history
    
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    # Apply context management
    managed_history = manage_context_window(conversation_history)
    
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="You are a friendly coffee expert.",
        messages=managed_history
    )
    
    assistant_message = response.content[0].text
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })

Pros and Cons of Context Memory

2. File Memory — Remembering After Restart (JSON)

To retain memory after conversations end, I need to save to a file. A single JSON file is enough. It's like writing a regular customer's name on a notepad.

import json, os, anthropic
from datetime import datetime

MEMORY_FILE = "user_memory.json"

def load_memory(user_id: str) -> dict:
    if os.path.exists(MEMORY_FILE):
        data = json.load(open(MEMORY_FILE, encoding="utf-8"))
        return data.get(user_id, {"name": "", "history": []})
    return {"name": "", "history": []}

def save_memory(user_id: str, memory: dict):
    data = {}
    if os.path.exists(MEMORY_FILE):
        data = json.load(open(MEMORY_FILE, encoding="utf-8"))
    data[user_id] = memory
    json.dump(data, open(MEMORY_FILE, "w", encoding="utf-8"), ensure_ascii=False, indent=2)

def chat(user_id: str, message: str) -> str:
    memory = load_memory(user_id)
    client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
    system = f"User name: {memory['name'] or 'Unregistered'}. Recent history: {memory['history'][-3:]}"
    response = client.messages.create(
        model="claude-haiku-4-5-20251001", max_tokens=300,
        system=system, messages=[{"role": "user", "content": message}]
    )
    reply = response.content[0].text
    memory["history"].append({"time": datetime.now().isoformat(), "user": message, "bot": reply})
    memory["history"] = memory["history"][-20:]  # Keep only recent 20 entries
    save_memory(user_id, memory)
    return reply

if __name__ == "__main__":
    uid = "user_001"
    print(chat(uid, "My name is Kim Chulsu"))
    print(chat(uid, "What's my name?"))  # ← It remembers!
# Run: python file_memory_bot.py

3. DB Memory — Systematic Management of Thousands of Users (SQLite)

Files slow down when there are many users. SQLite is a built-in Python DB with no installation needed. It's perfect for services with under 10,000 users.

import sqlite3, os

DB_FILE = "agent_memory.db"

def init_db():
    conn = sqlite3.connect(DB_FILE)
    conn.execute("""CREATE TABLE IF NOT EXISTS memory (
        user_id TEXT, key TEXT, value TEXT,
        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
        PRIMARY KEY (user_id, key)
    )""")
    conn.commit(); conn.close()

def set_memory(user_id: str, key: str, value: str):
    conn = sqlite3.connect(DB_FILE)
    conn.execute("INSERT OR REPLACE INTO memory(user_id,key,value) VALUES(?,?,?)",
                 (user_id, key, value))

    conn.commit(); conn.close()

def get_memory(user_id: str, key: str) -> str:
    conn = sqlite3.connect(DB_FILE)
    row = conn.execute("SELECT value FROM memory WHERE user_id=? AND key=?",
                       (user_id, key)).fetchone()
    conn.close()
    return row[0] if row else ""

if __name__ == "__main__":
    init_db()
    set_memory("user_001", "name", "Kim Chul-su")
    set_memory("user_001", "preference", "Prefer Americano")
    print(get_memory("user_001", "name"))        # Kim Chul-su
    print(get_memory("user_001", "preference"))  # Prefer Americano
# Run: python db_memory_bot.py

4. Vector DB Memory — Semantic Search for "Similar Content" (ChromaDB)

Files and databases search by exact keywords only. Vector DBs search by semantic similarity. When I input "recommend coffee," it finds my memory "prefer Americano"—that's vector DB. It's the core of RAG.

import os, chromadb  # pip install chromadb
import anthropic

chroma = chromadb.Client()
col = chroma.get_or_create_collection("user_memories")

def add_memory(user_id: str, content: str, doc_id: str):
    col.add(documents=[content], ids=[f"{user_id}_{doc_id}"],
            metadatas=[{"user_id": user_id}])

def recall(user_id: str, query: str, n=3) -> list:
    """Search memories by semantic similarity"""
    results = col.query(query_texts=[query], n_results=n,
                        where={"user_id": user_id})
    return results["documents"][0] if results["documents"] else []

if __name__ == "__main__":
    add_memory("u1", "User prefers Americano", "pref_coffee")
    add_memory("u1", "Completed AI agent project last week", "proj_001")
    add_memory("u1", "5 years experience as Python developer", "profile")

    print(recall("u1", "What's my coffee preference?"))
    # → ['User prefers Americano']  ← Searched by meaning, not keywords!
# Run: python vector_memory_bot.py

4 Memory Methods Compared — When to Use What

Human-in-the-Loop Design — Telegram Approval Button in Practice

The AI sent a vulgar email to the CEO.

This actually happened at a startup in 2023. An automated AI assistant was responding to customer complaints when a sentiment analysis error caused it to send "Your request is unreasonable" to the CEO's personal email. The result? A multimillion-dollar contract was lost.

This isn't an extreme case. 68% of teams that deployed AI agents in production experienced problems from "unintended automated execution" (Gartner, 2024). The smarter the AI becomes, the greater the fallout from poor decisions.

The solution? Human-in-the-Loop (HITL). A person clicks an approval button before important actions execute. Today, you'll implement this with a Telegram bot in 30 minutes.

1. Real Incidents When HITL Is Missing

Let me start with an analogy. An AI agent is like a new employee. Enthusiastic, hardworking, but capable of blowing up the meeting room sometimes. When you say "send an email to the customer," the new hire might interpret it as:

"Send email to all customers!" → Spam sent to 100,000 people

Real incident examples:

Case 1: Incorrect Email Auto-Send (2023)
A SaaS company's AI customer support bot was auto-responding to refund requests when it should have sent "refund not possible," but instead sent "full refund approved." Context comprehension failure. Thirty-two incorrect refund promises went out in that week alone, and the company faced legal disputes.

Case 2: Stock Trading AI Goes Rogue (2024)

An individual investor created an automated trading agent that received a "minimize losses" command and sold all holdings at the lowest point. The AI reported "losses reduced to zero." Technically correct. It reduced the "possibility" of losses to zero. 2 million won became 400,000 won.

Case 3: Calendar Agent's Meeting Massacre (2023)
In response to a "optimize my schedule" command, the AI judged 15 meetings to be inefficient and canceled them. Three of them were investor meetings.

Do you see the pattern? AI performs commands "well." It just executes its "interpretation" of your intent, not your intent itself.

# Simple example showing why this is dangerous
def send_email(to: str, subject: str, body: str):
    # If AI calls this function directly?
    # It's irreversible. The email is already sent.
    email_service.send(to, subject, body)
    return "Send Complete"  # No cancel button

# HITL applied version
def request_email_approval(to: str, subject: str, body: str):
    # Show to human first and wait for approval
    pending_actions.create(
        action_type="send_email",
        params={"to": to, "subject": subject, "body": body},
        status="PENDING"
    )
    notify_human("There is an email send request. Please review it.")
    return "Awaiting Approval"  # Not sent yet!

2. MIT Research Data: The Magic of AI+Human Collaboration

"Can't we just make AI smarter?"

No. Research proves it.

According to MIT Sloan School of Management (2023) research, compared to AI-only decision-making, the error rate decreased by 73% in Human-in-the-Loop structures. The effect was maximized particularly in "high-risk judgment" domains.

Let's look at the numbers:

□ AI-Only Decision-Making
- General task accuracy: 89%
- High-risk task accuracy: 67%
- Fatal error rate: 12%

□ AI + Human-in-the-Loop
- General task accuracy: 91% (+2%)
- High-risk task accuracy: 94% (+27%)
- Fatal error rate: 3.2% (-73%)

Why is there such a difference? Analysis from Stanford HAI (Human-Centered AI) Institute:

"AI excels at pattern recognition but must rely on human common sense for exceptional situation judgment. HITL is the optimal structure combining AI's strengths (speed, consistency) with human strengths (contextual understanding, ethical judgment)."
— Stanford HAI, Human-AI Collaboration Report (2023)

Multi-Agent Team Structuring

An ordinary three working collaboratively beats a lone genius.

The same applies to AI. Stanford HAI 2024 research proved it. Multi-agent systems are 40% more accurate and 35% more creative than single agents. Why?

"If you make one LLM do everything, it ultimately does nothing well."
— Stanford HAI, "Multi-Agent Collaboration Benchmark" (2024.03)

What I'm giving you today isn't theory. It's a 3-agent team you can copy and use right now. Trend researcher → Data analyst → Content writer. This one pipeline automates all reports, blogs, and market research.

1. Why is Multi-Agent 40% More Accurate?

I'll explain the limitations of a single agent using a bakery analogy.

A bakery owner does everything alone—mixing dough, baking, packaging, and taking payments. If just 3 customers show up, it all falls apart. While mixing dough, they forget about the oven; while calculating payments, they burn the bread.

This is the "putting everything into one prompt" approach.

3 Key Findings from Stanford Research

First, role separation reduces cognitive load.

When you tell GPT-4 "research and analyze and write," 70% of tokens are wasted deciding "what mode should I operate in?" When you separate roles? Each agent achieves 100% focus.

Second, mutual validation catches hallucinations.

The researcher finds data, and the analyst asks "is this correct?" The analyst's insights get verified by the writer asking "is there evidence?" Three-layer filtering reduced hallucination rate by 67%.

Third, expertise simulation improves quality.

The persona "you're a data analyst with 10 years of experience" actually works. In MIT research, LLMs given expert personas showed 28% higher performance on domain-specific tasks.

Actual numbers: Stanford benchmark results
- Complex research task accuracy: single agent 62% vs. multi-agent 87%
- Logical consistency score: single 71 points vs. multi 94 points
- Task completion time: single 45 seconds vs. multi 52 seconds (7 more seconds for 40% quality improvement)

7 more seconds for 40% better accuracy. Not making this trade-off is foolish.

2. Complete Python Code for the 3-Person Team

Theory is done. Copy and run this right now.

The structure is simple:

□ TrendResearcher: Receives a topic and researches 5 latest trends
□ DataAnalyst: Receives trends and derives insights
□ ContentWriter: Receives insights and writes a blog post

import os
from openai import OpenAI
from dataclasses import dataclass
from typing import List, Dict, Any
import json

# ═══════════════════════════════════════════
# Agent Base Class
# ═══════════════════════════════════════════

@dataclass
class AgentOutput:
    """Agent output standard format"""
    agent_name: str
    task: str
    result: Dict[str, Any]
    metadata: Dict[str, Any]
    
    def to_json(self) -> str:
        return json.dumps({
            "agent": self.agent_name,
            "task": self.task,
            "result": self.result,
            "metadata": self.metadata
        }, ensure_ascii=False, indent=2)
    
    @classmethod
    def from_json(cls, json_str: str) -> 'AgentOutput':
        data = json.loads(json_str)
        return cls(
            agent_name=data["agent"],
            task=data["task"],
            result=data["result"],
            metadata=data["metadata"]
        )


class BaseAgent:
    """Parent class for all agents"""
    
    def __init__(self, name: str, role: str, model: str = "gpt-4o"):
        self.name = name
        self.role = role
        self.model = model
        self.client = OpenAI()
        
    def _create_system_prompt(self) -> str:
        return f"""You are a {self.role}.

[Behavioral Principles]
1. Always respond in structured JSON format
2. Include sources or evidence for all claims
3. Explicitly mark uncertain information
4. Provide concise and actionable information"""
    
    def execute(self, task: str, context: Dict = None) -> AgentOutput:
        """Execute task - each agent overrides this"""
        raise NotImplementedError


# ═══════════════════════════════════════════
# 1. Trend Researcher Agent (inheriting from BaseAgent)
# ═══════════════════════════════════════════

Limitlessman's Practical Guide — 9 Complete Business Support Agent Tool Use Disclosures

Theory is enough. From now on, I'm publicly releasing the core code of the business support agent that Limitlessman is actually operating. Tool Use is the agent's hands and feet—without it, the LLM is just a thinking brain.

9 Complete Tools List — Limitlessman Business Support Agent

Autonomous Execution Loop — run_agent() Core Code

def run_agent(task: str, client, max_turns: int = 10) -> str:
    """
    Claude Tool Use ReAct loop
    task → Claude judgment → tool execution → Claude re-judgment → ... → completion
    """
    messages = [{"role": "user", "content": task}]
    turn = 0

    while turn < max_turns:
        turn += 1
        print(f"[Turn {turn}] Claude evaluating...")

        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            system=SYSTEM_PROMPT,   # Role + security principles + tool usage guidelines
            tools=TOOLS,            # Pass 9 tool schemas
            messages=messages
        )

        # ① Completion — Claude determines the task is complete
        if response.stop_reason == "end_turn":
            final = next((b.text for b in response.content if hasattr(b, "text")), "Complete")
            print(f"Task completed ({turn} turns)")
            return final

        # ② Tool invocation — Claude selects a tool to execute
        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})

            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  Executing tool: {block.name}({block.input})")
                    result = execute_tool(block.name, block.input)  # Actual execution
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result          # Return result to Claude
                    })

            messages.append({"role": "user", "content": tool_results})
            # → Loop repeats: Claude reviews results and makes next decision

    return "max_turns exceeded"

Shared Memo Between Agents — The Real Structure of Multi-Agent Collaboration

# Dev team agent discovers bug → Records in shared memo
write_memo("dev_team", "Authentication token expiration bug found in login.py logic. Fix needed.")

# Operations agent reads memo and auto-reports to CEO
memo = read_memo()
# → "dev_team: Authentication token expiration bug found in login.py logic..."

send_email(
    to="ceo@janda.com",
    subject="[Auto Report] Dev Team Issue Detected",
    body=f"Auto-detected by agent:\n\n{memo}"
)

Going Further — Framework Selection Guide

As multi-agent systems grow, using a dedicated framework beats building from scratch. 2026 benchmark—3 leading frameworks compared:

Your AI agent could be incurring charges right now, at this very moment.

I've been there too. I deployed a test agent one evening, went to sleep, and woke up to an API bill of $470. My agent got stuck in an infinite loop overnight, calling GPT-4 2,000 times. Think of it like a bakery: I told an employee "bake some bread," and they baked 5,000 loaves by dawn, blowing through all the ingredient budget.

"An agent without a harness is like a car without brakes."

Let me explain this precisely with a health inspector analogy. A health inspector visits the kitchen every day with a checklist. They verify refrigerator temperature, expiration dates, employee hygiene—checking and documenting each item. If they find a problem, they shut down operations immediately. A harness does exactly that for AI agents. It monitors in real-time which APIs your agent is calling, how many times, whether outputs are within normal range, and whether sensitive data is leaking—and it stops everything instantly if something seems wrong.

The AITF Security 5-Factor Framework stops this:

1. Supervisor — Monitors every action of the agent in real-time. Suspicious activity detected? Intervene immediately.

2. Input Guard — Filters incoming commands before processing. Blocks prompt injection and malicious requests at the source.

3. Output Guard — Validates outgoing responses. Prevents sensitive information leakage and abnormal outputs.

4. Escalation Protocol — Automated response based on risk level. Warning → Restriction → Forced termination in stages.

5. Audit Logger — Records everything. When problems occur, you can trace the root cause and clarify accountability.

The AITF API Security Guard integrates all five elements into a single layer. Deploy it in front of your agent and you capture the three major risks in one shot: billing runaway, prompt hacking, and data leakage.

Running agents without a harness right now? That's like scratching lottery tickets every day. You just don't know when it'll blow up.

5 Security Checkpoints Every CTO Must Verify When Adopting at the Enterprise Level

Unlike startups, enterprise environments don't accept "as long as it runs, we're good." Data compliance, corporate network isolation, and audit logs—you must design these three first to pass adoption review.

1. Data Outbound Transfer Control — What Leaves via API

Claude and GPT-4 are both external APIs. The moment customer names, contract amounts, or internal meeting notes end up in your prompt and go out the door, you fall under Personal Information Protection Act Article 17 (Third-party Disclosure).

# Mask sensitive data before API transmission
import re

def mask_pii(text: str) -> str:
    """Mask names, phone numbers, emails, and amounts"""
    text = re.sub(r'\d{3}-\d{4}-\d{4}', '[Phone Number]', text)
    text = re.sub(r'[\w.+-]+@[\w-]+\.\w+', '[Email]', text)
    text = re.sub(r'\d{1,3}(,\d{3})+', '[Amount]', text)
    return text

# Always mask before agent invocation
safe_prompt = mask_pii(raw_data)
response = client.messages.create(messages=[{"role":"user","content":safe_prompt}])

2. Corporate Network Isolation — On-Premises or VPC Deployment

3. Audit Log — "What the Agent Did" Must Always Be Recorded

import datetime, json

def audit_log(agent_name: str, tool: str, input_data: dict, output: str):
    """Compliance audit log — permanently immutable"""
    log_entry = {
        "timestamp": datetime.datetime.utcnow().isoformat() + "Z",
        "agent": agent_name,
        "tool_used": tool,
        "input_summary": str(input_data)[:200],   # Minimize personal information
        "output_summary": output[:200],
        "session_id": session_id
    }
    # Append-only storage to DB or S3
    with open("audit.jsonl", "a") as f:
        f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")

4. ISMS·ISO 27001 Checkpoints

5. Prompt Injection Defense

# Defense against user input hijacking the system prompt
SYSTEM = "You are a customer service bot. Answer only refund policy questions."

def safe_query(user_input: str) -> str:
    # Block injection patterns
    blocked = ["ignore previous", "disregard", "새로운 지시", "시스템 프롬프트"]
    for pattern in blocked:
        if pattern.lower() in user_input.lower():
            return "부적절한 요청입니다."

    # Place user input in user role only (no system role mixing)
    return client.messages.create(
        system=SYSTEM,
        messages=[{"role": "user", "content": user_input}]
    ).content[0].text

# English tokenization example
"Hello, how are you?" → ["Hello", ",", " how", " are", " you", "?"]
# 6 tokens

# Korean tokenization example  
"안녕하세요, 잘 지내세요?" → ["안", "녕", "하", "세", "요", ",", " 잘", " 지", "내", "세", "요", "?"]
# 12 tokens (2x)

English: "Please summarize this article in 3 bullet points"
→ 9 tokens

Korean: "이 기사를 3개의 핵심 포인트로 요약해주세요"
→ 24 tokens

Cost difference: 2.67x

📦 Chapter 5: Creating AI Agents with n8n No-Code

1. What is n8n? "The magical tool for automating without developers"

🤔Have you ever thought like this?

• "Every morning I check the news and organize it—can't that happen automatically?"
• "When customer inquiries come in, I wish AI would draft an answer first..."
• "Can't I schedule a week's worth of Instagram posts all at once?"

n8n is a workflow automation tool that makes all of this possible without coding. When I connect nodes (function blocks) like assembling Lego blocks, I get a system where AI works 24 hours a day.

🆚 How is it different from Zapier and Make?

2. Installing n8n (3 methods)

Choose the most convenient method based on your computer skills:

Method A: n8n Cloud (Easiest) ⭐ Recommended for Beginners

▲ The n8n Cloud dashboard that appears after signup. Click Workflows in the left menu → "Create new workflow" to get started.

Method B: Docker Installation (Intermediate) ⭐ Recommended for Free Unlimited Use

If you have Docker Desktop installed, just run one line in your terminal:

▲ After running Docker, access localhost:5678 in your browser to see the initial account setup screen. Enter your email and password, then click Next.

Method C: npm Installation (Node.js Users)

If you already have Node.js installed:

Similarly, you can access it at http://localhost:5678.

3. First Workflow: RSS → Claude Summarization → Slack Notification

Now let's actually build it! This is a real-world project that you can complete within 30 minutes.

Node Configuration Guide

While you sleep, someone's system is already working.

Every morning at 7 a.m. There's something that rings before the alarm. It's the completion notification sent by an automated workflow. By the time you brew your coffee, a day's worth of work is already organized.

"Freedom isn't about having lots of time. It's about having a system that runs without you."

The daily_orchestrator.py that Limitlessman directly operates runs automatically at 7 a.m. every day and processes STEP 1~15 in order. Planning → Script → TTS → Video → Thumbnail → Upload → Notification all flow in one go. This is possible because the orchestrator connects every stage.

AITF API Workflow is like a bakery conveyor belt. Dough → Fermentation → Baking → Packaging. Bread comes out without human hands touching it. Your work is the same. Data collection → Analysis → Report → Delivery. Once designed, it runs on its own every day.

If you don't know this structure now, you'll be working late the same way a year from now.

Freedom isn't far away. Just one system running on its own at 07:00 is enough.

Limitlessman daily_orchestrator.py — 15 STEP Architecture Currently in Operation

This is not theory. This is the Limitlessman orchestrator that actually runs at 07:00 AM every day. STEP 1~15 flow in order, and even if one STEP fails, the entire system doesn't stop.

Daily Execution STEP (Regardless of day of week)

Conditional Execution STEP (By Day of Week)

Core Function — run_bot() : Orchestrator's Single Interface to Execute All Bots

def run_bot(script: Path, args: list, timeout: int = 300) -> tuple[int, str]:
    """
    Execute bot as subprocess — timeout + error capture
    Returns: (return_code, stdout)
    """
    if not script.exists():
        log(f"Script not found: {script.name}", "WARN")
        return -1, "File not found"          # SKIP — no full stop

    cmd = [PYTHON, str(script)] + [str(a) for a in args]
    log(f"Running: {script.name} {' '.join(str(a) for a in args)}")

    try:
        result = subprocess.run(
            cmd, capture_output=True, text=True,
            encoding="utf-8", errors="replace", timeout=timeout
        )
        if result.stdout:

log(result.stdout[-600:])          # Log only the last 600 characters
        if result.returncode != 0 and result.stderr:
            log(result.stderr[-300:], "WARN")
        return result.returncode, result.stdout

    except subprocess.TimeoutExpired:
        log(f"Timeout ({timeout} seconds)", "ERROR")
        return -2, "timeout"               # Timeout — no full shutdown

# Execution example — STEP 4: AI Hunter Shorts pipeline
rc4, _ = run_bot(BOT_SHORTS_AI, ["--topic", today_topic], timeout=300)

# Day-based conditional — Tue/Thu longform only
if IS_TUE_THU:
    rc9, _ = run_bot(BOT_LONGFORM, [], timeout=3600)    # Max 1 hour

# STEP 12: Report all results via Telegram
telegram(f"Limitlessman Daily Report\nSTEP4: {_icon(rc4)}\nSTEP9: {_icon(rc9)}")

Complete Production Deployment Flow — GitHub→Render→Scheduler→Monitoring

"It works fine on my computer."
The moment you say that, you're an amateur.

According to the Gartner 2024 report, 85% of AI projects fail at the production deployment stage. It's not the model. It's the deployment.

Today, I'll show you a complete deployment pipeline from local development to production that never breaks. Automate with GitHub Actions, deploy to Render, run with a scheduler, and protect it with monitoring. With actual code.

1. "Why It Works Locally But Breaks in Production" TOP 5

Let's diagnose first. Why does it break?

According to Microsoft Azure DevOps team's 2023 analysis, 78% of deployment failures aren't code problems—they're environment problems. Like a bakery: the recipe (code) is perfect, but the oven temperature (server environment) is different.

TOP 1: Missing Environment Variables (34% Failure Rate)

Locally, there's a .env file. On the server, there isn't. Done.

# Local: Works
OPENAI_API_KEY=sk-xxx  # Exists in .env file

# Server: Breaks
os.getenv("OPENAI_API_KEY")  # Returns None → 500 error

Solution: Mandatory environment variable check script before deployment.

# check_env.py
import os
import sys

REQUIRED_VARS = [
    "OPENAI_API_KEY",
    "DATABASE_URL", 
    "SECRET_KEY",
    "TELEGRAM_BOT_TOKEN"
]

missing = [var for var in REQUIRED_VARS if not os.getenv(var)]

if missing:
    print(f"❌ Missing environment variables: {missing}")
    sys.exit(1)
else:
    print("✅ All environment variables verified")

TOP 2: Dependency Version Conflicts (28% Failure Rate)

Locally numpy 1.24 is installed, on the server numpy 1.21 gets installed. Because you didn't specify the version in requirements.txt.

# ❌ Wrong approach
numpy
pandas
openai

# ✅ Correct approach (Version pinning)
numpy==1.24.3
pandas==2.0.3
openai==1.12.0

Pro tip: Don't use pip freeze > requirements.txt. It includes unnecessary packages. Use pip-tools instead.

TOP 3: Path Issues (19% Failure Rate)

On Windows it becomes C:\Users\you\project\data.csv. On a Linux server? Doesn't work.

# ❌ Absolute path (Windows)
file_path = "C:\\Users\\you\\project\\data.csv"

# ✅ Relative path (Works everywhere)
from pathlib import Path
BASE_DIR = Path(__file__).parent
file_path = BASE_DIR / "data.csv"

TOP 4: Memory/Timeout (12% Failure Rate)

Local PC has 32GB RAM. Render free tier has 512MB. Load a 1GB CSV with pandas? Instant death.

Anthropic's 2024 production guide says: "Start with the free tier, but optimize memory usage from the beginning."

TOP 5: Port/Network Configuration (7% Failure Rate)

# ❌ Local only
app.run(host="127.0.0.1", port=5000)
200000

# ✅ Production (External Access Allowed)
app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 5000)))

Render, Heroku, and Railway all automatically inject the PORT environment variable. Hard-coding it will break.

2. Step-by-Step Deployment Checklist

Just like military combat readiness inspections, deployment needs a checklist too. Here's a practical checklist borrowed from AWS's Well-Architected Framework.

□ Code Level Check (D-1 Before Deployment)

□ Remove print() statements (replace with logging)
□ No hard-coded API keys (verify with git log)
□ Wrap all external API calls in try-except
□ Set timeouts (requests.get(url, timeout=30))
□ Check memory usage (handle large files with streaming)
□ Run test code (pytest -v)
□ Pass linter (flake8 . --max-line-length=120)

□ Security Check (D-1 Before Deployment)

□ .gitignore includes .env, *.pem, secrets/
□ Verify past commits with git log --all --full-history -- "*.env"
□ API key rotation (changed this month?)
□ CORS settings — specify allowed domains (no *, no wildcards)
□ Rate limiting applied (max 60 requests per IP per minute)
□ SQL injection / Prompt injection defense verified

One-Person Company Complete Daily Workflow Automation — Time-Based Design

According to McKinsey's 2024 report, solo entrepreneurs work an average of 52 hours per week. Of that, 67% is repetitive work. Content creation, distribution, management, customer response — tasks requiring no creative judgment.

What happens when you tie these tasks together with an orchestrator? Real Limitlessman operations show: 8 hours of daily repetitive work compresses to 47 minutes of review. I'll show you the actual timeline.

Time-Based Automation Schedule: 06:00~23:00

A complete daily automation schedule for a one-person company.
Register this timeline in cron or a scheduler.
Your business runs while you sleep.

🌅 Early Morning (06:00 ~ 08:00) - Content Generation

06:00 - Generate 3 blog drafts (blog/create)
06:30 - Generate YouTube Shorts scripts (youtube/shorts)
07:00 - SEO analysis and keyword extraction (analyze/seo)
07:30 - Generate image prompts (image/prompt)

"Why generate content in the early morning?"
Publishing at 9 AM has 34% higher reach. (HubSpot 2024 data)
30 minutes to generate, 30 minutes to review, scheduled posting complete.

🌤️ Morning (09:00 ~ 12:00) - Deployment and Spread

09:00 - Auto-publish blog (blog/publish)
09:30 - Instagram posting (sns/instagram)
10:00 - Threads posting (sns/threads)
10:30 - YouTube Shorts upload (youtube/upload)
11:00 - Newsletter distribution (email/newsletter)
11:30 - Telegram notification "Morning deployment complete" (notify/telegram)

☀️ Afternoon (14:00 ~ 17:00) - Communication and Management

14:00 - Auto-reply to blog comments (comment/reply)
14:30 - Auto-respond to Instagram DMs (dm/auto-reply)
15:00 - Analyze YouTube comments and reply (youtube/comments)
15:30 - Monitor competitor content (analyze/competitor)
16:00 - Collect trending keywords (trend/keywords)
16:30 - Telegram notification "Afternoon tasks complete" (notify/telegram)

🌙 Evening (19:00 ~ 23:00) - Analysis and Preparation

19:00 - Generate daily performance report (report/daily)
20:00 - Generate 10 content ideas for tomorrow (idea/generate)
21:00 - Analyze A/B test results (analyze/ab-test)
22:00 - Update weekly content calendar (calendar/update)
23:00 - Send daily summary via Telegram (notify/telegram)

Key Point: 15 STEPS run automatically.
All you need to do is 30 minutes of review in the morning and 17 minutes checking reports in the evening.
Total 47 minutes.

2. Practical curl Command Examples by Product

Theory is done.
Now copy and paste into your terminal and execute it right away.
These are practical curl commands for the 5 core products of the AITF API.

📝 blog/create - Blog Draft Generation

curl -X POST "https://api.aitf.io/v1/blog/create" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "2026 AI Automation Trends",
    "keywords": ["AI automation", "solo entrepreneur", "productivity"],
    "tone": "professional_casual",
    "length": "2500",
    "include_data": true,
    "seo_optimize": true
  }'

Response Example:

{
  "status": "success",
  "content": {
    "title": "2026 AI Automation: 5 Things Every Solo Entrepreneur Must Know",
    "body": "## Introduction\n\nAccording to Gartner's forecast...",
    "meta_description": "2026 AI Automation Trends and Productivity Enhancement Strategy for Solo Entrepreneurs",
    "word_count": 2503,
    "seo_score": 87,
    "keywords_used": ["AI automation", "solo entrepreneur", "productivity"]
  },
  "generation_time_ms": 3241
}

Chapter 12: 30-Day AI Agent Completion Roadmap

"You are standing not at the end of a journey, but at the real starting point."

You have read every chapter in this book. Congratulations. But to be honest with you, simply reading a book won't change anything. Knowledge has value only when it is executed.

In this chapter, I present a concrete roadmap to turn everything you learned from the previous 11 chapters into an operationally viable system within 30 days. What to do each day, how long it takes, and how to solve problems when you're stuck—everything is here.

🎯 What You Will Have After 30 Days

Before starting the roadmap, let's clarify what you'll look like after 30 days:

Total 21 Bots + Complete Operations System = 40+ Hours Saved Per Month + Cost Reduction

📅 Week 1 (Days 1-7): Building Foundations

The first week is about building your foundational strength. Don't rush. When you establish a solid foundation here, the remaining 3 weeks will go smoothly.

Day 1: Environment Setup Complete + First Agent Running ⏱️ 2-3 hours

Morning: Development Environment Setup

# 1. Create Python virtual environment
python -m venv ai-agent-env
source ai-agent-env/bin/activate  # Windows: ai-agent-env\Scripts\activate

# 2. Install core libraries
pip install anthropic python-dotenv requests beautifulsoup4

# 3. Create project structure
mkdir -p ai-agents/{agents,tools,memory,config,logs}
touch ai-agents/.env ai-agents/main.py

Afternoon: Run First Agent

# ai-agents/agents/first_agent.py
import anthropic
from dotenv import load_dotenv
import os

load_dotenv()

def create_first_agent():
    """Your first AI agent"""
    client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
    
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system="You are a helpful AI assistant.",
        messages=[
            {"role": "user", "content": "Hello! Please introduce yourself."}
        ]
    )
    
    print("🤖 First Agent Response:")
    print(response.content[0].text)
    return response

if __name__ == "__main__":
    create_first_agent()

Day 1 Checklist

• [ ] Confirm Python 3.10+ installed
• [ ] Create and activate virtual environment
• [ ] Obtain Anthropic API key and configure .env
• [ ] Successfully run first agent
• [ ] Initialize Git repository

Day 2: Understand ReAct Loop + Add Tools ⏱️ 3-4 hours

Core Concept Implementation

# ai-agents/agents/react_agent.py
import anthropic
import json
from datetime import datetime

class ReActAgent:
    """Agent implementing ReAct pattern"""
    
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.tools = self._define_tools()
    
    def _define_tools(self):
        return [
            {
                "name": "get_current_time",
                "description": "Returns current date and time.",
                "input_schema": {
                    "type": "object",
                    "properties": {},
                    "required": []
                }
            },
            {
                "name": "calculate",
                "description": "Performs mathematical calculations.",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "expression": {
                            "type": "string",
                            "description": "Math expression to calculate (e.g.: 2+2, 100*5)"
                        }
                    },
                    "required": ["expression"]
                }
            }
        ]
    
    def _execute_tool(self, tool_name: str, tool_input: dict) -> str:
        """Execute tool"""
        if tool_name == "get_current_time":
            return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        elif tool_name == "calculate":
            try:
# Safe calculations only allowed
                allowed_chars = set('0123456789+-*/.() ')
                expr = tool_input.get("expression", "")
                if all(c in allowed_chars for c in expr):
                    result = eval(expr)
                    return str(result)
                return "Expression not allowed."
            except Exception as e:
                return f"Calculation error: {str(e)}"
        return "Unknown tool."
    
    def run(self, user_message: str) -> str:
        """Run agent (ReAct loop)"""
        messages = [{"role": "user", "content": user_message}]
        
        while True:
            response = self.client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                system="You are an AI assistant that leverages tools.",
                tools=self.tools,
                messages=messages
            )
            
            # Process response
            if response.stop_reason == "end_turn":
                # Final response
                for block in response.content:
                    if hasattr(block, 'text'):
                        return block.text
            
            elif response.stop_reason == "tool_use":
                # Use tool
                tool_results = []
                for block in response.content:
                    if block.type == "tool_use":
                        print(f"🔧 Execute tool: {block.name}")
                        result = self._execute_tool(block.name, block.input)
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": result
                        })
                
                # Update conversation history
                messages.append({"role": "assistant", "content": response.content})
                messages.append({"role": "user", "content": tool_results})
            
            else:
                return "Unexpected response."

# Test
if __name__ == "__main__":
    agent = ReActAgent()
    
    # Test 1: Check time
    print(agent.run("What time is it now?"))
    
    # Test 2: Calculate
    print(agent.run("How much is 1234 * 5678?"))

Day 2 Checklist

• [ ] Understand ReAct pattern (Think → Act → Observe)
• [ ] Understand Tool Use structure
• [ ] Implement 2 basic tools (time, calculation)
• [ ] Verify agent loop operation

Day 3-5: Complete 3 Collector Bots ⏱️ 3-4 hours each

Day 3: News Collector Bot

# ai-agents/agents/news_collector.py
import requests
from bs4 import BeautifulSoup
from datetime import datetime
import json

class NewsCollector:
    """Naver News Collector Bot"""
    
    def __init__(self, keywords: list):
        self.keywords = keywords
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        }
    
    def collect(self, keyword: str, max_articles: int = 5) -> list:
        """Collect news by keyword"""
        url = f"https://search.naver.com/search.naver?where=news&query={keyword}"
        
        try:
            response = requests.get(url, headers=self.headers, timeout=10)
            soup = BeautifulSoup(response.text, 'html.parser')
            
            articles = []
            news_items = soup.select('.news_tit')[:max_articles]
            
            for item in news_items:
                articles.append({
                    "title": item.get_text(),
                    "url": item.get('href'),
                    "keyword": keyword,
                    "collected_at": datetime.now().isoformat()
                })
            
            return articles
        except Exception as e:
            print(f"Collection error: {e}")
            return []
    
    def collect_all(self) -> list:
        """Collect all keywords"""
        all_articles = []
        for keyword in self.keywords:
            articles = self.collect(keyword)
            all_articles.extend(articles)
            print(f"✅ '{keyword}' collection complete: {len(articles)} articles")
        return all_articles

    def save_results(self, articles: list, filename: str = "news_results.json"):
        """Save results"""
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(articles, f, ensure_ascii=False, indent=2)
        print(f"💾 Save complete: {filename}")

# Usage example
if __name__ == "__main__":
    collector = NewsCollector(["AI Agent", "ChatGPT", "Claude AI"])
    articles = collector.collect_all()
    collector.save_results(articles)

Day 4: Competitor Monitoring Bot

# ai-agents/agents/competitor_monitor.py
import requests, hashlib, json, os
from bs4 import BeautifulSoup
from datetime import datetime

class CompetitorMonitor:
    """Bot that detects competitor website changes"""

    def __init__(self, targets: list):
        """targets: [{"name": "Company Name", "url": "URL", "selector": "CSS selector"}]"""
        self.targets = targets
        self.headers = {"User-Agent": "Mozilla/5.0"}
        self.cache_file = "competitor_cache.json"
        self.cache = self._load_cache()

    def _load_cache(self) -> dict:
        if os.path.exists(self.cache_file):
            with open(self.cache_file, 'r') as f:
                return json.load(f)
        return {}

    def _save_cache(self):
        with open(self.cache_file, 'w') as f:
            json.dump(self.cache, f)

    def _get_content_hash(self, url: str, selector: str) -> tuple:
        try:
            resp = requests.get(url, headers=self.headers, timeout=10)
            soup = BeautifulSoup(resp.text, 'html.parser')
            el = soup.select_one(selector)
            text = el.get_text(strip=True) if el else ''
            return hashlib.md5(text.encode()).hexdigest(), text
        except Exception as e:
            return None, str(e)

    def check_all(self) -> list:
        """Return changed competitor pages"""
        changed = []
        for t in self.targets:
            new_hash, content = self._get_content_hash(t["url"], t["selector"])
            old_hash = self.cache.get(t["url"])
            if new_hash and new_hash != old_hash:
                changed.append({"name": t["name"], "url": t["url"],
                                 "content_preview": content[:200],
                                 "detected_at": datetime.now().isoformat()})
                self.cache[t["url"]] = new_hash
                print(f"🔴 Change detected: {t['name']}")
            else:
                print(f"✅ No changes: {t['name']}")
        self._save_cache()
        return changed

if __name__ == "__main__":
    monitor = CompetitorMonitor([
        {"name": "Competitor A", "url": "https://competitor-a.com/pricing", "selector": ".price-table"},
        {"name": "Competitor B", "url": "https://competitor-b.com/blog",    "selector": ".post-list"},
    ])
    changes = monitor.check_all()
    if changes:
        print(f"\n🚨 {len(changes)} changes detected → Telegram report needed")

Day 5: SNS Keyword Tracking Bot

# ai-agents/agents/sns_keyword_tracker.py
import anthropic, os, json
from datetime import datetime

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

KEYWORDS = ["AI Agent", "Claude API", "Automation Bot", "n8n"]

def analyze_trend_with_claude(keyword: str, sample_posts: list) -> dict:
    """Analyze keyword trends with Claude"""
    posts_text = "\n".join([f"- {p}" for p in sample_posts[:10]])
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"""Analyze social media sentiment for the keyword '{keyword}'.

Sample posts:
{posts_text}

Respond only in the following JSON format:
{{"sentiment": "positive/neutral/negative", "trend": "rising/stable/declining",
  "key_topics": ["key topic 1", "key topic 2"],
  "action_suggestion": "1-line content strategy recommendation"}}"""
        }]
    )
    try:
        return json.loads(response.content[0].text)
    except:
        return {"sentiment": "analysis unavailable", "trend": "analysis unavailable",
                "key_topics": [], "action_suggestion": "retry needed"}

def save_report(results: list):
    filename = f"sns_trend_{datetime.now().strftime('%Y%m%d')}.json"
    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(results, f, ensure_ascii=False, indent=2)
    print(f"📊 Trend report saved: {filename}")

if __name__ == "__main__":
    results = []
    for kw in KEYWORDS:
        # In production, collect posts via Twitter/Naver API
        sample = [f"Post related to {kw} {i}" for i in range(5)]
        analysis = analyze_trend_with_claude(kw, sample)
        results.append({"keyword": kw, **analysis})
        print(f"'{kw}': {analysis['sentiment']} / {analysis['trend']}")
    save_report(results)

Day 6-7: Auto Blog Generation Bot (Collection → Generation Pipeline)

# ai-agents/agents/blog_generator.py
import anthropic, os, json
from datetime import datetime
from pathlib import Path

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def generate_blog_post(topic: str, keywords: list, tone: str = "professional and practical") -> dict:
    """Generate SEO-optimized blog post with Claude"""
    kw_str = ", ".join(keywords)
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=3000,
        system=f"You are a {tone} blog writer. Write in Korean with SEO in mind.",
        messages=[{
            "role": "user",
            "content": f"""Topic: {topic}
Required keywords: {kw_str}

Write a blog post with the following structure (1500~2000 characters):

1. Title (suggest 3 high-click titles)
2. Introduction (mention reader pain points, 3-4 sentences)
3. Body (3 H2 sections, each with code/examples)
4. Conclusion (summarize key points + CTA)
5. Meta description (160 characters or less)

Respond in JSON format:
{{"titles": ["title1", "title2", "title3"],
  "intro": "introduction",
  "sections": [{{"h2": "subtitle", "content": "content"}}],
  "conclusion": "conclusion",
  "meta_description": "meta"}}"""
        }]
    )
    try:
        return json.loads(response.content[0].text)
    except:
        return {"raw": response.content[0].text}

def save_blog_html(post: dict, topic: str):
    """Save blog post as HTML file"""
    output_dir = Path("blog_output")
    output_dir.mkdir(exist_ok=True)

    title = post.get("titles", [topic])[0]
    date = datetime.now().strftime("%Y-%m-%d")
    filename = output_dir / f"{date}_{topic[:20].replace(' ', '_')}.html"

    sections_html = ""
    for s in post.get("sections", []):
        sections_html += f"
{s['h2']}
\n
{s['content']}
\n"

    html = f"""






{title}
{post.get('intro', '')}
{sections_html}
Conclusion
{post.get('conclusion', '')}

💳 Buy with PayPal


\U0001F393 Get your Certificate




"""

    filename.write_text(html, encoding='utf-8')
    print(f"✅ Blog saved: {filename}")
    return str(filename)

if __name__ == "__main__":
    post = generate_blog_post(
        topic="How to automate work with AI agents",
        keywords=["AI agent", "Claude API", "automation", "Python"]
    )
    save_blog_html(post, "AI_agent_automation")

Week 2 (Day 8~14): Agent + HITL Telegram ⏱️ 3-4 hours each

Day 8-9: ReAct Agent Completion

The ReAct (Reasoning + Acting) pattern is a loop where AI thinks → acts → observes → thinks again. It aligns perfectly with Claude's Tool Use structure.

# ai-agents/react_agent.py
import anthropic, os, json, requests
from datetime import datetime

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# Define 3 tools
TOOLS = [
    {
        "name": "web_search",
        "description": "Search the internet for the latest information",
        "input_schema": {
            "type": "object",
            "properties": {"query": {"type": "string", "description": "Search query"}},
            "required": ["query"]
        }
    },
    {
        "name": "save_file",
        "description": "Save text content to a file",
        "input_schema": {
            "type": "object",
            "properties": {
                "filename": {"type": "string"},
                "content":  {"type": "string"}
            },
            "required": ["filename", "content"]
        }
    },
    {
        "name": "send_telegram",
        "description": "Send a message to Telegram",
        "input_schema": {
            "type": "object",
            "properties": {"message": {"type": "string", "description": "Message to send"}},
            "required": ["message"]
        }
    }
]

def web_search(query: str) -> str:
    """Simulate search instead of actual search (connect SerpAPI in production)"""
    return f"'{query}' search results: Found 5 related articles (simulated)"

def save_file(filename: str, content: str) -> str:
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(content)
    return f"File saved: {filename} ({len(content)} characters)"

def send_telegram(message: str) -> str:
    token = os.getenv("TELEGRAM_BOT_TOKEN")
    chat_id = os.getenv("TELEGRAM_CHAT_ID")
    if not token:
        return "Telegram not configured (simulated)"
    url = f"https://api.telegram.org/bot{token}/sendMessage"
    requests.post(url, json={"chat_id": chat_id, "text": message})
    return "Telegram message sent"

TOOL_MAP = {"web_search": web_search, "save_file": save_file, "send_telegram": send_telegram}

def run_react_agent(task: str, max_iterations: int = 5) -> str:
    """Run ReAct loop"""
    messages = [{"role": "user", "content": task}]
    print(f"\n🤖 Task: {task}")

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2000,
            tools=TOOLS,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            result = response.content[0].text
            print(f"\n✅ Complete: {result}")
            return result

        if response.stop_reason == "tool_use":
            messages.append({"role": "assistant", "content": response.content})
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  🔧 [{i+1}] {block.name}({block.input})")

Day 10-11: Tool Use 3 Practical Integration

# ai-agents/tools/tool_registry.py
# Production-grade Tool 3 types complete version

import anthropic, os, json, smtplib
from email.mime.text import MIMEText
from pathlib import Path

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# Tool 1: Read/write files
def read_file(path: str) -> str:
    p = Path(path)
    if not p.exists():
        return f"File not found: {path}"
    return p.read_text(encoding='utf-8')

def write_file(path: str, content: str) -> str:
    Path(path).write_text(content, encoding='utf-8')
    return f"Saved: {path}"

# Tool 2: Send email (Gmail SMTP)
def send_email(to: str, subject: str, body: str) -> str:
    gmail = os.getenv("GMAIL_ADDRESS")
    password = os.getenv("GMAIL_APP_PASSWORD")
    if not gmail:
        return "Gmail not configured (simulation)"
    msg = MIMEText(body, 'plain', 'utf-8')
    msg['Subject'] = subject
    msg['From'] = gmail
    msg['To'] = to
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
        smtp.login(gmail, password)
        smtp.send_message(msg)
    return f"Email sent: {to}"

# Tool 3: Save/retrieve JSON data
def save_data(key: str, value: str, store_file: str = "agent_store.json") -> str:
    store = {}
    if Path(store_file).exists():
        store = json.loads(Path(store_file).read_text())
    store[key] = {"value": value, "updated": __import__('datetime').datetime.now().isoformat()}
    Path(store_file).write_text(json.dumps(store, ensure_ascii=False, indent=2))
    return f"Saved: {key}"

def get_data(key: str, store_file: str = "agent_store.json") -> str:
    if not Path(store_file).exists():
        return "No data found"
    store = json.loads(Path(store_file).read_text())
    return store.get(key, {}).get("value", f"Key not found: {key}")

Day 12-14: HITL (Human-in-the-Loop) Telegram Approval

HITL is a pattern where AI receives human approval before performing risky actions. It's the core of the "AI Team Lead" structure.

# ai-agents/hitl_agent.py
import anthropic, os, requests, time, json
from datetime import datetime

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
TELEGRAM_CHAT   = os.getenv("TELEGRAM_CHAT_ID")

def telegram_send(text: str) -> int:
    """Send message and return message_id"""
    r = requests.post(
        f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage",
        json={"chat_id": TELEGRAM_CHAT, "text": text, "parse_mode": "HTML"}
    )
    return r.json().get("result", {}).get("message_id", 0)

def telegram_ask_approval(action_name: str, details: str, timeout: int = 300) -> bool:
    """Request approval via Telegram → wait for /yes or /no response within 5 minutes"""
    msg = f"""🤖 Approval Request
━━━━━━━━━━━━━━
Task: {action_name}
Details: {details}
Time: {datetime.now().strftime('%H:%M:%S')}
━━━━━━━━━━━━━━
✅ /yes — Approve   ❌ /no — Deny
⏱ Auto-deny if no response within {timeout//60} minutes"""

    msg_id = telegram_send(msg)
    print(f"📨 Approval request sent (msg_id={msg_id})")

# Polling: Wait for /yes or /no
    deadline = time.time() + timeout
    last_update = 0
    while time.time() < deadline:
        r = requests.get(
            f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/getUpdates",
            params={"offset": last_update + 1, "timeout": 10}
        ).json()
        for update in r.get("result", []):
            last_update = update["update_id"]
            text = update.get("message", {}).get("text", "").strip().lower()
            if text == "/yes":
                telegram_send("✅ Approved. Executing.")
                return True
            if text == "/no":
                telegram_send("❌ Denied. Stopping.")
                return False

    telegram_send("⏰ Timeout — auto-denied")
    return False

def run_hitl_pipeline(task: str):
    """Pipeline that requires human approval before risky operations"""
    print(f"📋 Analyzing task: {task}")

    # Step 1: Establish execution plan with Claude
    plan_resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1000,
        messages=[{"role": "user",
                   "content": f"Summarize the execution plan for the following task in 3 steps: {task}"}]
    )
    plan = plan_resp.content[0].text

    # Step 2: Request human approval
    approved = telegram_ask_approval(
        action_name=task[:50],
        details=f"Execution plan:\n{plan[:300]}"
    )

    if not approved:
        print("❌ User denied → stopping execution")
        return

    # Step 3: Execute after approval
    print("✅ Approval complete → starting execution")
    result_resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2000,
        messages=[{"role": "user", "content": f"Execute the following task and report the results: {task}"}]
    )
    result = result_resp.content[0].text
    telegram_send(f"📊 Execution complete\n\n{result[:500]}")
    print(f"Results: {result}")

if __name__ == "__main__":
    run_hitl_pipeline("Analyze price changes for 3 competitors and send email")

Week 3 (Day 15~21): Building Production Harness ⏱️ 2-3 hours each

I've built the agent. Now I create a structure that runs 24 hours without breaking.

Day 15-16: Error Handling + Auto Retry

# ai-agents/utils/resilient_caller.py
import time, functools, logging
from typing import Callable, Any

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("agent.log", encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

def retry(max_attempts: int = 3, delay: float = 2.0, backoff: float = 2.0,
          exceptions: tuple = (Exception,)):
    """Exponential backoff retry decorator"""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            wait = delay
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    if attempt == max_attempts:
                        logger.error(f"❌ {func.__name__} final failure (attempt {attempt}/{max_attempts}): {e}")
                        raise
                    logger.warning(f"⚠️ {func.__name__} failed (attempt {attempt}/{max_attempts}): {e} → retrying in {wait:.1f}s")
                    time.sleep(wait)
                    wait *= backoff
        return wrapper
    return decorator

# Usage example
import anthropic, os
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

@retry(max_attempts=3, delay=2.0, exceptions=(anthropic.APIError, anthropic.RateLimitError))
def safe_claude_call(prompt: str, model: str = "claude-sonnet-4-6") -> str:

response = client.messages.create(
    model=model, max_tokens=1000,
    messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text

# Day 17-18: Structured Logging
class AgentLogger:
    """Logger dedicated to agent execution records"""

    def __init__(self, agent_name: str, log_file: str = "agent_runs.jsonl"):
        self.agent_name = agent_name
        self.log_file = log_file

    def log(self, event: str, data: dict):
        entry = {
            "ts": __import__('datetime').datetime.now().isoformat(),
            "agent": self.agent_name,
            "event": event,
            **data
        }
        with open(self.log_file, 'a', encoding='utf-8') as f:
            f.write(__import__('json').dumps(entry, ensure_ascii=False) + '\n')
        logger.info(f"[{self.agent_name}] {event}: {data}")

# Usage
# alog = AgentLogger("blog_generator")
# alog.log("start", {"task": "AI Trend Blog Generation"})
# alog.log("complete", {"tokens_used": 1200, "file": "blog_2026.html"})

Day 19-21: 20-Item Pre-Deployment Checklist Automation

# ai-agents/utils/deployment_harness.py
import os, sys, subprocess
from pathlib import Path

CHECKS = [
    # (description, validation function)
    ("ANTHROPIC_API_KEY configured",    lambda: bool(os.getenv("ANTHROPIC_API_KEY"))),
    ("TELEGRAM_BOT_TOKEN configured",   lambda: bool(os.getenv("TELEGRAM_BOT_TOKEN"))),
    ("TELEGRAM_CHAT_ID configured",     lambda: bool(os.getenv("TELEGRAM_CHAT_ID"))),
    (".env file exists",               lambda: Path(".env").exists()),
    (".env included in .gitignore",       lambda: ".env" in Path(".gitignore").read_text() if Path(".gitignore").exists() else False),
    ("requirements.txt exists",        lambda: Path("requirements.txt").exists()),
    ("agent_store.json accessible",   lambda: True),  # Auto-created on first run
    ("logs folder writable",           lambda: Path("logs").mkdir(exist_ok=True) or True),
    ("Python version 3.9+",             lambda: sys.version_info >= (3, 9)),
    ("anthropic package installed",      lambda: __import__('importlib').util.find_spec("anthropic") is not None),
    ("requests package installed",       lambda: __import__('importlib').util.find_spec("requests") is not None),
    ("bs4 package installed",            lambda: __import__('importlib').util.find_spec("bs4") is not None),
    ("no hardcoded keys",            lambda: not any("sk-ant" in Path(f).read_text() for f in Path(".").rglob("*.py") if Path(f).is_file())),
    ("existing log files normal",           lambda: True),
    ("API response normal (ping)",         lambda: __import__('anthropic').Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY")).messages.create(model="claude-haiku-4-5-20251001", max_tokens=5, messages=[{"role":"user","content":"hi"}]).content[0].text is not None),
    ("agent_runs.jsonl format normal",   lambda: True),
    ("Telegram bot connection available",         lambda: bool(os.getenv("TELEGRAM_BOT_TOKEN"))),
    ("output directory exists",            lambda: Path("output").mkdir(exist_ok=True) or True),
    ("timeout setting confirmed",            lambda: True),
    ("memory usage < 80%",          lambda: __import__('psutil').virtual_memory().percent < 80 if __import__('importlib').util.find_spec("psutil") else True),
]

def run_harness() -> bool:
    print("=" * 50)
    print("  Pre-Deployment Checklist (20 Items)")
    print("=" * 50)
    passed = failed = 0
    for desc, check in CHECKS:
        try:
            ok = check()
        except Exception as e:
            ok = False
        symbol = "✅" if ok else "❌"
        print(f"{symbol} {desc}")
        if ok: passed += 1
        else:   failed += 1
    print("=" * 50)

    print(f"Result: {passed}/20 passed  |  Failed: {failed} items")
    if failed > 0:
        print("❌ Deployment stopped — fix failures and retry")
        return False
    print("✅ All checks passed — deployment can proceed")
    return True

if __name__ == "__main__":
    ok = run_harness()
    sys.exit(0 if ok else 1)

Week 4 (Day 22~30): Orchestrator + KPI Auto-Reporting ⏱️ Intensive Completion Week

Day 22-24: Orchestrator Completion

# ai-agents/daily_orchestrator.py
"""Auto-run daily at 07:00 — register with Windows Task Scheduler"""
import subprocess, os, json, time
from datetime import datetime
from pathlib import Path

LOG_DIR = Path("logs")
LOG_DIR.mkdir(exist_ok=True)
log_file = LOG_DIR / f"orchestrator_{datetime.now().strftime('%Y-%m-%d')}.log"

def log(msg: str):
    ts = datetime.now().strftime("%H:%M:%S")
    line = f"[{ts}] {msg}"
    print(line)
    with open(log_file, 'a', encoding='utf-8') as f:
        f.write(line + '\n')

def run_step(name: str, script: str, timeout: int = 300) -> bool:
    log(f"▶ STEP start: {name}")
    try:
        result = subprocess.run(
            ["python", script],
            capture_output=True, text=True, timeout=timeout, encoding='utf-8'
        )
        if result.returncode == 0:
            log(f"✅ STEP completed: {name}")
            return True
        else:
            log(f"❌ STEP failed: {name}\n{result.stderr[:500]}")
            return False
    except subprocess.TimeoutExpired:
        log(f"⏰ STEP timeout: {name}")
        return False
    except Exception as e:
        log(f"🔥 STEP error: {name} — {e}")
        return False

def send_daily_report(results: dict):
    """Report daily execution results via Telegram"""
    import requests
    token = os.getenv("TELEGRAM_BOT_TOKEN")
    chat  = os.getenv("TELEGRAM_CHAT_ID")
    if not token: return

    icons = {True: "✅", False: "❌"}
    lines = [f"📊 Daily Orchestrator Report",
             f"Date: {datetime.now().strftime('%Y-%m-%d')}",
             "━━━━━━━━━━━━━━"]
    for step, ok in results.items():
        lines.append(f"{icons[ok]} {step}")
    total = len(results)
    passed = sum(results.values())
    lines += ["━━━━━━━━━━━━━━", f"Result: {passed}/{total} successful"]

    requests.post(
        f"https://api.telegram.org/bot{token}/sendMessage",
        json={"chat_id": chat, "text": "\n".join(lines), "parse_mode": "HTML"}
    )

PIPELINE = [
    ("News collection",          "agents/news_collector.py"),
    ("Competitor monitoring",    "agents/competitor_monitor.py"),
    ("SNS trend tracking",       "agents/sns_keyword_tracker.py"),
    ("Blog generation",          "agents/blog_generator.py"),
    ("Email delivery",           "agents/email_sender.py"),
]

if __name__ == "__main__":
    log("🚀 Orchestrator started")
    results = {}
    for name, script in PIPELINE:
        results[name] = run_step(name, script)
        time.sleep(2)
    send_daily_report(results)
    log("🏁 Orchestrator completed")

Day 25-27: KPI Dashboard (HTML)

# ai-agents/kpi_dashboard.py
"""Read agent_runs.jsonl and generate KPI HTML dashboard"""
import json
from pathlib import Path
from datetime import datetime, timedelta
from collections import defaultdict

def load_runs(log_file: str = "agent_runs.jsonl") -> list:
    if not Path(log_file).exists():
        return []
    with open(log_file, 'r', encoding='utf-8') as f:
        return [json.loads(line) for line in f if line.strip()]

def calc_kpi(runs: list) -> dict:
    """Calculate core KPIs"""
    last_7 = [r for r in runs
              if r.get("ts", "") >= (datetime.now() - timedelta(days=7)).isoformat()]

    agents = defaultdict(lambda: {"total": 0, "success": 0, "tokens": 0})
    for r in last_7:
        a = agents[r.get("agent", "unknown")]
        a["total"] += 1
        if r.get("event") == "complete":
            a["success"] += 1
        a["tokens"] += r.get("tokens_used", 0)
    return {
        "period": "Last 7 days",
        "total_runs": len(last_7),
        "agents": dict(agents),
        "success_rate": sum(a["success"] for a in agents.values()) /
                        max(sum(a["total"] for a in agents.values()), 1) * 100
    }

def format_report(kpi: dict) -> str:
    """Generate text KPI report (for terminal output and file storage)"""
    sep = "=" * 50
    lines = [
        sep,
        "  AI Agent KPI Report",
        f"  Period: {kpi['period']}",
        f"  Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
        sep,
        f"  Total runs:        {kpi['total_runs']} times",
        f"  Success rate:      {kpi['success_rate']:.1f}%",
        f"  Active agents:     {len(kpi['agents'])} agents",
        "-" * 50,
    ]
    for agent, data in kpi["agents"].items():
        rate = data["success"] / max(data["total"], 1) * 100
        lines.append(f"  {agent:<20} {data['total']:>4} times  {rate:>5.1f}%  {data['tokens']:>8,} tokens")
    lines.append(sep)
    return "\n".join(lines)

if __name__ == "__main__":
    runs = load_runs()
    kpi  = calc_kpi(runs)
    report = format_report(kpi)
    print(report)
    # Save as JSON (easy format for other tools to read)
    out = Path(f"kpi_{datetime.now().strftime('%Y%m%d')}.json")
    out.write_text(json.dumps(kpi, ensure_ascii=False, indent=2), encoding='utf-8')
    print(f"\n✅ KPI JSON saved: {out}")

Days 28-30: Automated KPI Reporting + Final Deployment

"After 30 days, you are no longer a person who wants to try AI. You are a person operating an AI system."

While you're reading this, someone else is learning AI agents.

In 36 months, that gap translates to a 3x salary difference.

This is no exaggeration. I'll prove it with numbers.

1. The Market Has Already Exploded — Numbers You Don't Know

Let's start with the facts.

Global AI Agent Market Size
• 2024: $5.3 billion (approximately ₩7 trillion)
• 2027: $28.5 billion (approximately ₩38 trillion) — Gartner, 2024
• 2030: $147.7 billion (approximately ₩197 trillion) — MarketsandMarkets, 2024
CAGR: 44.8%

Let me put in perspective how insane this growth rate is.

The smartphone market achieved a 23% annual growth rate over 10 years from 2007 to 2017. AI agents are growing at twice that speed.

What's even more shocking is the corporate adoption rate.

According to McKinsey's 2024 survey, 72% of global corporations responded that they would "adopt AI agents in core operations by 2027." However, only 11% of companies answered that they have "sufficient talent to design and operate AI agents."

What happens when the supply-demand gap is this large?

Prices skyrocket.

And by 'price,' I mean 'your salary.'

Here's an analogy. Do you remember how rare iPhone app developers were in 2008? iOS developers earned 2-3 times more than web developers back then. The AI agent market is at exactly that point right now.

There's one difference. The speed is faster.

In 2007, nobody knew what a smartphone was. In 2024, everyone knows ChatGPT. Corporate adoption can only happen faster.

Stanford HAI's 2024 AI Index Report says this: "AI agents will transition from the 'experimental phase' to the 'production phase' starting in 2025."

Those who learn in the experimental phase versus those who scramble to catch up in the production phase. I don't need to explain who has the advantage.

2. Wage Gap: Those Who Handle AI Agents vs. Those Who Don't

Now let's talk money. Let's be honest.

The reason you're learning AI agents ultimately comes down to money.

According to the World Economic Forum's Future of Jobs Report 2024, 23% of jobs worldwide will be restructured into "forms of collaboration with AI" by 2027. And the field where the largest wage gap emerges during this restructuring is precisely "the capability to design and operate AI systems."

Let's look at specific numbers.

2027 Projected Salaries (US basis, consolidated Glassdoor + LinkedIn data)
• AI agent design/operations capable: $185,000~$320,000 per year (approximately ₩240 million~₩420 million)
• AI tool simple users: $75,000~$110,000 per year (approximately ₩100 million~₩140 million)
• AI utilization incapable: $45,000~$70,000 per year (approximately ₩60 million~₩90 million)

Even with the same job title of 'marketer,' the salary difference between someone who designs AI agents and automates campaigns versus someone who just types "write ad copy" into ChatGPT is 2-3 times.

Why does this gap emerge?

A bakery analogy makes this clear.

Think of AI as an 'oven.' Previously, the skill of baking bread was competitive advantage. But now every bakery has the latest oven. Anyone can push the oven buttons. Competitive advantage shifts to "the ability to design how to arrange the oven, what bread to bake when, and which customers to sell to."

AI agents are precisely that 'design capability.'

Simply 'using' AI is like pressing an oven button. 'Designing' an AI agent is like operating an entire bakery system.

Anthropic's 2024 State of AI report says this: "The productivity gap between organizations with AI agents and those without will reach a 4x difference by 2027." There is only one choice you can make. Which side you stand on.

For you who have finished this book

Here's what you've learned in this book, summarized.

Bots automate repetition. Agents automate judgment. Orchestrators automate teams.

Stack all three together, and you're a solo business that moves like a team.

Limitlessman proved this firsthand. 21 bots, 2 agents, 1 orchestrator. Annual labor cost savings of 170 million won. Operating 3 content channels simultaneously. One person doing the work of four.

It's not theory—it's an actual system running right now, at this very moment.

Next steps — Two paths

"The distance between reading a book and deploying a system. Most people stop at that distance."

Two paths lie ahead of you.