AI lessons & courses

Build agent loops that finish, recover from errors, stay on budget, and produce checkable work. Start with the smallest ReAct loop; layer on state management, error taxonomy, and budgets; finish with adversarial verification panels, sub-agent orchestration, and the loop-shaped anti-patterns that ship to prod more than they should.

A compact track on how to know your LLM-powered system is actually working: LLM benchmarks vs. real evals, agent trajectory evaluation, RAG evaluation in production, and the OpenTelemetry GenAI conventions that tie traces across LangSmith, Phoenix, and Datadog LLM.

A short, modern tour of where RL is actually working in 2026: the post-RLHF landscape, DPO and its variants, RL with verifiable rewards (GRPO, DeepSeek-R1 style), and how reasoning models use RL on chains of thought.

Ten lessons that build up a modern LLM end to end — neural nets and backprop, attention and transformers, tokenization, pretraining, modern architectures and MoE, scaling laws, post-training (SFT/RLHF/DPO), and inference internals like the KV cache.

How modern coding agents are actually built: the Model Context Protocol, MCP server authoring in Python and TypeScript, agent harness design, subagent orchestration, tool-use patterns, and context engineering for long-running agents.

Nine lessons that take Retrieval-Augmented Generation past the cosine-search baseline. Chunking, hybrid retrieval with rerankers, query rewriting, GraphRAG and HippoRAG/RAPTOR, agentic multi-hop patterns, and how to actually evaluate the whole thing with RAGAS.

Go from zero to deep RL in four lessons. You will formalize sequential decision-making as a Markov Decision Process, solve small MDPs exactly with dynamic programming, implement Q-learning and SARSA from scratch, and understand DQN, policy gradients, actor-critic, and PPO well enough to use them in real projects.

Build and train neural networks from scratch. By the end you will implement forward and backward passes in NumPy, tune optimizers and regularizers to close the train-val gap, design convolutional architectures for image tasks, and read transformer papers fluently — understanding self-attention, multi-head attention, and positional encodings from first principles.

A five-lesson tour of how Meshy, Tripo, Rodin, Hunyuan3D, and Trellis actually work in 2026. Starts from the 3D representation zoo, walks through the modern image-and-text-to-3D pipeline, dives into native 3D generative models, covers texturing and PBR, and ends with the production pipeline and platform landscape.

Six lessons on choosing and using the right LLM for the job. Get a clear-eyed view of the 2026 model landscape, learn to compare capabilities honestly, understand the open-vs-closed tradeoff, and stop optimizing for benchmarks that don't predict your task.

A single-lesson taster that introduces the most fundamental concept behind every modern LLM app: the context window. Learn what tokens are, why models forget, and what 'lost in the middle' actually means in practice.

Five lessons on AI that sees, hears, and generates. Start with the unifying idea of multimodal models, dive into vision-language models and OpenCLIP, watch video generation make the leap from research to product, then bring it home with AI-aided software development.

Move beyond single prompts into agents that plan, use tools, and loop. Six lessons covering the agent mindset, the LangGraph framework, the realities of context windows, where humans belong in the loop, the security pitfalls, and how to evaluate non-deterministic systems.

A practical seven-lesson path from raw model calls to a production-ready RAG application. You'll learn how to ground LLMs in your own data, orchestrate the pieces with LangChain, observe what they actually do, and evaluate the result so you can ship with confidence.

Make loops trustworthy. Adversarial verification panels, sub-agent orchestration, loop-until-dry for unbounded discovery, loop-until-budget for paid depth, multi-modal sweeps with diverse prompts, eval-driven cap selection, and the five anti-patterns — silent caps, infinite plans, drift, premature termination, thrashing — that ship to prod more than they should.

Once an agent loop runs past a few iterations the failure surface shifts: state bloats, tool calls fail in three distinct ways, retries multiply if you stack them wrong, and unbounded budgets rack up four-figure bills overnight. The state, errors, and budgets you need to make the loop survive contact with reality.

How LLM agents actually run: the iterative prompt-action-observation loop, the ReAct shape, the smallest tool-calling loop in twelve lines, why you always stack three termination layers, what the model sees on iteration N, and when a single prompt is the better answer.

Master the OTel GenAI semantic conventions — gen_ai.* attributes, span structure for prompts/completions/tools, sampling strategies, and cost attribution — and understand why standardizing across LangSmith, Phoenix, Datadog, and Grafana matters for production AI systems.

Learn how to systematically evaluate Retrieval-Augmented Generation systems in production using RAGAS, TruLens, and Phoenix — covering golden sets, retrieval drift, embedding drift, and cost-aware eval scheduling.

A rigorous look at how to measure agent performance — trajectory-level vs final-answer evals, canonical multi-step benchmarks (SWE-bench, WebArena, OSWorld, GAIA), LLM-as-judge pitfalls, and why your eval is your spec.

A deep look at how reinforcement learning on chains-of-thought powers o1, DeepSeek-R1, Claude reasoning, and Gemini Thinking — covering GRPO, MCTS-style search, test-time compute scaling, and distillation into smaller models.

How Group Relative Policy Optimization turns unit tests and theorem provers into training signals — the technique behind DeepSeek-R1's leap in math and code reasoning without a reward model.

A deep dive into DPO (Rafailov et al. 2023) and its successors — how they reformulate RLHF as a classification problem, the math behind the implicit reward, and where each variant wins or loses against PPO-based pipelines.

Trace the full arc of Reinforcement Learning from Human Feedback — preference data, Bradley-Terry reward models, PPO with KL penalty, reward hacking, and why most labs have moved to offline alternatives like DPO and RAFT.

An honest map of RL in 2026 — the domains where it actually reaches production (LLM post-training, robotics policies, ad bidding, RLHF, reasoning models) and the places where it still cannot reliably cross the lab-to-deployment gap.

A deep dive into how large language models actually run in production — why prefill is fast and decode is slow, how the KV cache works, sampling strategies like temperature and top-p, speculative decoding, and continuous batching with vLLM.

A deep dive into how raw pretrained language models become helpful assistants — from supervised fine-tuning on curated demonstrations, through reward modeling and PPO-based RLHF, to modern direct alignment methods like DPO and the recipes used in Llama 3, Llama 4, and DeepSeek.

How two landmark papers — Kaplan et al. 2020 and DeepMind's Chinchilla 2022 — rewrote our understanding of compute-optimal training, why the industry now deliberately overtrains models, and how inference costs flip the math entirely.

A deep tour of the architectural choices powering today's large language models — decoder-only Transformers, encoder-decoder designs, grouped-query attention, RoPE positional embeddings, and mixture-of-experts routing — with concrete numbers and trade-offs.

A deep dive into how large language models learn from raw text: the next-token prediction objective, cross-entropy loss, the messy reality of web data curation (Common Crawl, dedup, quality filters), and the lineage from The Pile to FineWeb.

A rigorous tour of how modern LLMs split text into tokens — covering byte-pair encoding, GPT-2/Llama's byte-level variant, SentencePiece, vocabulary design trade-offs, and why your tokenizer silently determines multilingual fairness, code quality, and arithmetic ability.

How to manage, compress, and strategically fill the context window in long-horizon agents — covering summarization checkpoints, scratchpad memory, retrieval injection, prompt caching, and compaction triggers.

A deep dive into designing tool schemas that LLMs actually call correctly — covering parameter naming, description quality, structured output via response schemas, output parsing, and error message design that drives self-correction.

A practical deep-dive into fan-out, pipeline staging, judge panels, adversarial verification, and loop-until-dry — plus an honest accounting of when spawning subagents actually earns its token cost and when it just burns money.

Move beyond toy ReAct loops. Learn how to build a production-grade agent harness with a robust control loop, tool registry, schema validation, retry logic, token budgets, abort signals, and a persistent journal that survives crashes.

Learn to build Model Context Protocol servers from scratch using the official Python and TypeScript SDKs. Cover tool schemas, resource URIs, prompt templates, and how Claude Code, Claude.ai, and Cursor consume them.

A deep dive into MCP — Anthropic's open protocol for connecting LLMs to external tools, data, and prompts. Covers JSON-RPC transport layers, the three core primitives, capability negotiation, and how to build a working server from scratch.

A rigorous guide to measuring RAG quality using RAGAS metrics — faithfulness, answer relevancy, context precision, and context recall — plus how to build a golden dataset and recognize where automated metrics fall short.

Go beyond naive RAG pipelines. Learn how Self-RAG, Corrective RAG, and retrieval-as-tool patterns let an LLM decide when, what, and how many times to retrieve — enabling reliable multi-hop reasoning over complex knowledge bases.

Deep dive into two advanced RAG architectures — HippoRAG's hippocampal-inspired knowledge graph indexing and RAPTOR's recursive summarization tree — and why both dramatically outperform flat vector retrieval on multi-hop questions.

Go beyond dense-vector search: learn how Microsoft GraphRAG extracts entities, builds a knowledge graph, clusters it with the Leiden algorithm, and serves both local and global queries with community summaries — delivering answers that classic RAG cannot.

Master four advanced query rewriting techniques that dramatically improve RAG retrieval quality: Hypothetical Document Embeddings, multi-query expansion, query decomposition, and step-back prompting. Learn when to reach for each and how to implement them.

Build a production-grade retrieval pipeline combining BM25 keyword search with dense vector search, then sharpen precision with cross-encoder rerankers (Cohere Rerank, Voyage rerank-2, BGE). Learn when each layer matters and how to wire them together.

A deep dive into how you split documents for retrieval-augmented generation — fixed-size, recursive, semantic, hierarchical, and late chunking — with concrete trade-offs and code for each approach.

Tabular methods break down when the state space is continuous or astronomical in size. Learn how neural networks extend RL via DQN, how the policy gradient theorem makes it possible to differentiate through stochastic policies, and where actor-critic, PPO, and the deadly triad fit into the picture.

Leave the model behind. Monte Carlo methods wait for a full episode to update; TD methods bootstrap from the very next step. See exactly where SARSA and Q-learning diverge on the on-policy/off-policy axis, and why that single difference changes everything about convergence guarantees.

Master the mathematical skeleton of reinforcement learning. Learn how the agent-environment loop formalizes decision-making, why the Markov property is the key assumption, and how Bellman expectation equations link policies to value functions.

When you know the full MDP model, dynamic programming finds the optimal policy exactly. Learn the Bellman optimality equation, the contraction argument that guarantees convergence, and the concrete difference between policy iteration and value iteration — with a value-iteration code walkthrough.

Go from a raw neural network to one that actually generalizes. Covers loss functions (MSE, cross-entropy), gradient descent variants (SGD, momentum, Adam), learning-rate effects, overfitting vs underfitting, and the regularization toolkit (L2/dropout/early stopping/batch norm).

Build intuition for how artificial neurons stack into layers, why nonlinear activations are non-negotiable, and how the chain rule turns a forward pass into exact gradients — illustrated with a tiny numpy forward+backward walk-through.

Understand why fully-connected layers fail at image scale, then build up the CNN toolkit: convolutions, kernels, stride, padding, feature maps, pooling, and parameter sharing. Finish with the ResNet residual connection idea that unlocked networks of 100+ layers.

From the limits of RNNs to the self-attention mechanism that replaced them. Learn how queries, keys, and values implement scaled dot-product attention, why multi-head attention captures richer structure, how positional encodings inject order, and how all of this assembles into a transformer block.

The shift from 2D-lifting to native 3D generation. Autoregressive mesh transformers (MeshGPT, MeshAnything) and flow-matching latent models (Trellis, Hunyuan3D-2, TripoSG). Architectures, tokenization, conditioning, and which ones are actually usable in 2026.

What it takes to ship a generated mesh into a real game, AR app, or animation: topology cleanup, retopology, LODs, auto-rigging, and the 2026 platform landscape across Meshy, Tripo, Rodin, CSM and others.

The end-to-end production pipeline behind Meshy, Tripo, Rodin, and the open-source SOTA: multi-view diffusion, feed-forward reconstruction, mesh extraction, and the failure modes that still bite. Names the models, not just the concepts.

How modern 3D generation paints a mesh after it's built. UV unwrapping, multi-view diffusion for texture, view-consistency, PBR map decomposition, and the workflow Meshy and Tripo expose to users in 2026.

A working map of the 3D representations that matter in 2026 — meshes, point clouds, voxels, SDFs, NeRFs, and 3D Gaussian Splatting. What each one is, when each wins, and why mesh output still anchors production pipelines.

A field guide to the LLM benchmarks practitioners cite in 2026 — what each one measures, where it's saturated, where contamination risk is high, and why benchmark gains rarely transfer to your task without your own eval.

How frontier LLM costs and latency actually work in 2026 — input vs output token asymmetry, prompt caching, batch API discounts, TTFT and tokens-per-second, reasoning-model amplification, and when self-hosting breaks even.

A practical decision framework for picking an LLM in 2026 — define the task, build an offline eval, measure quality + latency + cost on real candidates, and avoid the classic trap of optimizing for benchmarks instead of your task.

An honest look at the open-weights vs closed-API choice for LLMs in 2026 — covering data privacy, cost at scale, fine-tuning, latency, regulatory concerns, and the gap in raw capability per dollar.

A capability-by-capability tour of frontier LLMs in 2026 — which models are strong at reasoning, code, math, long-context, multilingual, multimodal, and tool use, with hedged comparisons instead of point-estimate benchmark wars.

A practitioner's map of the major frontier-model labs as of early 2026 — who they are, what they ship, which models are open vs closed, and how the field has split into general-purpose chat and reasoning families.

How to cut LLM bills 50-90% without sacrificing freshness. Covers the three caching layers (response, prefix, semantic), what each costs to build, and the cases where caching subtly breaks correctness.

Not every AI feature should be fully autonomous. Here's where to insert humans for the biggest reliability win, the UX patterns that scale (confidence-gated review, sample audits, escalation), and the anti-patterns that turn HITL into a meeting factory.

Why traditional software testing falls apart on LLMs, the four evaluation regimes that work in practice (golden sets, LLM-as-judge, human review, online metrics), and how to wire them together without drowning in ungrounded scores.

What LangGraph adds over plain LangChain, how its nodes-and-edges model maps to real agent patterns (loops, branches, human approvals), and when to reach for it versus a simpler control flow.

What the context window actually is, why 1M-token marketing doesn't mean what you think, the cost and accuracy curves that bend as you stuff more in, and the strategies (compaction, caching, retrieval) that keep long-context apps sane.

Why LLM apps are uniquely vulnerable to attacks delivered as plain text, the difference between direct and indirect injection, and the defences that actually help (plus the ones that don't).

What modern AI dev tools actually do, where they sit on a spectrum from inline completion to autonomous agents, and the workflow habits that separate developers who 2x their output from developers who ship subtly broken code.

OpenAI released CLIP. LAION and friends released OpenCLIP — a reproducible, openly-trained re-implementation that has quietly become the default vision-language embedding backbone. Here's what it is, why it won, and how to drop it into a project.

How diffusion-based video models turn a text prompt into a moving image, why consistency is so hard, and the practical patterns you need to know before generating anything longer than a few seconds.

What "multimodal" actually means once you get past marketing copy. How modern models like GPT-4o, Gemini, and Claude blend modalities, and the design trade-offs (early vs late fusion, native vs adapted) you'll meet when building with them.

How models like CLIP, GPT-4V, and Claude visual learn to talk about pictures. Cover the contrastive trick behind CLIP, the difference between embedding models and generative VLMs, and where each one shines.

What separates an agent from a plain chatbot, the perceive-think-act loop they all share, and how to design one that doesn't loop forever or burn through your token budget.