DEV Community: Kristof Dreier

But what exactly is an AI agent? — Part 2

Kristof Dreier — Tue, 17 Feb 2026 23:11:10 +0000

This is the second part of a multi part series covering AI agents. Today we are going to build one from scratch. If you haven't read Part 1, feel free to do so. I'll wait here. Done? Good. Let's get our hands dirty.

What About Bot?

We start with the simplest chat bot you can imagine. It cannot do much — just replying to what you wrote — but it's ours.

import OpenAI from "openai";
import * as readline from "readline";

const client = new OpenAI();

const terminal = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

function main() {
  terminal.question("You: ", async (input) => {
    const completion = await client.chat.completions.create({
      messages: [{ role: "user", content: input }],
      model: "gpt-52-chat",
    });

    const reply = completion.choices[0].message.content;

    terminal.write(`Assistant: ${reply}\n`);
    main();
  });
}

main();

It works, but it's also a little weird. It's not a conversation, since the LLM only knows the latest message. It does not have knowledge of your previous messages. It cannot remember, because every call starts from scratch. Imagine waking up every morning at 6 am — listening to the same radio station — having the same conversation with the same people over and over again. This is what talking to our current chat bot implementation feels like. Let's fix that.

I Know What You Did Last Summer

Remembering the name of a colleague you just met and casually bringing it up in a conversation or being haunted right before you fall asleep by an embarrassing memory from when you were a kid. Memories come in all shapes and sizes. We, as in we humans, have a short-term memory and a long-term memory. We also have an ultrashort-term memory, but for the sake of this article, we will only look at short- and long-term storage.

Memento mori

In our short-term memory we hold everything we need to recall in the moment — and forget it once it's no longer needed. The sentence that you just read and the one that you are reading now are stored in short-term memory. You will probably have forgotten about it, when you finished this article, or already after the next paragraph. It's also limited and rather small when it comes to storage capacity. If we want our chat bot to feel less like a stranger and more like someone who actually pays attention, we need to give it something similar. For LLMs, this is called the context window. Let's add it to our chat bot.

import OpenAI from "openai";
import * as readline from "readline";

const client = new OpenAI();

const terminal = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const messages = [];
function main() {
  terminal.question("You: ", async (input) => {
    messages.push({ role: "user", content: input });
    const completion = await client.chat.completions.create({
      messages: messages,
      model: "gpt-52-chat",
    });

    const reply = completion.choices[0].message.content;
    messages.push({ role: "assistant", content: reply });

    terminal.write(`Assistant: ${reply}\n`);
    main();
  });
}

main();

Nice, with the context window the LLM remembers all of our messages and its responses. It also can store quite a bit of data. But just like our short-term memory, it's not endless either. We will look into how we can solve that in the next chapter. Let's first fix a potential amnesia issue.

Stay with me

One downside of the current implementation is that our chat bot will forget everything once you close the terminal. All messages are only stored in memory and terminating the process, gets rid of all messages. Instead of building a sophisticated session system — similar to what Open Claw uses — we will store all conversations in one single file and load it on startup.

import OpenAI from "openai";
import * as readline from "readline";
import * as fs from "fs";

const client = new OpenAI();

const terminal = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const memoryFilePath = "messages.jsonl";

function loadMessages() {
  if (!fs.existsSync(memoryFilePath)) {
    return [];
  }

  return fs
    .readFileSync(memoryFilePath, "utf-8")
    .split("\n")
    .filter(Boolean)
    .map(JSON.parse);
}

function appendMessage(message) {
  fs.appendFileSync(memoryFilePath, JSON.stringify(message) + "\n");
}

const messages = loadMessages();
function main() {
  terminal.question("You: ", async (input) => {
    const userMessage = { role: "user", content: input };
    messages.push(userMessage);
    appendMessage(userMessage);
    const completion = await client.chat.completions.create({
      messages: messages,
      model: "gpt-52-chat",
    });

    const reply = completion.choices[0].message.content;
    const assistantMessage = { role: "assistant", content: reply };
    messages.push(assistantMessage);
    appendMessage(assistantMessage);
    terminal.write(`Assistant: ${reply}\n`);
    main();
  });
}

