Token LabSearch

AI AGENTS · YOUTUBE

Learn AI agents on YouTube: a guided route through 10 creators

Compare representative videos, understand their scope, and turn watching into a tested project.

Sources & version details
In this article

Choose a learning route

Choose a learning route
Choose a learning route · Token Lab

1. Concepts

Jeff Su → IBM → Tina Huang. Learn to separate a model call, a fixed workflow and model-selected tool use. Then use Karpathy for the model foundation.

2. Python engineering

Tina Huang → Dave Ebbelaar → Cole Medin. Implement one bounded agent before considering a framework migration. Use Andrew Ng’s course outline to compare design patterns, not to justify adding agents by default.

3. Low-code workflows

Tina Huang → Nate Herk. Learn JSON and HTTP before complex integrations. A visual editor still needs explicit permissions, idempotency, error handling and ownership.

4. Business delivery

Liam Ottley → Dave Ebbelaar, with Google Cloud Tech for cloud context. Define the buyer’s problem and acceptance criteria before selecting tools. A demo is not a service-level commitment.

The video is free to view when available; models, hosting, APIs or associated courses may cost money. This page does not load a YouTube player or transmit exercise data. Opening a video leaves Token Lab and follows YouTube’s privacy rules. Subscriber counts and revenue promises are deliberately not used as quality evidence.

Six-stage curriculum: from model calls to a dependable service

These six lessons are Token Lab’s synthesis. They connect the videos to engineering concepts and a single read-only SRE project; they do not claim that every video covers every requirement. Read the explanation first, watch the selected material, and complete the practice section at the end.

1. Models, workflows and agents

Why this comes next and what you need first

Begin with the decision boundary: which next step is fixed by software, and which is selected by a model? You need to understand a function’s input and return value, not calculus. Jeff and IBM orient the vocabulary; Karpathy supplies model background. They serve different purposes and should not be treated as competing introductions.

Mechanism and design decisions

A model produces an output from context. A workflow connects steps using application rules. An agent adds a repeated observation–decision–action cycle, but the runtime still controls what may execute. A longer prompt does not create durable state, permissions or a stopping rule. Context changes at inference time are not weight updates.

The same SRE case, one stage deeper

Running example: an alert says that inference errors increased. A fixed workflow always reads metrics and recent deployments. An agent may choose a further read based on those results. Neither design should grant itself permission to restart production.

Suggested viewing order: Jeff Su → IBM Technology → Andrej Karpathy

Continue with the implementation chapter →

2. Tool contracts and the execution loop

Why this comes next and what you need first

Now learn JSON objects, required fields, types, HTTP status codes and exceptions. These are the boundary between generated text and executable software. Use Tina for component orientation and Dave for responsibility separation. Follow one tool call all the way through before adding more tools.

Mechanism and design decisions

A tool needs a name, purpose, argument schema and implementation. The model proposes a call; the executor validates the name, arguments and authority before running code. Append the result as untrusted evidence, then let the policy choose the next action. Limit steps and elapsed time. Schema-valid output can still be factually wrong or unauthorized.

The same SRE case, one stage deeper

For the SRE assistant, permit read_metrics and read_pods with server-bound scope. Do not expose a general shell or let the model supply arbitrary cluster URLs. Return evidence IDs so the final report can identify what was actually read.

Suggested viewing order: Tina Huang → Dave Ebbelaar / Datalumina

Continue with the implementation chapter →

3. Context, retrieval and memory

Why this comes next and what you need first

Before adding a vector database, understand the difference between the model’s current input, searchable knowledge and durable execution records. They solve different problems. Pair the videos with the RAG survey: a short agent demonstration cannot replace learning ingestion, retrieval quality and evidence sufficiency.

Mechanism and design decisions

Retrieval selects relevant source material; working context holds the current task; an execution store records progress and results. A memory entry must have scope, provenance and a freshness rule. Summarization reduces input size but may discard a constraint. Retrieved instructions remain data; a document cannot authorize a tool.

The same SRE case, one stage deeper

An old runbook may describe a previous deployment. Keep its version beside its text and compare it with the current service version. If they disagree, the assistant should report the mismatch rather than silently treating the runbook as current truth.

Suggested viewing order: Andrej Karpathy → Dave Ebbelaar / Datalumina → Nate Herk

Continue with the implementation chapter →

4. State graphs, planning and human approval

Why this comes next and what you need first

A graph is useful when branches and recovery points matter. Learn states and transitions first: what may run next, what data must exist, and what ends the run? Cole provides the graph-oriented reading; Andrew Ng’s course introduction gives pattern vocabulary, but is not the complete lesson.

Mechanism and design decisions

Planning proposes a sequence; orchestration enforces transitions. Reflection proposes a revision; evaluation checks whether it helped. Multiple agents split responsibilities or context, but also add coordination and failure modes. Approval should bind to the exact proposed action and its inputs; changed parameters require a new decision.

The same SRE case, one stage deeper

Use collect → assess → report, with an insufficient-evidence branch back to collection and a hard iteration cap. A restart proposal goes to review, not directly to a cluster tool. The shipped SRE tutorial remains read-only; an approval executor is a separate extension.

Suggested viewing order: Cole Medin → Andrew Ng / DeepLearning.AI → Nate Herk

Continue with the implementation chapter →

5. Reliability, security and evaluation

Why this comes next and what you need first

Move from “it answered once” to repeatable behavior. Understand timeout, retry, idempotency and least privilege before exposing tools to real users. Video demonstrations are examples, not measurements of reliability. Use the security and evaluation surveys to fill the gaps.

Mechanism and design decisions

A timeout does not prove an external action failed: the server may have committed it before the response was lost. Blind retries can duplicate side effects. Store request identity and outcomes. For quality, distinguish completing the protocol, citing a source and making a supported claim; these are three different properties.

The same SRE case, one stage deeper

For incident diagnosis, a report can cite a real Pending Pod and still falsely claim it caused all request errors. Preserve “root cause not established” when causality is unproven. Retrying the same incident should return the stored report, not imply fresh observation.

Suggested viewing order: Dave Ebbelaar / Datalumina → Nate Herk → IBM Technology

Continue with the implementation chapter →

6. Deployment, cost and customer ownership

Why this comes next and what you need first

Only after the loop is understandable should you decide where it runs. Learn containers, secrets, service identity, persistent storage and network boundaries. Google’s short interview offers orientation, Liam addresses commercialization, and neither replaces a deployment runbook.

Mechanism and design decisions

A private service, a process-health probe and a persistent volume solve different problems; none proves answer quality. Budget model calls, retrieval, retries and human review separately. Assign a maintainer, define data retention and document rollback. A billable automation needs an acceptance agreement and a way to handle exceptions.

The same SRE case, one stage deeper

Deliver the read-only SRE assistant with an incident schema, image version, configuration, sample request, expected report and recovery notes. Explicitly list missing live collectors and authentication. A localhost demonstration is a teaching milestone, not evidence of production readiness.

Suggested viewing order: Google Cloud Tech → Liam Ottley → Dave Ebbelaar / Datalumina

Continue with the implementation chapter →

Representative videos and scope

01 · Jeff Su

AI Agents, Clearly Explained

A concise introduction to the progression from a standalone LLM to a predefined workflow and a tool-using agent. Start here to distinguish these categories before choosing software.

English audio; check captions on YouTube.

Watch on YouTube ↗https://www.youtube.com/watch?v=FwOTs4UxQS4
02 · Andrej Karpathy

Deep Dive into LLMs like ChatGPT

A general-audience explanation of the model underneath a chat assistant. Use it for LLM foundations, not as an agent-deployment course; the author separately offers a technical Zero to Hero track.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=7xTGNNLPyMI
03 · Tina Huang

Building AI Agents In 44 Minutes

The published chapters move from definitions and components to workflows, prompting, n8n demonstrations and an Agents SDK financial-research example. A useful bridge from vocabulary to implementations.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=_Udb5NC6vTI
Selected chapter links
04 · Dave Ebbelaar / Datalumina

How to Build Reliable AI Agents (without the hype)

Organizes reliability around intelligence, memory, tools, validation, control, recovery and feedback. The accompanying engineering article argues for explicit workflows and selective model calls rather than giving an LLM the entire process.

English audio; check captions on YouTube.

Watch on YouTube ↗https://www.youtube.com/watch?v=T1Lowy1mnEg
Selected chapter links
05 · IBM Technology

