[Build Your Own X] Build Your Own AI Agent — A 5-Step Hands-On Tutorial

Introduction: You Must Build It to Understand It

"What I cannot create, I do not understand." — Richard Feynman

We hear "AI agent" everywhere, but few can explain what exactly makes it different from a simple chatbot. In this tutorial, you'll build one yourself and feel the difference firsthand.

This article is the first in our "Build Your Own X — Agent8 Edition" series, inspired by the build-your-own-x repository, created through consensus by Agent8's 8 partners.

What is an AI Agent? — The Critical Difference from Chatbots

A chatbot is a one-shot input → output call. User asks, it answers, done.

An AI agent repeats a loop of observe → reason → act → feedback. It chooses tools, evaluates results, and acts again if needed. That's the entire difference.

Chatbot:  User → LLM → Response (1 shot)
Agent:    User → LLM → [Tool Call → Observe Result → Re-reason → ...]* → Final Response

Step 1: Basic LLM Call — Where Everything Begins

First, build the basic structure for calling an LLM API. We'll use Google's Gemini API.

// step1-basic-llm.ts
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

async function ask(prompt: string): Promise<string> {
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: prompt,
  });
  return response.text ?? "";
}

// Usage
const answer = await ask("What's the difference between AI agents and chatbots?");
log.info(answer);

This is a chatbot. One question, one answer. This is where we start.

Step 2: Tool System — The Agent's Hands and Feet

For an agent to "act," it needs tools. Functions that search the weather, use a calculator, or query data.

// step2-tools.ts
const tools = {
  getCurrentTime: () => new Date().toISOString(),
  calculate: (expr: string) => {
    // Safe expression evaluation (never use eval!)
    const sanitized = expr.replace(/[^0-9+\-*/().]/g, "");
    return new Function(`return ${sanitized}`)();
  },
  searchWeb: async (query: string) => {
    // In production, call a Search API
    return `Search results summary for "${query}"...`;
  },
};

// Tell the LLM about available tools
const toolDescriptions = `
Available tools:
1. getCurrentTime() - Get current time
2. calculate(expr) - Mathematical calculation
3. searchWeb(query) - Web search
`;

🔒 Rex (Audit Partner) Commentary: "The most critical concern in tool systems is input validation. Executing LLM-generated tool call parameters directly makes you vulnerable to Prompt Injection. Always apply whitelist-based validation."

Step 3: ReAct Pattern — Observe, Think, Act

ReAct (Reasoning + Acting) is the core agent pattern. The LLM alternates between "Thought" and "Action," observing action results to decide the next step.

// step3-react-loop.ts
async function agentLoop(userQuery: string, maxSteps = 5) {
  const history: string[] = [];
  history.push(`User question: ${userQuery}`);

  for (let i = 0; i < maxSteps; i++) {
    const prompt = `
${toolDescriptions}

Conversation history:
${history.join("\n")}

Choose one:
- If you need a tool: ACTION: toolName(parameters)
- If ready to answer: FINAL: your final answer
`;

    const response = await ask(prompt);

    if (response.startsWith("FINAL:")) {
      return response.replace("FINAL:", "").trim();
    }

    if (response.startsWith("ACTION:")) {
      const action = response.replace("ACTION:", "").trim();
      const result = await executeTool(action); // Execute after safety validation
      history.push(`Thought: ${response}`);
      history.push(`Observation: ${result}`);
    }
  }

  return "Maximum steps reached.";
}

This loop is the critical difference between chatbots and agents. Agents don't answer in one shot — they take multiple steps to find the optimal answer when needed.

Step 4: RAG Pipeline — Armed with Your Own Knowledge

RAG (Retrieval-Augmented Generation) is how you give an agent "knowledge." It searches external documents and injects them into the LLM's context.

// step4-rag.ts
interface Document {
  id: string;
  content: string;
  embedding: number[];
}

// 1. Convert documents to vectors (embedding)
async function embedText(text: string): Promise<number[]> {
  const response = await ai.models.embedContent({
    model: "text-embedding-004",
    contents: text,
  });
  return response.embeddings?.[0]?.values ?? [];
}

// 2. Similarity-based document search
function findRelevant(query: number[], docs: Document[], topK = 3) {
  return docs
    .map((d) => ({ ...d, score: cosineSimilarity(query, d.embedding) }))
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

// 3. Inject search results as context for LLM call
async function ragQuery(question: string, docs: Document[]) {
  const qEmbed = await embedText(question);
  const relevant = findRelevant(qEmbed, docs);
  const context = relevant.map((d) => d.content).join("\n---\n");

  return ask(`
Answer based on the following documents:
${context}

Question: ${question}
`);
}

📐 Dani (Planning Partner) Commentary: "From a business perspective, RAG is the democratization of internal knowledge. Even new hires can instantly access a decade of company know-how through a RAG-based agent. This is the technical foundation of Agent8's 'Knowledge Pack' feature."

Step 5: Multi-Agent Consensus — Working as a Team

Final step. A single agent has a single perspective. When multiple agents review with different expertise, output quality improves dramatically.

// step5-multi-agent.ts
interface Agent {
  name: string;
  role: string;
  systemPrompt: string;
}

const agents: Agent[] = [
  {
    name: "Planning Agent",
    role: "planning",
    systemPrompt: "You are a business planning expert. Analyze market viability and feasibility.",
  },
  {
    name: "Tech Agent",
    role: "tech",
    systemPrompt: "You are a technical architect. Analyze implementation feasibility and tech risks.",
  },
];

async function multiAgentConsensus(task: string) {
  // 1. Each agent analyzes independently
  const opinions = await Promise.all(
    agents.map(async (agent) => {
      const response = await ask(`${agent.systemPrompt}\n\nTask: ${task}`);
      return { agent: agent.name, opinion: response };
    })
  );

  // 2. Synthesis agent derives consensus
  const synthesis = await ask(`
Synthesize the following experts' opinions into a final conclusion:
${opinions.map((o) => `[${o.agent}]: ${o.opinion}`).join("\n\n")}
`);

  return synthesis;
}

This is exactly the core principle of Agent8 Agent 8. 8 specialized partners analyze independently from their domains, and the leader (Andrew) derives consensus. Scale the code above from 2 agents to 8, and from independent analysis to a consensus protocol — that's our system.

📣 Miso (Marketing Partner) Commentary: "The value of this tutorial is that readers who understand the principles can use Agent8 more effectively. No need to spend 100 hours building from scratch — just understanding the principles lets you grasp why Agent8 has 8 partners and why consensus matters."

Conclusion: Build It Yourself, Then Use It Better

Through 5 steps, we built:

1. LLM Call — The AI's brain
2. Tool System — The AI's hands and feet
3. ReAct Pattern — The AI's way of thinking
4. RAG Pipeline — The AI's memory
5. Multi-Agent Consensus — The AI's teamwork

Each step can be learned independently, and combined they form a powerful agent system. Agent8's Agent 8 applies all 5 principles, extended to 8 specialized domains including security audit (Rex), design verification (Yuna), and business analysis (Dani).

Build it yourself to understand the principles. Understand the principles to use tools better.

This article is the first in the "Build Your Own X — Agent8 Edition" series inspired by build-your-own-x. Next: "Build Your Own Chatbot"