main();

Great, we have a basic working conversation memory. Every single interaction of our conversation is now persisted as JSON Lines in the messages.jsonl on disk. Once we restart the terminal, the chat bot will have the full conversation present.

We use JSON Lines instead of a regular JSON array because it lets us append new messages without reading and rewriting the entire file.

Context compaction

While the context windows of recent models got bigger over time, they are not endless. Just as our short-term memory starts to forget things when someone just throws stuff at us — do you remember the first sentence from the Memento Mori paragraph? — an LLM will simply refuse to accept more input once its context window is full. This is an issue that all agents with long-running conversations have and one solution is context compaction: summarize old messages and keep the most recent ones. Our implementation is again simple, for illustration purposes.

import OpenAI from "openai";
import * as readline from "readline";
import * as fs from "fs";

const client = new OpenAI();

const terminal = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const memoryFilePath = "messages.jsonl";

function loadMessages() {
  if (!fs.existsSync(memoryFilePath)) {
    return [];
  }

  return fs
    .readFileSync(memoryFilePath, "utf-8")
    .split("\n")
    .filter(Boolean)
    .map(JSON.parse);
}

function appendMessage(message) {
  fs.appendFileSync(memoryFilePath, JSON.stringify(message) + "\n");
}

function saveMessages(messages) {
  fs.writeFileSync(
    memoryFilePath,
    messages.map(JSON.stringify).join("\n") + "\n",
  );
}

async function compactMessages(messages) {
  // Naively estimate token count based on character length, assuming 4 characters per token on average
  const estimatedTokens =
    messages.reduce(
      (count, message) => count + JSON.stringify(message).length,
      0,
    ) / 4;

  // Current models typically support 128K to 200K tokens, so we can set a threshold to trigger compaction before hitting limits
  if (estimatedTokens < 105_000) {
    return messages;
  }

  terminal.write("Compacting conversation ...");

  // Split messages into two halves: older messages to summarize, recent messages to keep intact
  const split = Math.floor(messages.length / 2);
  const old = messages.slice(0, split);
  const recent = messages.slice(split);

  const summary = await client.chat.completions.create({
    messages: [
      {
        role: "user",
        content: `Condense the following conversation into a brief summary.
Focus on:
- Who the user is and what they care about
- Decisions made and their rationale
- Outstanding tasks or unresolved questions
- Any specific details (names, numbers, paths) that would be lost without explicit mention

Drop all conversational filler.

${JSON.stringify(old, null, 2)}`,
      },
    ],
    model: "gpt-52-chat",
  });

  const compacted = [
    {
      role: "user",
      content: `## Previous Conversation Summary\n ${summary.choices[0].message.content}`,
    },
    ...recent,
  ];
  saveMessages(compacted);

  return compacted;
}

let messages = loadMessages();
function main() {
  terminal.question("You: ", async (input) => {
    messages = await compactMessages(messages);
    const userMessage = { role: "user", content: input };
    messages.push(userMessage);
    appendMessage(userMessage);
    const completion = await client.chat.completions.create({
      messages: messages,
      model: "gpt-52-chat",
    });

    const reply = completion.choices[0].message.content;
    const assistantMessage = { role: "assistant", content: reply };
    messages.push(assistantMessage);
    appendMessage(assistantMessage);
    terminal.write(`Assistant: ${reply}\n`);
    main();
  });
}

main();

We added compactMessages which takes care of checking if we are still in the context window limit. Once we start exceeding it, we will create a summary with the first half of your conversation. Together with the most recent messages this will be our new short-term memory, or context window. We also had to add saveMessages as we have to overwrite message.jsonl and we check and compact on every turn.

Total Recall

How would you feel, if your brain put everything directly into long-term memory once you experienced something? I'd argue things would get overwhelming and intense pretty quickly. When it comes to long-term memory, storing a memory becomes a bit more complicated. While short-term is mostly automatic, long-term is more selective, and there are a few mechanisms that determine what we deem worthy of storing. It's a bouncer deciding who is coming in and who's not. Our chat bot has to become a bouncer, deciding for itself which information to keep and which to discard, and since long-term memories are not automatically part of the context window, it also needs the ability to recall said information. In short: we need to give it tools.