What are AI Agents?

Maya Murad explains the move from a single model to compound AI systems using databases and external tools. Useful for seeing the agent as part of a larger system.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=F8NKVhkZZWI
06 · Google Cloud Tech

AI Agents: From concept to code

A short discussion of what agents are, how developers build them and coding considerations. This is an orientation interview, not an end-to-end Vertex AI deployment lab.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=8Yx0HW0bA_o
07 · Cole Medin

THE BEST Tool for AI Agent Workflows - LangGraph FULL Guide

The creator’s companion notes describe state, nodes and conditional edges, with branching and agent–tool loops. Read the older examples for architecture; verify current library APIs separately.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=w_HeP0A2MF8
08 · Liam Ottley

How to Build & Sell AI Agents: Ultimate Beginner’s Guide

The course description divides the material into foundations, building use cases and commercialization. Best treated as a business-delivery track rather than proof of achievable revenue.

English audio; check captions on YouTube.

Watch on YouTube ↗https://www.youtube.com/watch?v=w0H1-b044KY
09 · Andrew Ng / DeepLearning.AI

Learn to build effective Agentic AI systems with Andrew Ng

This video introduces the Agentic AI course, not the complete course. It presents reflection, tool use, planning and multi-agent workflows, with evaluation and Python implementation as course goals.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=w7vqXL4PWEE
10 · Nate Herk

Build & Sell n8n AI Agents (8+ Hour Course, No Code)

The chapter list covers n8n and JSON, APIs, agent construction, parsing, human review, error workflows, webhooks and self-hosting. Select one project rather than copying every integration at once.

English audio; check captions on YouTube. Original video date:

Watch on YouTube ↗https://www.youtube.com/watch?v=Ey18PDiaAYI
Selected chapter links

Practice and verification — Token Lab exercises

Jeff Su

Draw three versions of support triage: one model call, fixed routing, and a bounded tool loop. Mark exactly who chooses the next step. Prefer the simplest version that meets the requirement.

Andrej Karpathy

Explain why conversation context is different from updating model weights. In Token Lab, inspect tokenization and implement the small language-model project before assuming an agent has learned from a tool result.

Tina Huang

Rebuild only one read-only example. Write the input schema, allowed tools, stopping rule and evidence required for the answer before adding a second use case. Treat financial examples as software exercises, not investment advice.

Dave Ebbelaar / Datalumina

Map these seven responsibilities to the SRE project files. Identify which failures can be retried, which must stop, and why a repeated request must not duplicate an external action.

IBM Technology

Draw the model, data store, tool executor and user separately. Add trust boundaries: retrieved text is data, not permission to execute. Explain which component enforces access.

Google Cloud Tech

Before choosing a cloud runtime, specify identity, model access, tool credentials, network egress and observability. Separate portable agent logic from provider-specific deployment configuration.

Cole Medin

Implement a three-state graph: collect evidence, assess sufficiency, answer or stop. Add an explicit iteration limit and test restarting after a tool result is stored but before the next model call.

Liam Ottley

Write a one-page pilot proposal: buyer, existing process, measurable baseline, acceptance threshold, data permissions, maintenance owner and rollback. Estimate total delivery cost, not just token cost.

Andrew Ng / DeepLearning.AI

Use one fixed task set to compare direct generation with one bounded revision step. Measure correctness, latency and calls. Reflection is a hypothesis to test, not automatic improvement; additional agents also need evidence.

Nate Herk

Build a draft-only support workflow with an approval gate. Send the same webhook twice, remove a credential and force a timeout. The workflow should record failure and avoid duplicate sends; use mock tools until verified.

Finish with one read-only SRE incident assistant. Its output must separate observed facts, hypotheses, missing evidence and proposed actions. Use the same saved incidents for a deterministic baseline and a model-driven policy. Record task success, unsupported causal claims, tool failures, latency and calls; include stale evidence, duplicated requests, missing permissions and tool-output injection. Grade 1: terminology only; 2: happy-path reproduction; 3: reproducible failures and boundaries; 4: fair comparison with costs; 5: defensible design, recovery and transfer to a new incident. These are original practice criteria, not company interview questions.

Continue with the complete SRE Agent tutorial →

Explore language-model fundamentals →

Original resources and further reading

Keep other videos in the learning library