It's OK to Feel Lost in AI Right Now

New terms. New tools. New architectures. New frameworks. Every single week, before you've made sense of last week's. This edition is your map through one corner of it. No experience required. Genuinely.

Let's be honest about something. If you've been paying even passing attention to the AI space over the last couple of years, you've encountered a relentless stream of new vocabulary. Terms that get thrown around in meetings, in headlines, in job descriptions, often without explanation, as if everyone already knows what they mean.

The pace is genuinely relentless. And the uncomfortable truth is that even people who work in AI full-time don't always have a clear picture of how everything fits together. They just hide it better.

This isn't a sign that you're behind. It's a sign that the field is moving faster than anyone's ability to communicate it clearly. So today we're going to slow down, zoom out, and actually explain one part of this world properly - from the beginning, for anyone.

START AT ZERO |

What is an AI model actually doing?

Before we get to any of the tools or architectures, we need to make sure we're on the same page about the thing at the centre of all of this: the language model itself.

When you use ChatGPT, or Claude, or Gemini, what's happening under the hood is simpler than it sounds. You send a message. The model reads every word, predicts what the most useful response would be, and writes it out. That's it.

There's no memory of your previous conversations by default, no ability to look things up in real time, no connection to your company's database. Just text in, text out.

Think of a language model like a brilliant consultant who reads everything and forgets everything between meetings. Extraordinary knowledge, genuine insight, but you have to bring all the relevant documents every single time, they can't browse the web during your conversation, and they won't remember what you discussed last Tuesday.

The tools we're going to cover today are essentially the systems built around that consultant to make them actually useful at scale.

WHEN SIMPLE BREAKS |

The moment a chat becomes a system

Say you work in a company with thousands of internal documents. Someone asks: "What's our refund policy for enterprise clients signed before 2023?"

To answer that properly, a lot has to happen before the model even sees the question:

You've just built a pipeline. And if you're building many of these, for different questions, different use cases, different teams, you'll find yourself writing the same plumbing code over and over again.

TOOL #1 |

LangChain: the building blocks

LangChain gives developers standardised ways to build pipelines around language models. Instead of writing custom code for every connection and handoff, you use building blocks that already know how to talk to each other. Three ideas do the heavy lifting:

Tools are the critical unlock. They transform the model from a text generator into something that acts.

Tools are particularly important. By default an LLM can only generate text. It can't check a live price, run a calculation, or query your database. Tools give the model reach into the real world.

THE KNOWLEDGE PROBLEM |

RAG: giving the model your information

Here's a fundamental limitation: language models only know what they were trained on. That training ended at some point in the past. Your latest internal policy? Not in there. Your product catalogue updated last week? Not in there.

You can't retrain the model every time something changes. So engineers came up with something more elegant.

Instead of expecting the consultant to have memorised every document your company has ever produced, you hire a very fast researcher who sits alongside them. When a question comes in, the researcher sprints to the filing cabinet, grabs the most relevant documents, puts them on the consultant's desk, and then the consultant answers.

That's RAG. Retrieval Augmented Generation. Fetch the right context. Give it to the model. Get a grounded answer.

WHEN PIPELINES AREN'T ENOUGH |

Agents: when the model decides what to do next

Everything we've covered so far follows a fixed sequence. Step 1, then step 2, then step 3 — the same path every time. That works for predictable tasks. But what about open-ended ones?

Imagine asking: "Research the three most promising competitors to our product and write a comparison." That's not a fixed pipeline. The model needs to decide what to search for, evaluate what it finds, decide whether it has enough, search again if not, and eventually synthesise it all. The path is different every time.

That's what an agent is. Instead of following a script, it loops — reason, act, observe, repeat — until the job is done. This is called the ReAct loop.

Simple sequential chains can't model this cleanly — the path branches, loops, and makes conditional decisions. You need something more like a graph. That's LangGraph.

LangGraph also maintains a shared state object that the entire graph reads from and writes to. Each node picks up current state, does its work, updates it, and passes control forward. This makes the system fully auditable, you know exactly what information each step had.

THE PART NOBODY TALKS ABOUT |

LangSmith: seeing inside the machine

Here's the production problem nobody warns you about. When traditional software fails, it crashes; loud, obvious, with an error message. When an AI system fails, it often just gives you a subtly wrong answer. Plausible. Confident. Wrong.

Was it the prompt? Did it retrieve the wrong documents? Did the model hallucinate? In a multi-step system, the failure could have happened anywhere, and without visibility, you're just guessing.

LangSmith is the observability layer. It records every single step as a structured trace: what went in, what came out, how long it took, which tools were called.

LangSmith is also how you improve over time. Build evaluation datasets, run your system against them, and measure whether a change actually helped. Small wording changes in prompts can shift model behaviour dramatically — LangSmith lets you measure that systematically rather than hoping for the best.

PUTTING IT TOGETHER |

Three tools. One coherent idea.

These three tools aren't competitors, and they aren't interchangeable. They solve different problems at different layers of the same system.

And RAG sits underneath all of it, the technique that solves the fundamental problem that models don't know your stuff. Retrieve relevant context. Inject it. Get a grounded answer.

THE SHIFT THAT MATTERS |

Here's what's actually changing

A year ago, working with AI meant writing clever prompts. Today it means designing systems — with retrieval pipelines, reasoning loops, tool connections, and observability built in from the start. That shift is real, and it's happening fast.

But here's what I want you to take from this: you don't need to become an engineer to benefit from understanding this. You just need a clear enough picture to ask better questions, make better decisions, and spot the difference between genuine capability and expensive noise. That picture is what I'm trying to give you, one edition at a time.

If this felt like a lot, read it again next week. It'll land differently. The concepts that seem unfamiliar today become obvious surprisingly quickly once you've seen them in context, and now you have.

That's why I write this. Not to impress you with vocabulary, but to make sure you're never the person in the room who feels like they missed something. You didn't. You're right here.

Until next time,

Editor - Ideas for a Better World