Concepts

What is AI, ML & Deep Learning?

AI, machine learning, and deep learning are nested circles, not synonyms — and which one you are looking at predicts how a system fails.

Neural Networks, Intuitively

A neural network is a big stack of adjustable knobs that turns numbers into numbers; learning is just nudging those knobs toward less error.

What Is a Large Language Model?

An LLM is a huge next-token predictor; scale turned that one simple objective into abilities nobody explicitly programmed.

Training vs Inference

Training builds the model’s frozen weights once; inference runs them per request and never changes them — which answers most cost and privacy questions.

Tokens & Tokenization

Models see integers, not text; the hidden tokenization step explains your bill, your context limit, and odd failure modes.

Embeddings: Meaning as Geometry

Embeddings turn things into points in space so that similar becomes close — the engine behind search, recommendations, and RAG.

Transformers, at a High Level

Self-attention lets every token look at every other token; that one idea fixed long-range memory and unlocked GPU-scale training.

Generation & Sampling: Temperature

The model returns a probability distribution, not an answer; temperature reshapes it, and temperature 0 is low-variance, not deterministic.

What Is an AI Agent?

An agent is a model placed in a loop with tools, choosing each next action toward a goal — the core mental model.

The Agent Loop

Reason → act → observe → repeat: tracing a tool call from the model through the harness into the environment and back.

Autonomy Levels

A five-rung ladder from suggest to fully autonomous, and why the right level is a per-action engineering decision.

Agents vs Chatbots vs Workflows

One question — who decides the next step — sorts any LLM system into chatbot, pipeline, workflow, or agent.

Tools, Actions & Environments

What a tool really is, read vs write actions, and why the environment — not the model — is where agents become dangerous.

Goals, Planning & Termination

The planning spectrum from reactive to deliberative, and the under-appreciated hard problem of knowing when an agent is done.

When to Use an Agent

The three properties a task needs to justify an agent, the cheaper patterns that solve most cases, and clear do-not cases.

Risks & Limits of Agents

The four characteristic loop failure modes, the security shift autonomy brings, and what "safe agent" honestly means.

Prompting basics

The four levers that move output quality: instruction, context, examples, output shape.

System vs user prompts

Message roles, the instruction hierarchy, and never letting data act as instructions.

Few-shot prompting & examples

When examples beat instructions, how to choose/order them, and where they stop paying off.

Context windows explained

The finite shared token budget, the three limit failures, and managing it actively.

Tool / function calling explained

The model proposes, your code disposes: the request/response shape, the loop, the safety rules.

Retrieval-augmented generation (RAG) explained

Retrieve→augment→generate, RAG vs alternatives, and debugging it in two halves.

Chunking & vector search intuition

Why we chunk, embeddings as coordinates, nearest-neighbour search, hybrid + reranking.

Structured outputs

From "ask for JSON" to schema-constrained decoding, plus schema design and defensive parsing.

The model landscape: families & providers

A vendor-neutral map of the major model families and a durable mental model for placing any new release.

Open-weight vs closed models

Control, cost, privacy, licensing and lock-in — the real engineering trade-offs, without the marketing.

Modalities & multimodal models

Text, vision, audio, code: input vs output modalities and why "multimodal" is a spectrum, not a checkbox.

Cost, quality & latency

Model size and the trade-off triangle that dominates production model economics, and how to engineer around it.

Reasoning vs non-reasoning models

What inference-time "thinking" actually does, when it helps or wastes money, and why it is now a dial.

Agent frameworks & orchestration

LangChain, LlamaIndex, provider SDKs and the broader landscape — by category and trade-off, not by brand.

Serving & access: APIs, local, gateways

Model choice and serving choice are orthogonal: first-party APIs, cloud catalogs, inference providers, self-host, gateways.

Reading benchmarks critically

Why leaderboard rank rarely predicts your task, and why a small custom eval set beats every public number.

Choosing a model: a checklist

A repeatable, constraint-first decision procedure that synthesizes the whole topic and survives a fast-moving field.