How AI Actually Works
10 concepts. Explained by building real products. Grounded in experience, not theory.
Everyone talks about neural networks like they're magic. They're not.
A neural network just learns by adjusting numbers. Feed it data, it guesses wrong a bunch of times, adjusts slightly, and eventually the guesses get better. That's the entire mechanism.
Think learning to drive. First time you overcorrect, miss turns, brake hard. Over time your brain adjusts. Less correction needed. Smoother. A neural network adjusts numbers instead of muscle memory.
What everyone gets wrong: They think the network "understands" something. It doesn't. It found a pattern in training data that works. Feed it new data that doesn't match that pattern, it falls apart. I've seen this building Miru and Intel. Models work great on training data. Real users hit them with edge cases and suddenly they're useless.
Words are useless to a model. It converts them to numbers. That conversion is an embedding.
Two words meaning similar things end up as numbers close to each other. "Doctor" and "nurse" are near each other. "Doctor" and "mountain" are far apart.
That's the whole trick. The model doesn't understand language. It understands geometry. Distance. Direction.
Building Intel, half the problem was making embeddings work for company intelligence. The model needed to know "revenue growth" and "sales increase" meant the same thing. Embeddings solved that by putting them geometrically close.
Words mean different things in different sentences. "Apple" is a fruit in one sentence, a company in another.
Attention is how the model figures out which meaning applies. It looks at the whole sentence, sees what matters, and focuses there.
This is why modern AI got so much better. Older systems read left to right like robots. Attention lets them see the full picture at once and understand how everything connects.
Before a model reads anything, it breaks text into tiny pieces. Tokens.
A token isn't always a full word. "Playing" might split into "play" and "ing". "Dog" stays as one token. The model works with these pieces, not words.
Why? Language is messy. New words appear constantly. Misspellings. Slang. If a model tried storing every possible word, the vocabulary would explode.
Tokenization keeps a fixed set of building blocks. The model learns patterns and reusable pieces. Encounters a word it's never seen? Breaks it down into familiar tokens.
Every model has a memory limit. How much it can read at once. Context window.
It's like working memory. Older models handled maybe 4,000 tokens. Modern ones handle 100,000 or more. That's the difference between losing track halfway through a conversation and remembering an entire book.
The catch: Bigger context costs more in memory and compute. And even with huge windows, models don't treat every part equally. They focus on the beginning and end. Middle gets lost. This is why sometimes a model "forgets" something you clearly mentioned earlier. The information was there. The attention just didn't land on it.
Sometimes the model sounds completely confident. And completely wrong.
It might mention a research study that doesn't exist. Suggest an API that was never created. Present made-up facts like they're obvious.
Why? Because a language model isn't trying to tell the truth. It's trying to generate the next probable piece of text.
It learned patterns from massive data. Its job is to continue those patterns naturally. But it doesn't verify whether what it says is correct. If a false statement looks like what should come next, the model generates it with confidence.
Real talk: you can't just trust the output. Especially for facts, code, or decisions. The model is incredibly good at sounding right. But it still needs you to check if it actually is.
When a model generates text, it's calculating probabilities for every possible next word. Temperature controls how strict or creative that choice is.
Low temperature: Model plays it safe. Always picks the most likely next word. Output is predictable and consistent. Good for code, summaries, anything where accuracy matters.
High temperature: Model gets flexible. Explores other options based on their probabilities. Output feels more natural or creative. Good for brainstorming or writing variations.
Push it too high? Things get unpredictable. Surprising and imaginative but also incoherent.
Temperature is just controlling behavior. Lower makes it precise and reliable. Higher makes it creative and diverse.
Hallucinations exist because models only know what they learned during training. Old data. No real-time information.
RAG fixes this. Instead of relying only on what the model knows, you give it access to real information at the moment it answers.
Before generating a response, the system searches for useful documents from a knowledge source. Those documents get passed into the model as context. The model uses them to produce a grounded answer.
Think of it as allowing the model to look things up first.
Building Miru and Intel, RAG was crucial. The models needed access to current company data, not just training data from months ago. RAG lets you update your knowledge base without retraining the model.
You take a pretrained model. Continue training it on your specific data. The model already knows general patterns. You guide it in a specific direction.
Like specialization. A general model answers all kinds of questions. But if you want it performing really well in a specific area, you fine-tune it with focused data.
Want a model that understands legal documents? Train it further on contracts, case summaries, legal explanations. Over time it responds in ways that fit that domain.
The cost: Fine-tuning updates billions of parameters. Requires serious infrastructure. Multiple GPUs. Significant compute. So while fine-tuning is powerful, it's not lightweight. You get control and customization. You pay for it in complexity and cost.
Everything so far: models that generate text. Agents are different. They take actions.
An agent doesn't just respond. It interacts with tools. Runs code. Searches for information. Calls APIs. Combines these steps to complete a task.
Most agents operate in a loop. Look at current situation. Decide what to do. Take an action. Repeat based on what changed. The model decides at every step.
Cowork is an agent framework. Instead of asking "what should I do?", it actually does it. Reads your email, searches Drive, updates documents, sends messages. All automatically based on instructions you give it.
Here's the catch: Every step has a chance of going wrong. Small errors add up. A task that looks simple can become unreliable with multiple decisions in a row. That's why building good agents isn't just about capability. It's about reliability. Planning. Validation. Self-correction to keep multi-step workflows on track.