AI curriculum

Course outline for Agent Platforms and Frameworks

A framework can simplify tool and state handling while adding dependencies and hiding important failure behavior. Compare version-labeled platform examples and inspect the same bounded task through a framework and a custom controller. Choose from tested contract, recovery, portability, and review requirements rather than a feature list alone.

Technology: Agentic Systems
Duration: 4 hours
Modules: 2 · 2 hours each
Level: Level 4

About Agent Platforms and Frameworks

Agent Platforms and Frameworks Course Objectives

Map named platform abstractions to planner, executor, state, and supervision responsibilities.
Inspect supplied typed tool and model-result exchanges.
Compare the same task contract in a framework adapter and a custom controller.
Test timeout and duplicate-result behavior independently of completion claims.
Record dependencies, portability limits, operating effort, and review needs.
Justify a framework or simpler custom orchestration choice using the evidence.

Pre-requisites

Building Applications with LLMs and Agentic AI Foundations, or equivalent tool-backed application and agent-loop competence.
Basic programming and API integration experience.
Familiarity with agent loops and workflow state; deeper orchestration and recovery study is helpful but not required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Can build tool-backed applications and explain agent loops; orchestration and failure handling help compare framework abstractions.

Find your place in the learning map

Lab Setup

Computer with a code editor, prepared programming runtime, and test runner.
Supplied version-labeled framework examples, a small local adapter/controller scaffold, mocked model/tool results, and failure traces.
All named platforms receive guided comparison; hands-on work uses one prepared framework adapter plus custom orchestration, not every platform. No paid API or hosted workflow account is required.

Detailed Course Outline

Module 1: Map platform abstractions to responsibilities (2 hours)

OpenAI Agents SDK: Supplied SDK examples for tools, model calls, and supervision; map orchestration responsibilities and record version-dependent behavior needing verification.
OpenAI agent APIs: Service-side model requests and tool-result exchanges in supplied examples; distinguish hosted API responsibilities from application orchestration and durable state management.
Microsoft Agent Framework: Version-labeled orchestration examples, tool interfaces, and state responsibilities; compare documented abstractions without assuming equivalent coverage or live compatibility.
Google ADK: Supplied agent-development examples and execution responsibilities; compare tools, supervision, and state assumptions without promising a separate platform implementation.

Practical outcome: Compare verified-version or supplied platform examples for tools, model calls, typed state, supervision, and checkpoints, distinguishing an API service from an orchestration SDK and recording unsupported assumptions.

Module 2: Compare execution and portability (2 hours)

LangChain / LangGraph: Messages, provider wrappers, typed tools, and graph state; compare cyclic and acyclic execution using the supplied weather-task adapter.
n8n: Supplied workflow artifacts, execution steps, and integration boundaries; compare automation responsibilities with the same task contract rather than assuming agent equivalence.
Framework comparison: Shared fixtures, final-state checks, timeout handling, and duplicate results; compare review effort, dependencies, and portability under identical task criteria.
Framework vs custom orchestration: Adapter convenience versus explicit controller logic; compare validation, recovery, and coupling, identifying when simpler custom execution meets the contract.

Practical outcome: Inspect a supplied LangChain/LangGraph adapter and a custom controller for the same task, recognize cyclic as well as acyclic flows, compare n8n workflow artifacts, and measure validation, failure handling, review effort, and dependency coupling.

Practical exercise

Produce a same-task contract, two adapter/controller artifacts or annotated traces, and a framework-selection record.
Accept a valid tool-backed result; reject malformed state and handle a supplied timeout or duplicate completion according to the same contract in both approaches.
Run at least six shared fixtures through prepared local adapters or trace validators and compare final results, accepted-effect counts, and recovery outcomes.
Record dependencies, version assumptions, review effort, and portability limits; explain when custom orchestration is simpler and why a graph diagram alone does not establish reliability.

What you will produce

Select a framework or custom controller by comparing the same bounded task's contract, failure behavior, dependencies, and review effort.

How the work is checked

The comparison maps each platform example to explicit execution responsibilities.
Both approaches use the same task contract and shared fixtures.
Timeout, duplicate, and malformed-state cases are checked against actual recorded outcomes.
The selection accounts for portability and operating effort and does not assume all graph workflows are acyclic.

Four hours using a supplied weather lookup/validation/report task in one LangChain/LangGraph adapter and a custom controller. Inspect concrete messages, typed tool inputs, and state transitions, then extend one validation or failure-handling rule and run shared fixtures within module time. Other named platforms receive guided version-labeled comparison, not equal hands-on coverage. Trace validation does not establish live SDK compatibility or production reliability.

When another approach is better

Use a small custom controller when the task has few stable stages and framework dependencies add more complexity than useful capability.
Do not select a platform from feature names alone when state, failure handling, portability, and current version support remain untested.

How we train

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals