In spring 2026 I completed three courses from DeepLearning.AI. One is for business leaders. One is for people who build AI agents. One explains the architecture inside large language models. This page collects my notes from all three. Each section says what the course covers, what I took from it, and why it matters for AI governance work.
| Course | Instructors | Length | Level |
|---|---|---|---|
| AI for Everyone | Andrew Ng | About 7 hours | Beginner, no code |
| Agentic AI | Andrew Ng | About 10 hours | Intermediate, Python |
| How Transformer LLMs Work | Jay Alammar and Maarten Grootendorst | About 1 hour 45 minutes | Beginner |
AI for Everyone
AI for Everyone is a non-technical course by Andrew Ng. It needs no math or programming background. It has four modules:
- What is AI?
- Building AI Projects
- Building AI in Your Company
- AI and Society
The course gives a shared vocabulary for AI projects: what AI is, how a project runs, and how a company builds AI capability. Large language models and prompting are not part of this course. DeepLearning.AI teaches those topics in a separate course, Generative AI for Everyone.
For governance work, this vocabulary is the starting point. Every decision-maker needs it before signing an AI contract, deploying an AI system, or building an internal governance framework.
Certificate: Verify here
Agentic AI
Agentic AI is a hands-on course by Andrew Ng. It uses plain Python with no agent framework. It has five modules:
- Introduction to Agentic Workflows
- Reflection Design Pattern
- Tool use
- Practical Tips for Building Agentic AI
- Patterns for Highly Autonomous Agents
The most important mindset shift is that real-world agentic AI is not a single model that answers questions. You can use a single agent, but the real power comes from many agents. It is a network of agents, each with a defined role, working together toward a goal.
Some agents plan. Some execute. Some verify. Designing that orchestration layer separates someone who has used AI from someone who can deploy it.
Reflection: The Model Checks Its Own Work
Reflection is the ability of an agent to evaluate its own output, find gaps, and revise before it delivers a result. It was the most accessible pattern for me at the beginning. Reflection is not a prompt trick. It is an architectural decision. When you build reflection into an agentic loop, output quality improves without a human at every step.
For governance and compliance, reflection matters because AI systems can be designed with built-in self-evaluation loops. That changes how you audit and validate their outputs. I built this idea into a verification and validation agent.
Tool Use: The Model Reaches Outside Itself
A model on its own only knows what it was trained on. With tool use, the model calls external functions, APIs, and other systems in the middle of a response. Examples are a search engine, a calculator, a database, or a calendar. The course also covers how to design those tool interfaces, so that agents use them correctly and reliably.
This is what makes agentic AI actually agentic. The model decides when it needs more information, calls a tool to get it, and uses the result. I use this capability every day with Claude: web searches, calendar events, and document retrieval. I built it from scratch in my tool invocation agent.
Planning, Multi-Agent Work, and Evals
The last module covers planning and multi-agent collaboration. The course also teaches evaluations and error analysis, so that you can measure an agent and decide what to fix next. I built both patterns: a planning agent that sequences tasks, and three ways for AI agents to collaborate.
From a governance view, multi-agent systems add new risks. When agents delegate to sub-agents, the chain of accountability gets complex. Someone must still be able to say which agent made which decision, and why.
Certificate: Verify here
How Transformer LLMs Work
How Transformer LLMs Work is a short course by Jay Alammar and Maarten Grootendorst, the authors of Hands-On Large Language Models. It explains how a large language model reads input, processes it, and generates a response. The lessons cover:
- Language as a bag of words, then word embeddings
- Attention, which lets the model use the context around each word
- Tokenizers, which split text into tokens
- The transformer block and self-attention
- Recent improvements, such as the KV cache and grouped-query attention
- Mixture of Experts (MoE)
It gets technical fast: attention heads, embedding layers, and matrix operations. Without a math or machine learning background, you will not leave with an engineer’s understanding. That is not the point for most of us. The point is to understand enough to make better decisions about how these systems are designed, deployed, and governed.
Two parts of the course connect directly to my own work. Mixture of Experts explains why Qwen3 30B A3B runs fast on my laptop. Only about 3 billion of its 30 billion parameters work on each token. I measured that speed in my local AI setup on a gaming laptop.
The course also shows how a model writes: it predicts the next token, one token at a time. It predicts likely words, not checked facts. That is why a model can hallucinate, which means it gives a confident answer that is wrong. The confidence can mislead people and organizations that do not know the subject well. For anyone who advises on AI adoption or governance, this failure mode is foundational knowledge.
What the Three Courses Add Up To
Each course works at a different level. AI for Everyone gives the vocabulary that leaders need. Agentic AI gives the design patterns that builders use. How Transformer LLMs Work shows what happens inside the model. AI governance needs all three levels, because a policy only works when it matches how the system is actually built.
Keep reading: from course notes to builds
The builds behind these patterns: 50+ Agent Patterns & Builds
Local AI in practice: Running Local AI on a Gaming Laptop
Topic hub: AI Governance
All articles: NosisTech Writing