AI Foundations for Technical Professionals

Artificial Intelligence (AI) has moved from a chat window into your terminal, your integrated development environment (IDE), and your ticket queue. It’s now part of the systems you build and run, so treating it as a black box no longer works. You need to know why a model gives a different answer to the same prompt, why it confidently makes things up, what a million tokens really costs, and what an agent is allowed to touch when it runs on its own.

This course gives you that understanding without requiring you to read research papers. You'll start with the modern AI stack and how it has evolved, and then look inside the model at parameters, tokens, context windows, sampling, and hallucinations. From there, you'll learn to choose and run models by weighing performance against cost and latency, and you'll run one model on your own machine. You'll go from prompt engineering to context engineering, and you'll see how retrieval-augmented generation (RAG) works from start to finish and when to choose it over fine-tuning or a longer context window.

The second half covers agentic AI. You'll learn the loop that makes an agent an agent, how tool calling lets models act in the real world, and why the harness around the model matters as much as the model itself. You'll see subagents, orchestrators, and human-in-the-loop guardrails, and then you’ll watch an agent work through a ticket end to end. You'll also learn how the Model Context Protocol (MCP) fixes the N×M integration problem, connect an MCP server yourself, and compare orchestration frameworks like LangChain, LangGraph, and CrewAI. The course closes with the security risks that matter most, such as prompt injection and over-privileged agents, and the identity, runtime, and observability controls that keep AI systems in check.

This course doesn't teach you to train models or derive the math behind them. That's built for technical professionals who need to understand, evaluate, build with, and secure AI systems at work.

What you'll learn

• How LLMs work: parameters, weights, training vs inference, LLMs vs SLMs, and open vs closed weights
• How tokens, context windows, and temperature shape every response, and why hallucinations never fully go away
• How to choose a model by trading off performance, cost, and latency, and when to self-host instead of calling an API
• Prompt techniques that hold up in production (system prompts, few-shot, chain-of-thought) and the shift to context engineering
• How embeddings, vector search, and the RAG pipeline work, and when to use RAG, fine-tuning, or long context
• What makes an agent: the loop, tool calling, the harness, multi-agent systems, and human-in-the-loop checkpoints
• How MCP hosts, clients and servers fit together, and where frameworks and skills fit in automation
• How to defend AI systems against prompt injection and over-privileged agents with least privilege, identity, and observability

Hands-on demos

• Running a local model on your own machine
• Watching an agent work a ticket end to end
• Connecting an MCP server

Who this course is for

• Software engineers, DevOps, SRE, platform, and cloud engineers bringing AI into their work
• IT and security professionals who need to evaluate and govern AI tools
• Technical leads and architects making build-vs-buy and model-selection decisions
• Anyone in tech who uses AI daily and wants to understand what's underneath

Prerequisites

• General comfort with software and technical concepts
• No machine learning, data science, or math background required