But tools deserve their own chapter, and so does the question of how an agent decides what to remember and when to recall it. We'll tackle both in Part 3.

Until next time.

P.S.: If you have questions in the meantime, feel free to reach out. I'm always happy to help and support where I can!

But what exactly is an AI agent?

Kristof Dreier — Mon, 16 Feb 2026 05:47:22 +0000

This is the first episode in an ongoing series called But what exactly is ....
I usually learn better when I write things down. It forces me to find the right words and that usually helps to get the concept clearer. Without further ado, let's dive right in.

You'll hear people say agentic AI, AI agent, agentic assistant. The naming is a mess and nobody fully agrees. Think of it as a spectrum: a chatbot answers questions, an assistant helps when asked, and an agent goes off and does things on your behalf. Most of what's out there today sits somewhere in between. For this article, I'll just call it an agent and move on.

First contact

My introduction to large language models was through chat interfaces, namely ChatGPT. Having a software engineering background I wanted to build my own chat interface, mainly because I wanted to understand how the magic actually worked. I started playing around with the chat completions endpoint from OpenAI, building my own ChatGPT. It was just API call after API call. No magic involved.

Later I learned the real magic is with how the models are being created and trained, but that’s another story, and shall be told another time.

Fly, you tools!

The chat completions API got more powerful when function calling, erm tool calling, was introduced. On top of the turn-based message exchange, the model could now return a special tool call instruction. You could use that to fetch additional information, interact with files, or call other APIs. Everything was orchestrated by the service that called the chat completions API.

This was great. Instead of just generating text, the LLM could now reply with structured intentions. Rather than being stuck with the User → Model → User → Model loop, we could do multi-step loops — User → Model → Tool → Model → Tool → Model → User. With the introduction of tool calling, all the building blocks for agentic AI were there. It still took a while to make the jump, though.

But what exactly are AI agents?

From a conceptual perspective, an AI agent autonomously takes actions based on a high-level goal and remembers what it did across sessions. From a technical perspective, it's a while-loop with an LLM, some tools, and a growing context window.

So why did it take a while to get there? After all, the building blocks were all there. Well, function calling was not really reliable — hello hallucinated tool call, my old friend — context windows were rather small — wait, didn't I already fetch that information? — and who in their right mind would trust an LLM with access to their computer? And hey, have you seen the latest chatbot that I just built? Uh, shiny!

What does it take to turn our good ol' chat bot into an AI agent? Everything was already there. No secret sauce, no breakthrough invention. If you look at projects like OpenClaw, they all combine the same handful of ingredients.

My... precious...

When you start a new conversation with a chat bot, that session has no idea what you talked about in previous ones. Groundhog Day all over the place. When we give the LLM memories, the agent is primed with context from past conversations, including what worked, what didn't, and what you care about. There are different types of memory, just as we have short- and long-term memory, but that is worth it’s own article.

Look Mom... No hands

Tool calling gives the LLM the ability to "reach out". It can gather information from the web, run commands or control applications on your machine. Or read and reply to your emails. Or check your bank balance and go on a shopping spree. The more tools it has, the more autonomous it feels — and, yeah, the scarier it gets.

Wake up, Neo ...

While you start the interaction with a classical chat bot, AI agents can be invoked on a schedule. Want to read your morning digest of what happens in the world on the way to work? A scheduler invokes the agent at a predefined time, and it can look up the latest news and have an overview ready for you. It doesn't have to be just mornings. You define the heartbeat of your agent.

Everything Everywhere All at Once

Ultimately it's also about how you interact with it. Instead of a textbox in a browser, you use your favorite chat application. The agent meets you where you already are — always there, a fingertip and a notification away.

We need to cook!

Now that we have our building blocks conceptually ready, we want to create our own AI agent. In the next installment, we will start simple, with a basic chat bot, and work our way up from there. It won't be Open Claw in the end, but the goal is to show you how to pull the rabbit out of the hat and not do a full Copperfield magic show.

If you have questions in the meantime, feel free to reach out. I'm always happy to help and support where I can!

Until next time.