The AI Edge

Agents, Ontologies and the Path to Trusted AI

Curriculum: - See Lesssons in Pulldown Menu

1

Agentic Plumbing - Command Line/Linux/Environments/Github
- Command Line Mastery
- LLMs : Frontier and Local Models
- Linux Essentials
- Virtual Environments
- Git and Github
2

Foundational Material as Context for the Course
- From Neurons to Neural Networks - A Short History of AI
- Embeddings - the secret sauce behind what makes an AI tick (or think?)
- RAG and GraphRAG
- Ontologies as Guardrails for Agents
3

Agentic AI - Navigating the World of Agents
- Prompt and Context Engineering
- Context Window Management
- The KV-Cache -- the secret to keeping your token costs under control
- Agent Basics: Tools, Loops and Agency
- A Simple Agentic Loop
- Workflows and Agentic Frameworks
- Tools, Context and Memory - the foundation of all agentic systems
- MCP - The Model Context Protocol
- AI Guardrails and Ontologies
- The AI Safety Trifecta
- Agent Measurement and Evaluation
- CCA Exam Overview
4

Ontologies Explained - How to leverage knowledge graphs for your agentic apps
- Ontologies - Introduction
- Ontologies: Inference with RDFS
- Ontologies: Inference with OWL
- SPARQL - the Query Langauge
- SHACL - the Shapes Contraint Language
- SWRL - Semantic Web Rule Language
5

MAKE Exercises
- MAKE_01 Measurement
- MAKE 02 - Testing prompts
- MAKE 03 - Chain-of-Thought : Locking you up or freeing you ?
- MAKE 04 - Finding needles in haystacks
- MAKE 05 - Structured Extraction
- MAKE 06 - Model comparison - cost and speed
- MAKE 07 - Parallel vs. Sequenial Sub-Agent Architectures
- MAKE 08 - Cache Strategy Implementation

Get the AI Edge

Five layers, each answering a different question:

Agentic Plumbing — can I run it? Command line, Linux, virtual environments, Git and GitHub, and choosing between frontier APIs and models on your own hardware. The ground every agent stands on, and where most people quietly get stuck.

Foundations — why does it work? From Cajal's neurons to transformers. How embeddings turn meaning into geometry, how RAG grounds a model in your documents, and why "nearest" is not the same as "correct."

Agentic AI — how do I build it? Twelve lessons on the working parts of a real agent: prompt and context engineering, context windows, the KV-cache and prompt caching, tool loops, workflows versus autonomous agents, memory and MCP. Then the part most courses skip — guardrails, the AI safety trifecta, and how to evaluate what your agent actually does.

Ontologies — how do I keep it right? Agents fail in a particular way: fluently, plausibly, wrong. Model your domain in RDF, RDFS and OWL, query it with SPARQL, and write SHACL shapes that check an action before it happens. The same standards behind SNOMED CT and FIBO.

MAKE Labs — can I prove it? Eight hands-on exercises where you measure instead of guess: prompt testing, chain-of-thought, long-context recall, structured extraction, model cost and speed, sub-agent architectures, cache strategy. Each one ends as a GitHub artifact you can show.

Go in order, or jump in. Every lesson stands on its own. At home in the terminal? Start at Agentic AI. Agent works but you can't trust it? Go straight to Ontologies. The sequence follows the five domains of Anthropic's Claude Certified Architect exam, so it lines up with that credential — but the goal is the skill, not the badge.

Taught by Dr. Frank Coyle ("drC") — 32 years teaching CS at SMU, now teaching generative AI at UC Berkeley and the University of Bologna.

if not satisfied for any reason, request refund with 30 days - drc@codesupreme.ai

IntroPlan

$345