AI curriculum
Course outline for Agent Platforms and Frameworks
Learn the common building blocks of agent frameworks, then implement one small task in each major framework through a dedicated module. Work with OpenAI Agents SDK, Microsoft Agent Framework, Google ADK, LangChain, LangGraph, and n8n. Compare real tool use, state, execution flow, inspection, and failure behavior before choosing a framework or simpler custom controller.
Agent Platforms and Frameworks Course Objectives
- Explain shared model, tool, state, orchestration, and runtime responsibilities.
- Build and run a small tool-using example in each required framework.
- Identify framework-specific setup, model access, state, and execution semantics.
- Inspect actual outputs, events/traces, and a handled failure in each implementation.
- Compare implementations using the same task contract and independent checks.
- Explain portability, dependencies, license/hosting costs, and application-owned safeguards.
- Justify a framework choice against a working custom-controller baseline.
Pre-requisites
- Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.
- Basic Python, functions, JSON, API calls, environment variables, and tests.
- Modify and run a small supplied project; no prior mastery of every framework is required.
- Agent Architecture and Orchestration helps with orchestration patterns but its full course is not mandatory.
- The course introduces visual workflow authoring and explicit graph primitives.
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
Readiness checks
- Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.
- Basic Python, functions, JSON, API calls, environment variables, and tests.
- Modify and run a small supplied project; no prior mastery of every framework is required.
- Agent Architecture and Orchestration helps with orchestration patterns but its full course is not mandatory.
- The course introduces visual workflow authoring and explicit graph primitives.
Building Applications with LLMs and Agentic AI Foundations or equivalent model/tool application and agent-loop competence.
Find your place in the learning mapLab Setup
Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
Preflight separate stable Python environments for OpenAI Agents SDK, Microsoft Agent Framework, Google ADK, LangChain, and LangGraph, plus an isolated stable n8n instance. Provide credentials and model endpoints supported by each actual implementation; do not assume all can share one account or identical model APIs. Supply tiny starter projects, local lookup service, tests, and inspection tools. No production workflows or broad cloud administration are required.
Verify framework/package/node releases, language-specific support, invocation, state, and failure paths before delivery. Required preview-only features are blockers or explicit scope decisions, not substitutes for stable implementation. Local trace/event inspection is sufficient; paid observability subscriptions are not required. Credentials, quotas, costs, data handling, and license conditions must be checked for all six tracks.
Detailed Course Outline
Module 1: Common concepts before framework APIs (2 hours)
- Stack responsibilities: Model API, agent SDK, harness, orchestration runtime, and hosted platform.
- Model actions and effects: Instructions, messages, typed tools, model-selected actions, and actual effects.
- State and checkpoints: Conversation state, durable memory, task records, and checkpoints.
- Execution patterns: Sequential, conditional, parallel, and iterative execution with stop conditions.
- Checks and authority: Observation, validation, failure handling, credentials, and application authority.
- Shared task baseline: Shared task contract, local lookup service, and custom-controller baseline.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run the baseline and identify which responsibilities every framework implementation must provide.
Module 2: OpenAI Agents SDK and agent APIs (2 hours)
- Agents SDK setup: Stable Python SDK setup, credentials, model configuration, and first run.
- Responses API and managed loop: Responses API exchanges versus the Agents SDK's managed execution loop.
- Agents SDK primitives: Agent, Runner, typed function tools, results, and structured output.
- Sessions and delegation: Sessions/context, handoffs or agents-as-tools, and bounded execution.
- Events and failures: Events/tracing, tool failure, application checks, and independent result verification.
- SDK implementation: Implement the shared task and save its runnable code and observations.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run an SDK agent with an actual tool and diagnose a failed lookup through inspected evidence.
Module 3: Microsoft Agent Framework (2 hours)
- Agent Framework setup: Current AutoGen/Semantic Kernel successor and stable Python setup.
- Agent Framework primitives: Model client, agent, tools, messages, sessions, and actual execution.
- Branch or handoff: Workflow/control abstractions and one small supported branch or handoff.
- State ownership: State/context ownership, persistence options, and application responsibilities.
- Middleware and limits: Events, middleware, error handling, limits, and result inspection.
- Current-framework implementation: Implement the shared task without mixing legacy AutoGen APIs.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run a tool-backed Agent Framework task and explain its state and failure behavior.
Module 4: Google Agent Development Kit (2 hours)
- ADK setup: Stable Python ADK setup, credentials, model selection, and first run.
- ADK primitives: Agent, tools, Runner, session service, state, and events.
- Workflow and delegation: Sequential/parallel workflow or delegation primitives and chosen task flow.
- Sessions and memory: Session versus memory services and explicit artifact responsibilities.
- Callbacks and failures: Tool errors, callbacks/inspection, execution limits, and independent checks.
- ADK implementation: Implement the shared task and record supported versus unavailable features.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run an ADK tool-backed task and inspect its session events and a handled failure.
Module 5: LangChain (2 hours)
- LangChain setup: Stable packages, provider integration, create_agent, and first run.
- Tool interaction: Instructions, messages, typed tools, invocation, and tool-result feedback.
- Agent state and memory: Agent state, short-term memory/checkpointer, and explicit stored facts.
- Agent middleware: Middleware for context, bounded calls, human intervention, or error handling.
- Events and checks: Streamed events/local inspection and independent result checks.
- LangChain implementation: Implement the shared task, extending Agentic AI Foundations foundations rather than repeating its whole course.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run and modify the LangChain implementation and check its real tool and failure results.
Module 6: LangGraph (2 hours)
- LangGraph setup: Stable setup and the distinction from higher-level LangChain agents.
- State and compilation: State schema, nodes, edges, compilation, invocation, and returned state.
- Transitions and cycles: Conditional transitions, cycles, termination, and graph execution limits.
- Checkpoint and resume: Checkpoint/thread identity, interruption, and one prepared resume example.
- Events and effects: State/event inspection, tool failures, and application-owned side-effect checks.
- Graph implementation: Implement the shared task through a small explicit graph.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run a learner-modified graph, inspect a branch, and resume the prepared interrupted path.
Module 7: n8n (2 hours)
- n8n setup: Stable isolated instance, editor, credentials, and first workflow execution.
- Nodes and connections: Triggers, nodes, expressions, data mapping, and actual model/tool connections.
- Conditions and persistence: Conditions, bounded workflow flow, and state/data persistence choices.
- Error routing: Error routing, execution history, outputs, and independent checks.
- Workflow export: Workflow export/re-import and keeping credential values outside artifacts.
- Visual-workflow implementation: Implement the shared task and distinguish workflow automation from agent-selected behavior.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Run and export a workflow with observed successful and failed lookup paths.
Module 8: Compare implementations and choose deliberately (2 hours)
- Shared acceptance contract: Same input data, task contract, tool behavior, and acceptance checks.
- Adverse cases: Invalid input, tool timeout/failure, repeated task identity, and final-state checks.
- Safeguards and guarantees: Application safeguards versus actual framework guarantees and missing features.
- Portability and diagnosis: State formats, model/provider portability, tracing, debugging, and review effort.
- Operating costs: Dependencies, licenses, hosting, credentials, data paths, and operating costs.
- Framework selection: Framework choice, migration limits, and the simpler custom-controller alternative.
- Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.
Practical outcome: Produce an evidence-based selection record from executed implementations and shared checks.
Practical exercise
- Use the same weather-based planning report across the course. A controlled lookup service supplies units, timestamps, and factual readings; a real model interprets or drafts the report. Define the permitted outputs, required facts, uncertainty handling, and completion checks before selecting a framework.
- Each framework has its own prepared project and a small learner-authored extension: register a tool, add a validation rule, or implement a failure branch. Run the actual framework with authorized inference, inspect its tool result and runtime evidence, and test an unavailable or invalid lookup. Save runnable code or a workflow export and observations for every framework. The baseline and service adapters are supplied; learners do not port six large applications from scratch. Native state/control features differ and must be explained rather than hidden behind one generic wrapper.
- Run the shared comparison cases against all implementations. Report where duplicate prevention, timeout handling, or durable state needs application code. Observe one prepared LangGraph interruption/resume and n8n export/re-import. Record evidence, versions, coupling, and review effort. Different correct report wording can pass; unsupported facts and broken state constraints cannot.
Delivery and timing
- Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.
What you will produce
Implement one small task in six frameworks and compare each with a working custom baseline.
How the work is checked
- Every required framework executes a learner-modified model/tool task.
- Each module records actual success, one failure, and independent output checks.
- The learner explains framework-specific state and execution ownership.
- OpenAI API calls, Agents SDK orchestration, and hosted services are not conflated.
- Microsoft examples use Agent Framework rather than mislabeled legacy AutoGen code.
- LangChain's agent loop and LangGraph's explicit graph controls are distinguished.
- A runnable n8n export excludes secret values and reproduces the task.
- Shared tests expose missing safeguards as well as successful outcomes.
- The final choice accounts for portability, maintenance, costs, and the custom baseline.
16 guided hours. Common concepts and a custom baseline precede six separate two-hour tracks: OpenAI Agents SDK, Microsoft Agent Framework, Google ADK, LangChain, LangGraph, and n8n. Each track requires actual success and handled-failure execution using prepared adapters and isolated environments. Comparison does not imply interchangeable APIs or equal behavior. Stable support and learner timing must be checked before delivery.
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
Contact us for full course details, including duration, delivery options and lab requirements.
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 goalsRelated Courses
These courses list this course as preparation.