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.

Prompt injection, in plain words

What prompt injection actually is, why it's not a bug a vendor can patch, and the three real defenses available to you.

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.

Guardrails, in plain words

Guardrails are pre/post-checks around a model call, not a wall around the model — what they catch, what they miss, and where they live.

Evals, in plain words

An eval is a small, trusted scoreboard you run against your own task — why public benchmarks aren't enough, and what a useful eval set looks like.

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.