Artificial Intelligence

---

Prompt engineering is the practice of designing clear, structured instructions that help AI models produce better, more accurate results. It’s all about choosing the right wording, adding context, and guiding the model toward the outcome you want. Good prompts turn vague ideas into useful responses, making AI a powerful tool for coding, writing, and problem‑solving.

For most of AI's history, models could only respond — you asked a question, it gave an answer. AI agents change that. An agent is an AI that can take actions: it can browse the web, write and run code, send emails, search databases, and make decisions — all on its own, step by step, to complete a goal you give it.

Think of it like the difference between asking someone for directions versus hiring a driver. The model goes from answering to actually doing.

To make this work, agents rely on a few key ideas. First, tool use — giving the AI access to external capabilities like a calculator, a search engine, or an API. Second, memory — letting the agent remember what it has already done so it doesn't repeat itself or lose track. Third, planning — breaking a big goal into smaller steps and deciding what to do next at each stage.

Agents can also work in teams. Multi-agent systems have multiple AI models collaborating, each handling a different part of a task, with one acting as an orchestrator directing the others. This mirrors how a real team works.

Popular frameworks like LangChain and AutoGPT made this approachable by giving developers ready-made building blocks to wire these pieces together. Today, major products like customer support bots, coding assistants, and research tools are all built on agentic foundations.

Understanding agents matters because it represents the shift from AI as a tool you talk to, to AI as something that works alongside you.

When most people think of learning, they picture a classroom — a teacher explains something, a student takes notes, and knowledge is transferred. Machine learning works differently. Instead of being taught rules, an AI learns by looking at examples until it figures out the patterns on its own.

There are three main ways this happens.

The first is supervised learning. You show the AI thousands of labeled examples — pictures of cats labeled "cat," pictures of dogs labeled "dog" — and it gradually learns what features separate one from the other. Once trained, it can look at a photo it has never seen before and make a reasonable guess. Most of the AI you interact with daily, from spam filters to recommendation engines, works this way.

The second is unsupervised learning. Here, the AI gets data with no labels at all. It has to find structure on its own — grouping similar things together, spotting patterns nobody told it to look for. Companies use this to segment customers into groups without knowing in advance what those groups will look like.

The third is reinforcement learning. This one is closest to how humans learn through experience. The AI takes actions, receives feedback in the form of rewards or penalties, and gradually figures out which actions lead to better outcomes. This is how AI learned to play chess and Go at a superhuman level — not by being taught moves, but by playing millions of games against itself and learning from what worked.

What makes all three powerful is that none of them require a human to manually write the rules. The AI finds the rules itself, hidden inside the data.

A large language model, or LLM, is the technology behind tools like ChatGPT, Claude, and Gemini. Understanding what it actually is — not just what it does — changes how you use it and why you trust it the way you would trust any other tool: carefully and with context.

At its core, an LLM is a system trained to predict what comes next in a sequence of text. That sounds simple, but the scale of it is what makes it powerful. These models are trained on enormous amounts of written text — books, articles, websites, code — and through that process they develop an internal representation of how language, ideas, and facts connect to one another.

When you type a prompt, the model does not look up an answer in a database. It generates a response one piece at a time, each piece chosen based on what is most likely to follow everything that came before it. Those pieces are called tokens — roughly chunks of a word — and a model processes thousands of them at once.

This is also why LLMs sometimes get things wrong. They are not retrieving facts; they are generating text that looks like the kind of text that would answer your question. If the training data contained something wrong, or if the model is pushed into territory it has little data on, it can produce a confident-sounding answer that is simply incorrect. This is called a hallucination, and it is not a bug in the traditional sense — it is a structural feature of how these models work.

 LLMs know a lot, but they have a hard limit: they only know what was in their training data, and that data has a cutoff date. Ask an LLM about something that happened last week, or about a document that lives on your company's internal drive, and it will either make something up or tell you it does not know.

RAG, which stands for Retrieval-Augmented Generation, is the solution to this problem. Instead of relying purely on what the model already knows, RAG gives the model access to a relevant piece of information right before it responds — pulled fresh from a database, a document, or a search engine.

Here is how it works in practice. You have a support chatbot for a software company. A user asks why their account is not syncing. Without RAG, the model guesses based on general knowledge. With RAG, the system first searches the company's own documentation, finds the relevant troubleshooting page, and feeds that content directly into the prompt. The model then answers using the actual documentation, not a guess.

The key pieces that make this work are embeddings and vector databases. An embedding is a way of turning a piece of text into a list of numbers that captures its meaning. A vector database stores thousands of these embeddings and can instantly find the ones most similar to a new question. When a user asks something, their question is turned into an embedding, the database finds the closest matches, and those matches get handed to the model as context.

If you have used an AI tool for long enough, you have probably caught it saying something wrong yet confidently. A fake statistic. A book that does not exist. A law that was never passed. This is called a hallucination, and it is one of the most important things to understand about how these systems work.

The word "hallucination" implies the AI is imagining things, which is a useful way to think about it. But the deeper explanation is more structural. An LLM does not store facts the way a database does. It learns patterns from enormous amounts of text, and when it generates a response, it is producing what sounds most plausible given everything it has processed — not retrieving a verified answer from a reliable source.

This means that when the model does not know something, it does not always say so. Instead, it continues generating text that fits the shape of a confident answer. The tone stays the same whether the model is certain or completely guessing, which is what makes hallucinations so easy to miss.

Several things make hallucinations more likely. Asking about very specific or niche topics gives the model less reliable training data to draw on. Asking about recent events pushes it past its knowledge cutoff. And asking leading questions can nudge the model toward confirming something false rather than questioning it.

The ways to reduce hallucinations are also worth knowing. RAG grounds responses in real documents rather than the model's internal knowledge. Asking the model to cite its sources forces it to be specific, making errors easier to spot. And treating AI output the way you would treat a first draft. Useful, but worth checking is the best practice.