Revised 2026-08-16 — rewritten for clarity. The argument is unchanged from the original.

Two years ago I didn’t set out to learn AI. I just started using AI coding assistants, and at the time it felt like a better autocomplete.

It turned into something much bigger. Looking back, the path went roughly like this: assistants, then tools that understood a whole repo, then the model APIs underneath them, then embeddings, RAG, tool calling, skills, agents, workflow engines, memory, multi-agent setups, and finally platforms. Each step mostly existed to solve a problem created by the step before it.

This post is my story of that progression, and what the AI stack actually looks like once you’re building on it.

It started with faster loops

The first thing that changed was speed. My old loop was search, read, try, fail. The new one was ask, generate, run, fix. Learning got faster mostly because the cost of trying something dropped.

Then the tools grew past a single file. Once they could see the whole project, the conversation moved from “write this function” to “where should this live”—AI started helping with architecture, not just typing.

Calling the models directly

Using the APIs directly taught me how little there is at the bottom: a model, some tokens, and a context window. That’s it. Everything else—retrieval, routing, retries, state—is engineering you build around it.

That was clarifying, and a little deflating. There’s no magic layer you’re missing. There’s a stateless function call, and a lot of systems work to make it useful.

Getting the model to use my data

Embeddings were the first real unlock. Turning text into vectors meant I could search my own content by meaning and feed the relevant parts back in as context. That’s what made real applications possible instead of demos.

RAG is the pattern built on top of that, and it works—knowledge bases, docs, and internal tools all get noticeably better. But RAG has a ceiling. It answers questions. It doesn’t do anything.

From answering to doing

Tool calling broke that ceiling. Once the model can query a database, call an API, read a file, or kick off a job, it stops being a text generator and starts acting on real systems.

Complexity grew immediately. Every tool is a new failure mode, a new permission question, and another thing to explain in the prompt. Skills helped here: instead of repeating the same instructions everywhere, I could package a capability once and reuse it. Fewer tokens, and more importantly, consistent behavior.

Agents are a backend problem

An agent is roughly skills plus tools plus memory, wrapped in a loop. That combination is genuinely capable—it can take a goal and work at it. It’s also the point where I stopped thinking about prompts and started thinking about infrastructure.

Real systems need queues, retries, state, and scheduling. None of that is AI-specific; it’s ordinary backend engineering, and skipping it is why so many agent demos fall apart the moment they run unattended.

Memory is the other half. Agents need long-term state—conversation history, vector memory, event logs, durable facts. Without it, behavior drifts between runs. With it, behavior becomes stable enough to trust.

Many agents, then platforms

Past a certain size, a single agent stops being the right shape. You end up with a planner, workers, tool services, and something that owns memory—which is to say you end up with a distributed system, and all the coordination problems that come with one.

The step after that is platforms. Not one agent doing more, but many agents sharing tools, memory, and policy. That’s where I think this is heading.

The stack

Written out, the layers look like this:

• Product
• Platform
• Multi-agent
• Workflow
• Agents
• Skills
• Tools
• RAG
• Embeddings
• LLM API
• Model

What I take from it

The future isn’t prompts. It’s systems. Cost, control, and reliability all push in the same direction: toward better architecture, clearer boundaries, and less cleverness in the prompt.

The part that surprised me most is that agents require more backend, not less. The model handles what used to be the hard part, and everything you already knew about queues, state, and failure handling turns out to be exactly what’s needed around it.

Two years ago I started using AI assistants. Today I see a whole new software stack—and we’re still at the beginning.