This is a well-defined execution task with all research, strategy, and requirements already provided — the SUBAGENT-STOP clause applies. Proceeding directly to writing the article.
ENGLISH CONTENT:
How to create AI agents from scratch: step-by-step tutorial for beginners
By 2028, 33% of all enterprise software applications will include agentic AI — up from less than 1% in 2024, according to Gartner. That's not a distant horizon. That's three years. And if you're trying to figure out how to create AI agents from scratch without a machine learning PhD, you're asking exactly the right question at exactly the right moment.
This guide is for real beginners. Not "I've been coding for a decade" beginners — people who've heard the term, maybe seen a demo, and want to understand what an AI agent actually is, how it works under the hood, and how to build one today. We'll cover the architecture, the code, the honest failure modes, and the decisions that actually matter.
What is an AI agent, and how is it different from a chatbot?
Most people conflate the two. They're not the same thing.
A chatbot responds. You send a message, it generates a reply, and the interaction ends. Clean, predictable, limited. An AI agent does something fundamentally different: it acts. It uses tools, calls APIs, searches the web, reads files, runs code — and it loops through multiple steps autonomously until it reaches a goal or hits a defined limit.
Here's the mental model I keep coming back to: a chatbot is a very smart answering machine. An AI agent is a junior employee who gets things done without you supervising every click.
Harrison Chase, co-founder of LangChain, put it directly: "The key insight is that LLMs are not just text generators — they are reasoning engines. When you give them tools and a loop, you get something much more powerful."
That loop is called the ReAct cycle — Reason, Act, Observe, Repeat. The agent thinks about what to do, does it, reads the result, then decides what comes next. This runs until the task is complete or the agent times out. Everything else in agent development flows from understanding this loop.
The four components every agent needs
Skip the foundation and you'll be copying code you don't understand. Before writing a single line, know what's inside.
Perception is how the agent receives information — your text input, a file it reads, data from an API, or a webpage it fetches.
Memory splits into two types. Short-term memory is the current conversation history. Long-term memory is persistent storage across sessions — a vector database, SQL, or even a flat file. Most beginner tutorials skip long-term memory entirely. That's why their agents feel dumb after the first conversation.
Reasoning is the LLM itself. GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 — these are the actual thinking components. Pick one that fits your budget and latency requirements.
Action is the tools layer. Web search, code execution, email sending, database reads. No tools means no agent — just a stateful chatbot.
Andrew Ng said it clearly in his "AI Agents in LangGraph" course: "Multi-agent systems will outperform single agents on nearly every complex task. The parallelization and specialization you get is extraordinary." But you need to walk before you run. One agent, a few tools, deployed and working — that's the first milestone.
How to create AI agents from scratch: 5 steps that actually work
Here's the process. No hand-waving.
Step 1: set up your environment
You need Python 3.10+ and pip. Start with the minimum:
pip install langchain langchain-openai python-dotenv
Create a .env file:
OPENAI_API_KEY=sk-your-key-here
Cost reality check — and this is something most tutorials skip entirely. GPT-4o costs roughly $0.005 per 1K input tokens. A testing session costs under a dollar. But if your agent loops with expensive tool calls, costs spike fast. Set a hard spending limit in your OpenAI dashboard before you run anything.
Step 2: build your first tool
Tools are just Python functions with a decorator and a clear docstring. That's it.
from langchain.tools import tool
@tool
def get_weather(city: str) -> str:
"""Returns the current weather conditions for a given city."""
# Replace with a real weather API call in production
return f"22°C and sunny in {city}"
The LLM reads the function name and docstring to decide when to call this tool. Write descriptive docstrings. Seriously — they matter more than the implementation.
Step 3: wire up the react agent
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
tools = [get_weather]
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.invoke({"input": "What's the weather in São Paulo?"})
print(result["output"])
Run this with verbose=True. Watch the output. You'll see the agent reason, decide to call the weather tool, observe the result, and generate a final answer. That's the ReAct loop running live. Reading about it doesn't produce the same click as watching it happen.
Step 4: add memory so it doesn't forget you
Without this, every message starts fresh:
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=memory,
verbose=True
)
For production, persist this memory to a database or vector store — not in-process RAM that disappears when the server restarts. But for a first build, this gets you talking.
Step 5: handle failures before they handle you
Your agent will fail. That's not a bug in your code — it's a property of the system. The common failure modes:
- Infinite loops — The agent can't complete the task and keeps retrying. Fix: set
max_iterations=10 - Tool hallucination — The agent invents arguments that don't match your function signature. Fix: add strict input validation with Pydantic
- Context overflow — Long conversations fill the context window. Fix: switch to
ConversationSummaryMemoryfor extended sessions
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
max_iterations=10,
handle_parsing_errors=True,
verbose=True
)
Add this from the start, not after your first production incident.
Which framework should you actually use?
LangChain is the safe first choice. It has a massive community, solid documentation, and enough tutorials that you'll find answers to almost any beginner question. LangChain surpassed 90,000 GitHub stars and 10 million monthly downloads in 2024 — it's effectively the default for agent development. The API changes frequently though. Pin your dependency versions.
CrewAI is better for multi-agent workflows. If you need three agents working in parallel — a researcher, a writer, and an editor — CrewAI handles role-based coordination cleanly. Our team at Yaitec uses it for content automation pipelines.
AutoGen comes from Microsoft and is strongest for agent-to-agent conversation patterns. More complex initial setup, but worth it for enterprise-grade orchestration.
Agno is newer, lighter, and surprisingly capable. We've been using it on RAG-heavy applications where we need fine-grained control over the retrieval pipeline — it doesn't add the ceremony that LangChain sometimes does.
Not ready to write Python? Tools like n8n let you build visual agent workflows without code. For small business owners who need a customer service agent connected to WhatsApp or a CRM, n8n is often the right call over LangChain.
What 50+ AI agent projects actually taught us
Honest assessment. No optimism padding.
After delivering AI agents across fintech, healthtech, legal tech, and e-commerce, we've hit every failure mode you can imagine. Here's what we consistently see:
Memory is the most underestimated component. When we built a RAG chatbot for a fintech client, the first version had zero persistent memory. It worked beautifully in demos. It failed in production because users expected it to remember context from yesterday's session. Adding proper vector-based memory cut support tickets by 40% in the first three months.
Start with one agent and three tools. Almost every new client arrives wanting a twelve-agent system with specialized roles for everything. We talk them down to a single agent with three or four tools. That agent ships. The twelve-agent system doesn't.
The documentation is terrible in places, but the tools work. LangChain's docs have rough patches — especially around memory management and older API patterns that appear in tutorials but no longer work. Budget time for that friction.
After working with 10+ specialists on production ML systems, one honest limitation we always share upfront: AI agents aren't reliable for high-stakes decisions. Legal judgments, medical diagnoses, financial compliance calls — you want a human in that loop. Use agents to research, summarize, and prepare; keep humans in the final decision seat.
The document processing agent we built for a legal tech client now handles 80% of contract review automatically — saving 120 hours a month. That result took four iterations and serious edge case work. The first version was embarrassingly unreliable. Ship early, iterate hard.
If you're building an agent for production and don't want to learn the hard lessons yourself, contact us — we've probably already hit whatever problem you're worried about.
The field is moving faster than most people realize
According to a Microsoft and GitHub research study published in ACM, developers using AI coding assistants complete programming tasks 55.8% faster than those without. The global AI agents market hit $3.86 billion in 2023 and is projected to reach $47 billion by 2030. LLMs with tool-use score three times higher on complex multi-step tasks compared to models without agentic capabilities, according to the GAIA benchmark paper.
Klarna's AI agent handled 2.3 million customer service conversations in its first month — work equivalent to 700 full-time employees — while cutting resolution time from 11 minutes to under 2 minutes. Morgan Stanley deployed an agent giving 16,000 financial advisors instant access to 100,000+ research documents, with over 75% adoption within months of launch.
Sam Altman said it plainly: "We're moving from models that respond to models that act. Agents that can use tools, browse the web, write and execute code — that's where the real-world value is."
Build something small, and ship it
The classic beginner trap is designing a perfect system before writing any code. Don't. Build an agent that does one thing well — a web researcher, a document summarizer, a customer FAQ handler. Get that running, watch it fail, fix the failures, and then add complexity.
With LangChain or CrewAI, a functional prototype runs in under 50 lines of Python. That's extraordinary compared to what this required in 2020. The frameworks are here. The LLMs are affordable for testing. The mental model — Reason, Act, Observe, Repeat — is learnable in an afternoon.
You don't need to be an ML researcher to create AI agents from scratch. You need to understand the loop, design honest tool docstrings, and handle failure modes from day one.
Start there.
