To build an AI agent from scratch, you need access to an LLM that supports tool calling. The OpenAI API and the Anthropic API both provide native tool-calling interfaces that tell the model when and how to invoke external functions. Set up your Python environment with the relevant SDK:<\/p>\n\n\n\n
pip install openai anthropic python-dotenv<\/code><\/pre><\/div>\n\n\n\nStore your API keys in a .env<\/code> file and load them with python-dotenv<\/code>. Never hardcode credentials in your agent code, as this is a security risk that becomes serious the moment your agent has access to external systems.<\/p>\n\n\n\nStep 3: Define Your Tools<\/h4>\n\n\n\n
Tools are the hands of your AI agent. Each tool is a Python function that the agent can call at runtime. Define them clearly, because the model reads your descriptions to decide when to use each one:<\/p>\n\n\n\n
tools = [\n {\n "type": "function",\n "function": {\n "name": "web_search",\n "description": "Search the web for current information on any topic.",\n "parameters": {\n "type": "object",\n "properties": {\n "query": {\n "type": "string",\n "description": "The search query to send."\n }\n },\n "required": ["query"]\n }\n }\n }\n]<\/code><\/pre><\/div>\n\n\n\nWrite tool descriptions as if you are explaining the function to a capable but literal colleague. Vague descriptions produce inconsistent tool selection, which is one of the most common failure modes when you build an AI agent from scratch.<\/p>\n\n\n\n
Step 4: Write the System Prompt<\/h4>\n\n\n\n
The system prompt is the agent’s constitution. It defines its identity, its available tools, the format it must use to call them, and the conditions under which it should stop. A minimal but effective system prompt for a research agent looks like this:<\/p>\n\n\n\n
You are a research assistant with access to web search.\nThink step by step before acting. Use the web_search tool\nto find current information. When you have enough information\nto answer the task fully, return a final answer clearly labelled\nas "Final Answer:". Never guess when you can search.<\/code><\/pre><\/div>\n\n\n\nWhen you build an AI agent from scratch, the system prompt deserves as much attention as the code. A poorly written prompt produces unpredictable reasoning regardless of how well the rest of the system is engineered.<\/p>\n\n\n\n
Step 5: Build the Reasoning Loop<\/h4>\n\n\n\n
The reasoning loop is the core of the agent. It sends the current conversation to the LLM, parses its response for tool calls, executes the tools, appends the results, and repeats:<\/p>\n\n\n\n
def run_agent(task: str, tools: list, tool_functions: dict,\n max_steps: int = 10) -> str:\n\n messages = [\n {"role": "system", "content": SYSTEM_PROMPT},\n {"role": "user", "content": task}\n ]\n\n for step in range(max_steps):\n response = client.chat.completions.create(\n model="gpt-4o",\n messages=messages,\n tools=tools\n )\n message = response.choices[0].message\n\n if message.tool_calls is None:\n return message.content # final answer reached\n\n for tool_call in message.tool_calls:\n fn_name = tool_call.function.name\n fn_args = json.loads(tool_call.function.arguments)\n result = tool_functions[fn_name](**fn_args)\n\n messages.append(message)\n messages.append({\n "role": "tool",\n "tool_call_id": tool_call.id,\n "content": str(result)\n })\n\n return "Max steps reached."<\/code><\/pre><\/div>\n\n\n\nNotice the max_steps<\/code> guard. Every time you build an AI agent from scratch, this is non-negotiable. Without it, a confused agent will spin indefinitely and consume tokens until it hits a rate limit or your budget runs out.<\/p>\n\n\n\nStep 6: Add Memory<\/h4>\n\n\n\n
In-context memory is built into the loop above: the entire conversation history is passed to the LLM at each step, giving it full access to everything that has happened. For longer tasks or multi-session agents, you need external memory.<\/p>\n\n\n\n
The simplest form of external memory is a vector store. At the end of each session, summarise the key findings and store them as embeddings in a database such as ChromaDB or Pinecone. At the start of the next session, retrieve the most relevant summaries and inject them into the context:<\/p>\n\n\n\n
import chromadb\n\nclient_db = chromadb.Client()\ncollection = client_db.create_collection("agent_memory")\n\ndef save_memory(content: str, session_id: str):\n collection.add(\n documents=[content],\n ids=[session_id]\n )\n\ndef retrieve_memory(query: str, n: int = 3) -> list[str]:\n results = collection.query(query_texts=[query], n_results=n)\n return results["documents"][0]<\/code><\/pre><\/div>\n\n\n\nWhen you build an AI agent from scratch with persistent memory, you move from a stateless tool into a system that genuinely learns from experience across sessions.<\/p>\n\n\n\n
Step 7: Add Observability and Safety Rails<\/h4>\n\n\n\n
The final step before deploying is instrumentation. Log every step of the reasoning loop: what the model decided, which tool it called, what arguments it passed, and what the tool returned. Without structured logs, debugging a failed agent run is nearly impossible.<\/p>\n\n\n\n
Safety rails are equally important. Any action that is irreversible, sending an email, modifying a database record, executing a financial transaction, should route through a human confirmation step before execution. Implementing this is straightforward: before calling any write-action tool, prompt the user for explicit approval and only proceed if it is granted.<\/p>\n\n\n\n
Build an AI Agent from Scratch: What Comes Next<\/h4>\n\n\n\n
Once you have a working agent using these seven steps, the natural progression is to add more tools, introduce parallel tool execution, implement re-ranking for memory retrieval, and explore multi-agent architectures where specialised agents collaborate on complex tasks. Each of those extensions builds directly on the foundation covered here.<\/p>\n\n\n\n
The most important thing is to start. Build an AI agent from scratch on a small, bounded task. Break it deliberately. Fix it. Then extend it. That cycle of build, break, and fix is how engineering intuition develops, and intuition is what separates an AI engineer who can ship from one who can only read about it.<\/p>\n","protected":false},"excerpt":{"rendered":"
Why Build an AI Agent from Scratch? If you want to build an AI agent that actually works in production, the worst place to start is a pre-packaged framework that hides what is happening beneath the surface. Frameworks are useful once you understand what they are abstracting. Before that point, they make debugging nearly impossible and leave you unable to explain your own system’s behaviour. This guide walks through seven concrete steps to build an AI agent from scratch using Python. By the end, you will understand precisely how each component of the agent works, how they connect, and what goes wrong when they do not. Whether you are a software engineer exploring AI, or a practising ML engineer who wants to move beyond single-turn API calls, building an AI agent from scratch is one of the most productive things you can do to advance your practical skills in 2026. Step 1: Understand What an AI Agent Actually Is Before writing a single line of code, you need a clear mental model. An AI agent is not a chatbot that answers one question at a time. It is a reasoning system that perceives a situation, selects an action, executes it, observes the result, and decides what to do next, repeating this loop until the task is complete. The three components every AI agent needs are tools (functions it can call to interact with the world), memory (a record of what has happened so far), and a reasoning loop (the logic that connects perception to action). When you build an AI agent from scratch, you are constructing all three of these components yourself, rather than inheriting someone else’s implementation. Step 2: Choose Your LLM and Set Up Your Environment To build an AI agent from scratch, you need access to an LLM that supports tool calling. The OpenAI API and the Anthropic API both provide native tool-calling interfaces that tell the model when and how to invoke external functions. Set up your Python environment with the relevant SDK: Store your API keys in a .env file and load them with python-dotenv. Never hardcode credentials in your agent code, as this is a security risk that becomes serious the moment your agent has access to external systems. Step 3: Define Your Tools Tools are the hands of your AI agent. Each tool is a Python function that the agent can call at runtime. Define them clearly, because the model reads your descriptions to decide when to use each one: Write tool descriptions as if you are explaining the function to a capable but literal colleague. Vague descriptions produce inconsistent tool selection, which is one of the most common failure modes when you build an AI agent from scratch. Step 4: Write the System Prompt The system prompt is the agent’s constitution. It defines its identity, its available tools, the format it must use to call them, and the conditions under which it should stop. A minimal but effective system prompt for a research agent looks like this: When you build an AI agent from scratch, the system prompt deserves as much attention as the code. A poorly written prompt produces unpredictable reasoning regardless of how well the rest of the system is engineered. Step 5: Build the Reasoning Loop The reasoning loop is the core of the agent. It sends the current conversation to the LLM, parses its response for tool calls, executes the tools, appends the results, and repeats: Notice the max_steps guard. Every time you build an AI agent from scratch, this is non-negotiable. Without it, a confused agent will spin indefinitely and consume tokens until it hits a rate limit or your budget runs out. Step 6: Add Memory In-context memory is built into the loop above: the entire conversation history is passed to the LLM at each step, giving it full access to everything that has happened. For longer tasks or multi-session agents, you need external memory. The simplest form of external memory is a vector store. At the end of each session, summarise the key findings and store them as embeddings in a database such as ChromaDB or Pinecone. At the start of the next session, retrieve the most relevant summaries and inject them into the context: When you build an AI agent from scratch with persistent memory, you move from a stateless tool into a system that genuinely learns from experience across sessions. Step 7: Add Observability and Safety Rails The final step before deploying is instrumentation. Log every step of the reasoning loop: what the model decided, which tool it called, what arguments it passed, and what the tool returned. Without structured logs, debugging a failed agent run is nearly impossible. Safety rails are equally important. Any action that is irreversible, sending an email, modifying a database record, executing a financial transaction, should route through a human confirmation step before execution. Implementing this is straightforward: before calling any write-action tool, prompt the user for explicit approval and only proceed if it is granted. Build an AI Agent from Scratch: What Comes Next Once you have a working agent using these seven steps, the natural progression is to add more tools, introduce parallel tool execution, implement re-ranking for memory retrieval, and explore multi-agent architectures where specialised agents collaborate on complex tasks. Each of those extensions builds directly on the foundation covered here. The most important thing is to start. Build an AI agent from scratch on a small, bounded task. Break it deliberately. Fix it. Then extend it. That cycle of build, break, and fix is how engineering intuition develops, and intuition is what separates an AI engineer who can ship from one who can only read about it.<\/p>\n","protected":false},"author":1,"featured_media":1125,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[],"class_list":["post-1124","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-engineering"],"_links":{"self":[{"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/posts\/1124","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/comments?post=1124"}],"version-history":[{"count":2,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/posts\/1124\/revisions"}],"predecessor-version":[{"id":1127,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/posts\/1124\/revisions\/1127"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/media\/1125"}],"wp:attachment":[{"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/media?parent=1124"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/categories?post=1124"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/learnerbox.net\/blog\/wp-json\/wp\/v2\/tags?post=1124"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}