Views: 9
Most “learn AI” content today teaches you to assemble — wire an LLM API into a framework, call it an agent, ship it. That’s a real and useful skill. It is not the same as understanding the system you just built.
From Zero to Agents is a free, open course that starts at zero and walks all the way to modern agentic AI systems — the kind powering production tools today — without skipping the foundation underneath them.
Why start from zero when you already work with AI in production?
Because production experience and first-principles understanding are different things. You can wire together a working agent pipeline without ever deriving why a transformer’s attention mechanism behaves the way it does, or why a fine-tuned model’s embeddings drift the way they do. Those gaps don’t matter — until the day they do, usually at the worst possible time, in production.
This course rebuilds that foundation deliberately: text representation, the underlying math, neural networks from scratch, and only then the current research frontier — agentic workflows.
The three-lens teaching method
Every concept in this course is explained three ways before moving on:
- Theory — the intuition and the “why” behind the idea.
- Math — the actual formalism, derived, not hand-waved.
- Code — implemented twice: once in raw Python with no shortcuts, so the mechanism is visible, and once using the standard library (like PyTorch), so the abstraction is understood rather than just trusted.
Nothing moves forward until all three are covered.
How the course is structured
The course is organized into modules, each containing several episodes. Each episode tackles one discrete concept, in full, with worked examples and runnable code. Every episode ships in three forms: a markdown write-up on GitHub, an adapted post here on the blog, and eventually a chapter in a compiled ebook.
The provisional roadmap:
- Module 0 — Introduction: methodology and framing (you’re reading part of it now).
- Module 1 — Representing Language as Numbers: tokenization, encoding, embeddings.
- Module 2 — Math Foundations: vectors, matrices, calculus, probability — only what’s needed, built as it’s needed.
- Module 3 — Neural Networks from First Principles: perceptrons through backpropagation, by hand and in PyTorch.
- Later modules: attention, transformers, fine-tuning (including LoRA), and agentic systems — planning, tool use, memory, multi-agent coordination.
At its core, Artificial Intelligence (AI) is the discipline of creating algorithms that allow computers to perform tasks that previously required human cognitive abilities—such as reasoning, recognizing patterns, making decisions, and processing natural language.
While “AI” sounds like a single entity, it is actually a hierarchy of nested concepts:
┌─────────────────────────────────────────────────────────────┐
│ ARTIFICIAL INTELLIGENCE (AI) │
│ Systems that mimic human decision-making and logic │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ MACHINE LEARNING (ML) │ │
│ │ Algorithms that learn patterns from data │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ DEEP LEARNING (DL) │ │ │
│ │ │ Multi-layer neural networks (Representation)│ │ │
│ │ │ ┌───────────────────────────────────────────┐ │ │ │
│ │ │ │ GENERATIVE AI & AGENTS │ │ │ │
│ │ │ │ LLMs, Multi-Agent Systems, Steering │ │ │ │
│ │ │ └───────────────────────────────────────────┘ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
The Core Branches: Vision vs. Text (Language)
Modern Deep Learning generally splits into two major sensory domains, each with its own underlying mathematical structures:
| Domain | Primary Modality | Core Math Primitive | Architectural Benchmark | Primary Use Cases |
| Computer Vision (CV) | Spatial grid arrays (Pixels) | 2D/3D Convolutions ($\ast$), Spatial Pooling | CNNs, Vision Transformers (ViT), Diffusion | Image recognition, medical imaging, video synthesis |
| Natural Language (NLP) | Discrete, sequential symbolic tokens | Vector Embeddings, Sequence Gating, Self-Attention ($Q, K, V$) | RNNs, GRUs, Transformers, LLMs | Machine translation, code generation, reasoning, Agentic AI |
Why Our Focus is Text & Sequential Intelligence
While image generation is visual and expressive, language is the native substrate of reasoning, logic, and planning.
By focusing on text and sequence modeling, we gain direct access to the exact primitives that make modern Large Language Models (LLMs) and Agentic AI possible. Understanding how a model handles sequence dependencies gives you the keys to building reasoning engines, code assistants, and autonomous agents.
- Theoretical Intuition (Layman Perspective): We start with high-level conceptual analogies and the historical problem the creators were trying to solve.
- Mathematical Formulation: We strip away black-box abstractions and break down the exact linear algebra, calculus, and probability equations powering the system.
- From-Scratch Python/PyTorch Code: We implement the mechanism step-by-step—first using raw Python lists and loops to see the gears turning, then converting it to production-grade PyTorch tensors.
- Curated Paper Reading: Each post concludes with the essential academic papers that defined that specific breakthrough, giving you a researcher-level bibliography.
Recommended Foundational Reading
Before diving into Episode 1, explore this classic survey to contextualize where language technology started:
- Jurafsky & Martin: Speech and Language Processing (3rd ed. draft) — Chapter 6: Vector Semantics and Embeddings.
Follow along
New episodes land on GitHub and here on the blog as they’re written. If you want a head start on Episode 1, sit with this question first: what makes a system intelligent — not fast, not smart, but intelligent — and where does your own definition start to break down?
We’ll dig into that next.
Leave a Reply