rudnfaiActual Inflearn course review
“I was able to understand the core principles behind how agents work by implementing them myself.”핵심 원리 이해
An AI agent that uses tools,
built by hand
This course is a TypeScript course where you first implement an AI agent loop by hand and then rebuild it with the Vercel AI SDK. You’ll write the agent loop once from scratch, without a framework, to see how it works firsthand, and then complete it again with the Vercel AI SDK. A real agent that runs on your laptop—with no cloud services or paid APIs. In the final bonus section, you’ll swap out only the agent’s model for Kimi K3 and see how far you can go beyond what local models can do.
Find the meeting schedule in the workspace and summarize it in one line.
[tool] search_files("meeting") → notes.md
[tool] read_file("notes.md")
The next meeting is on Friday at 3 PM.
calculate({"expression":"17*23"}) → 391read_file("notes.md")write_file("todo.md") → confirmed
ylist_files({})search_files("회의") →
notes.mdremember("likes tea")recall("like") → memory
recallfetch_url("https://example.com")current_time({})stopWhen: stepCountIs(8)temperature: 0steps 2 · multi-step complete
calculate({"expression":"17*23"}) → 391read_file("notes.md")write_file("todo.md") → confirmed
ylist_files({})search_files("회의") →
notes.mdremember("likes tea")recall("like") → memory
recallfetch_url("https://example.com")current_time({})stopWhen: stepCountIs(8)temperature: 0steps 2 · multi-step complete
Now, let me show you first rather than tell you.
Preview video
One minute is enough—more effective than a hundred words of explanation.
An AI agent is a program that understands the user’s request, selects tools on its own, performs tasks in multiple steps, and then verifies the results. First, see how the finished product actually works. With a single line of instruction, the agent chooses and uses tools, then decides what to do next on its own. The text-based flow below breaks it down step by step afterward.
Demonstration of a complete local work agent · Since it’s a local model, the wording may vary slightly with each execution.
Taking that agent apart step by step
Once completed, it does things like this
When the conversation is broken down to include tool calls,
Once you turn it on, it reads and writes files, performs calculations, fetches information from the web, and remembers the user. Before risky operations, it asks a person for confirmation. Below is the actual conversation flow of the local work agent completed at the end of the lecture.
My name is Hong, and I like tea. Remember that.
[tool] remember("The user's name is Hong, and they like tea")
Hong, I’ll remember that you like tea.
Select only the unfinished tasks from todo.md and organize them in todo-open.md.
[tool] read_file("todo.md")
Writing 38 characters to 'todo-open.md'. Shall I proceed? (y/N) y
[tool] write_file("todo-open.md")
I organized the 2 unfinished tasks in todo-open.md.
What was my name again?
I'm Hong.
Tool use, multistep reasoning, memory, and human confirmation. It all runs on code written directly.
But how is this possible?
What this course promises
We don’t stop at “knowing how to use it.”
There’s nothing special about it. The order is simply different—we first implement the principles by hand, then build the framework on top of them. Usually, people do it the other way around.
Before taking the course
They know how to use a framework. But they don't know what's happening under the hood.
→
After taking the course
Because I’ve written the loop myself, I understand what the framework is doing under the hood. Even when I encounter a new tool, I adapt quickly.
01
Once by Hand, Then with the SDK
Implement the function-calling loop directly in raw code to see how it works, then recreate the same thing with the Vercel AI SDK. You’ll understand what the framework is doing under the hood.
02
100% Local, 100% Free
Run the model on your own computer with Ollama. No API key, payment, or GPU is required. Experiment as much as you like at zero cost. Kimi K3 in the bonus section also supports credits, so you can follow along without paying.
03
We’ll cover robustness too.
We don’t stop at a demo. We build agents that hold up in practice—from error recovery and input validation to infinite-loop prevention and human confirmation for risky actions.
You can start that sequence now.
Once you’ve written one by hand, you’ll see frameworks in a completely different light.
지금 시작하기And one more thing: we added it through a collaboration.
Moonshot AI Collaboration · Bonus Section
How far can the same agent go when you plug in K3?
In the agent we built through Section 7, simply swap the model for Kimi K3.
MOONSHOT AI · Collaboration Section
K3
Moonshot AI's latest flagship model. Start by writing this name in a single line of code.
OFFICIAL K3 MODEL SPEC
2.8Ttotal parametersThe world's first open 3T-class
model
1,048,576maximum context tokensLarge repositories and long documents in a
single request
90.4BrowseComp scoreWithout 1M context or context compression
Native Visionimage understandingRead error screens and visual materials
directly
BrowseComp 90.4 is the official evaluation score published by Kimi. It was measured with 1M-token context and the maximum reasoning intensity setting, without context compression.
Kimi K3 공식 성능 근거 보기 →Kimi CLI is this kind of tool.
1 million tokens
Whole, without splitting it up
The context window is 1,048,576 tokens. You can put in a 3,600-line code file as-is without splitting it up and ask, "Where is this value determined?"
Images · Video
The error screen as-is
It doesn’t require OCR. If you capture a broken screen and send it as-is, the model reads it and pinpoints the bug. It can be built as a tool and connected to the agent loop as well.
Agent Swarm
Sub-agents in parallel
The orchestrator breaks the work down, distributes it to sub-agents, and gathers the results back together. Up to 300 can run simultaneously (Beta, available to members).
This is a scene where an image was inserted as-is to have it find bugs. We try it ourselves in Section 8.
It is a 2.8-trillion-parameter MoE model. We begin by reading the official blog together and distinguishing what has been empirically measured from where the marketing begins.
That order, building up step by step through 8 stages.
An Agent That Grows in 8 Stages
At the end of each section, the agent grows one step.
Rather than viewing it as a table of contents, it’s better to look at what gets added at each stage. I’ve noted what your agent will newly be able to do after completing each section.
1
Section 1
What Is an Agent, and What Will We Build?
→ Understand the agent loop (perception, reasoning, action, observation) and set up a local development environment
- The Essence of AI Agents and the Agent Loop
- The Big Picture of the Concepts You’ll Learn in This Course
- Prepare the development environment and set up Ollama and a tool-calling model
2
Section 2
Handcrafting an Agent
→ Build a function-calling loop from scratch without a framework to gain a hands-on understanding of how agents work.
- The Meaning of the Messages Array and Function Calls
- Defining, executing, and checking the results of tools
- Build the agent loop yourself and add more tools
- Observing multi-step reasoning, infinite loops, and termination conditions
3
Section 3
Rebuilding with the Vercel AI SDK
→ Cleanly restructure the hand-built loop using an industry-standard framework
- Introduction to the Vercel AI SDK and Ollama Integration
- generateText calls, tool definitions, and zod schemas
- steps tracking, response streaming, multi-step patterns
4
Section 4
Local Work Agent — Tool Integration
→ Evolve it into an agent that handles real tasks by integrating file, web, and calculation tools
- Tool Schema Design Principles and a Safe Workspace
- File reading, writing, listing, and search tools
- Fetching web pages, context-saving patterns
- Practical Scenarios for Combining Multiple Tools
5
Section 5
Agent Memory
→ Build an agent that remembers users through short-term (conversation) and long-term (file-based) memory.
- Why Memory Is Needed and the Limitations of the Context Window
- Managing Old Context and Designing Long-Term Memory
- In fact: A demonstration of storage and recall tools and an agent that remembers
6
Section 6
Robustness and Control
→ Build a robust agent that doesn’t break down on errors and involves a human for risky tasks.
- Why Local Models Go Off Track and Loop Control
- Input validation, returning errors as results, and recovering
- Behavioral guidelines through system prompts, human confirmation patterns
- Handling Debugging and Common Failure Patterns
7
Section 7
Capstone — A Fully Functional Local Task Agent
→ Combine all the pieces so far to build a fully functional agent that runs in the terminal.
- Capstone design, a thin REPL harness, and loop assembly
- Streaming polish and a multi-step end-to-end demonstration
- What We Haven’t Covered and Next Steps, Conclusion
8
Collaboration Section · Moonshot AI
Swap the same agent out for Kimi K3.
→ Assess what becomes possible and what remains unchanged when swapping models, including the cost.
- Read the official K3 blog together to identify its features and limitations
- Run the agent built through Chapter 7 with Kimi as-is.
- Execute work workflows, coding workflows with Kimi CLI
- Find bugs by simply uploading screenshots of error screens as-is
- Insert long code and documents in their entirety without cutting them.
- Differences from Claude · Codex, token cost calculation
- Run sub-agents in parallel with Agent Swarm
- Pricing, adoption decisions, and when it’s best to use it
If you've made it this far, it's time to start with Step 1.
You can get started right away by installing Ollama. The cost is $0.
수강 시작하기So what remains is this:
What This Course Fills In
One agent, properly, all the way to the end
We’ll continue from the principles through to completion. By the end of the course, you’ll be able to build these things yourself.
Build it yourself in this course
- Implement the agent loop by hand
- Using the Vercel AI SDK and How It Works Internally
- Function calling (tool use) and multi-step reasoning
- File, web, and calculation tool integration
- Short-term and long-term memory
- Error recovery, guardrails, and human confirmation
- Swap in the Kimi K3 model (Bonus)
So, who is this suitable for?
Before you start
This is for those who fit the following profile, and all you need to prepare is this.
◆Recommended for these learners
- Those who are trying to properly build an AI agent for the first time
- Those who have felt frustrated using frameworks as black boxes
- Those who want to “know how to use it and understand how it works”
- Those who want to experiment freely locally without worrying about costs
◆Requirements
- TypeScript / JavaScript Basic Syntax
- Experience using Node.js and npm
- macOS environment (using zsh)
- Ollama Installation — CPU Is Sufficient Without a GPU
This is a good fit for those who:
Instructor Introduction
A developer who likes building things from first principles
SILICON VALLEY · AI ENGINEER
Silicon Valley Developer Waddy
I’m Waddy, a backend server developer with 13 years of experience. After working at various companies in Korea, I recently moved to Silicon Valley, where I’m now working on AI-related development.
I connected with a developer friend at Toss and ended up joining this way. I’m very interested in being able to provide a wide range of information online. I’ll do my best to share the knowledge I have in the easiest and most accessible way possible.
"Anyone can use a framework. But once you build one yourself, even just once, you see tools in a completely different way. That perspective is what ultimately makes the difference in skill."_久久爱
AI agents
tool use · function calling
local LLMs
Silicon Valley professionals
Before we begin, things you may be wondering about
Frequently Asked Questions
Things You May Be Curious About First
Can a beginner who has just started coding follow along?
You need a basic understanding of TypeScript or JavaScript syntax and experience using npm. Building on that foundation, the course covers the concepts needed for agents—LLM calls, function calls, and tool use—from the ground up.
What is Kimi K3, which is covered in the bonus section?
We simply swap the model of the agent built in Sections 1–7 for Kimi K3. We leave the code almost entirely unchanged and see what differs. K3 is a model that supports a 1-million-token context and image and video inputs, opening up possibilities that weren’t available with small local models. For example, you can feed it an entire long code file without cutting it up, or send it an image of an error screen as-is and have it find the bug. We also read the official blog together and examine where the facts end and the marketing begins. This section was created in collaboration with Moonshot AI.
Don’t you use frameworks like LangChain?
We use the industry-standard Vercel AI SDK. However, rather than using it right away, we first build the core loop by hand and then port it to the SDK, comparing them one-to-one. This way, you’ll understand even what the framework does under the hood.
Is it possible on Windows as well?
The course is conducted using macOS (zsh) as the reference environment. The code and concepts themselves are the same, but installation and execution commands will be shown for macOS.
What will I take away from the course?
You’ll come away with your own local work agent running in the terminal and, above all, a solid understanding of how an agent works. It’s a foundation that will help you quickly adapt to other frameworks as well.
Is there any reason to take this course even if I’ve already used the Vercel AI SDK?
Knowing how to use an SDK and understanding what it does under the hood are two different things. This course first has you build the function-calling loop by hand and then reconstruct it with the SDK, so even if you already use an SDK, you’ll gain a fresh perspective on what happens inside it.
Student’s Record
A student who implemented it themselves evaluated it as follows:
5.0Selected Reviews · Other AI Agent Courses
This review was excerpted from an actual Inflearn course review for an AI agent course. It is displayed separately to avoid being mistaken for a review of the course on this page.
AI Agents—Now Build One Yourself
Open the black box and complete a working agent with your own hands.
수강 시작하기TypeScript · Ollama Local
Even after the course ends, it’s not the end.
Grow Together
So it doesn’t end with listening alone
Learning continues beyond the course. We run a KakaoTalk open chat where developers gather to freely share career concerns, workplace situations, and technical topics. Feel free to ask about anything you get stuck on while taking the course.
KakaoTalk open chat where developers gather
From career topics and real-world work situations to technical concerns—this is a space where you can ask questions casually and find answers together.
Career discussionsShare real-world work situationsTechnical discussionsFree for everyone
오픈채팅
참여하기인스타그램
보러가기
open.kakao.com/o/ggBVZsai
I was able to learn the principles of AI Agents by building one myself. Previously, I only used AI for asking and answering questions in a chat format, but by implementing how an AI Agent works internally from scratch, I was able to understand AI systems. It was exactly the lecture I needed. Thank you!
I had been using agent tools like Claude Code, Codex, and Hermes quite comfortably, but I had no idea how they actually worked internally. However, after taking this course, the recommended usage methods for each agent started to make sense in a new way. I began to see the reasoning behind prompting methods, why responses sometimes become "dumb," the concepts of context and memory, why token usage was occasionally so high, and the actual flow of the tools and the famous "Loop" that agents use. After completing the section where we build an agent by hand, the tools I use daily felt completely different. While the experience of building an Agent AI from scratch was great, what resonated with me most was gaining an understanding of the principles behind the agents I currently use as tools, which gave me a sense of how to utilize them even better. In particular, the content regarding robustness—such as memory design, error handling, and behavioral guidelines—was a huge help in understanding why agents sometimes behave strangely in practice. I watched the entire course at 2x speed first to get a quick overview of the flow and then followed up with hands-on practice, which turned out to be the most effective method for me. Thank you for creating such a great course.
I was interested in AI agents, but until now, I had only gone as far as following examples using LangChain or various frameworks. Because of that, I only had a vague understanding of how agents actually operate internally, why Tool Calling is necessary, and how the Agent Loop functions. The best part about this lecture was that, rather than relying on complex frameworks from the start, I was able to understand the core principles of how an agent works by implementing them myself. I had heard the term "agent" many times but was curious about exactly how they are implemented; I am very satisfied that I was able to build one firsthand. Before taking the course, agents felt like a somewhat abstract concept, but now I have a clear mental framework of how to design the structure and what needs to be controlled when creating an agent. I highly recommend this course to anyone who wants to build a single agent from scratch, from start to finish.
Until now, I intentionally avoided diving deep into AI-related technologies. I prioritized other areas of learning because I believed that having a high-level understanding of my own technical stack was more important in the AI era. However, as AI evolves faster than expected, I began to feel that even simple side projects felt incomplete without some form of AI integration. Through this lecture, I easily gained insights into local LLMs and how to utilize them, enabling me to apply these technologies without worrying about costs. Up to Chapter 3, there were no difficult parts for a standard backend developer. However, I think the true charm of this course lies in learning the instructor's development philosophy and habits—things that aren't easily observed elsewhere. I'm learning a lot!
This curriculum first implements the tool-calling loop at the core of an agent directly in vanilla TypeScript to understand how it works, then refactors it using the Vercel AI SDK. It helps you understand what the framework handles internally and covers realistic challenges you encounter in production, such as preventing infinite loops, automatically recovering from errors, and requiring human approval for risky operations. It seems like a useful course for developers who want to control agents reliably in real-world applications.
![[Part 1: Basics] OpenClaw.AI Master Class: Create Your Own Autonomous AI Agent with Gemini and DockerCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/340904/cover/01kk1e4bcwnwdyjnmg641hz67w?w=420)
![[VOD] How to Redesign Your Expertise in the AI EraCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/342633/cover/01kv7bvnz7t0wjh5fyp3xkscyp?w=420)
![[Rookiss] Introduction to CS for Claude Code Development (Interactive Textbook)Course Thumbnail](https://cdn.inflearn.com/public/files/courses/343039/cover/01kxxkr2jvwc78m24qjtf89qfw?w=420)
![[VOD] Lee Jae-gyu (Ouroboros) Buildermit - Harness, the contract handed to the agentCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/343420/cover/01kzx5jbjghs8996h7d312bc44?w=420)
![[Inflearn Award Bestseller] How to Become an AI Automation Expert Without Coding, The Complete n8n GuideCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/337053/cover/01jrkjt8emye2z7j7846br3vkk?w=420)
![[VOD] A story of a non-developer planner building AX in the fieldCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/343357/cover/01ky6xa21r5qw8nveevz7317kj?w=420)
![[Serial] WE CAN ChatGPT! - We can do it too, ChatGPT.Course Thumbnail](https://cdn.inflearn.com/public/courses/336097/cover/a0235c47-7dc2-4a85-8656-a8b64d1b96b3/336097.jpg?w=420)
![[OT (Manufacturing) Security] Master Class for the 4 Major Manufacturing IndustriesCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/342823/cover/ai/3/d8a24ae4-a719-4167-b6c9-88c40dbbf133.png?w=420)
![[OT Security - ① Automotive Industry] Understanding Manufacturing Security in the AI Era: Focusing on Real-world Field CasesCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/342429/cover/ai/0/99dc048b-01e8-4b67-87d2-a333aea84856.png?w=420)
![[Meetup VOD] The Future of Work Seen Through the Working Style of an AI Native CompanyCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/340242/cover/01kfdb25rybs92qftj95q38p2d?w=420)
![[OT Security - ④ Food Industry] Understanding Manufacturing Security in the AI Era through On-site Case StudiesCourse Thumbnail](https://cdn.inflearn.com/public/files/courses/342718/cover/ai/0/d8913e1d-e4ba-4dae-9cfa-85a3c649c509.png?w=420)
