AI Systems Engineer — architecture and design

• Difference between an agent and a standard language model request: observation, planning, action, and result validation
• Core components of an agentic system: language model, tools, memory, planner, and stopping rules
• Agent execution cycles: ReAct, Plan-and-Execute, and Chain of Thought
• Architectural patterns: single agent, router, pipeline, supervisor, and multi-agent systems
• Common limitations: hallucinations, context overflow, and looping
• Ecosystem overview: Cloudflare Project Think, OpenAI Agents SDK, Google ADK, and Maestro
• Practice: Build a first agent using Workers AI and create a C4 Context Diagram and Architecture Decision Record (ADR) for the selected project.

• Agent class architecture: constructor, run() method, tool registry, and conversation history
• Manual implementation of tool calling: JSON parsing, selection, and execution
• Context management: sliding window, short summaries, and step limitations
• Streaming responses through Server-Sent Events (SSE)
• Error handling: timeouts, retries, and graceful interruption
• JSON Schema for tool input validation
• Practice: Build a basic Agent class in JavaScript with streaming responses and tool integration.

• V8 Isolates runtime: limitations, memory consumption, and execution time
• Service bindings: Workers AI, KV, D1, Vectorize, Queues, and Durable Objects
• Service Bindings for direct communication between Workers
• Queues for asynchronous tasks with retries
• Durable Objects for state storage and coordination
• Local development and testing using Wrangler and Miniflare
• Practice: Build a project with multiple Workers, configure service bindings, and implement interaction through Service Bindings.

• Agents SDK: Agent, AgentContext, tools, routing, and built-in state management
• Project Think: resilient execution, recovery after failure, and checkpoints
• Saving progress of long-running tasks and resuming execution after interruption
• Persistent Sessions: preserving user context between interactions
• Sub-agents as a way to separate responsibilities between specialized agents
• Comparing SDK-based and manual implementations and choosing the right approach
• Practice: Migrate an agent to Cloudflare Agents SDK and implement resilient execution with checkpoints.

• Short-term memory: active dialogue context and history size management
• Long-term semantic memory: similarity search and semantic retrieval
• Episodic memory: storing history, actions, and sessions
• Working memory: task state storage and agent coordination
• History compression strategies: summaries and filtering important messages
• Memory quality control: outdated entries and unreliable context
• Practice: Configure semantic memory using Vectorize, working state in Durable Objects, and session history in KV.

• Graph theory
• Types of relationships
• Maltego and transforms
• Gephi for analysis
• Automated graph data collection
• Financial networks and corporate structures
• Practice: Build and visualize a corporate relationship map.

• Tool architecture: JSON Schema, selection, execution, and result handling
• Model Context Protocol (MCP): tool descriptions and capability discovery
• AI Gateway: request routing, caching, and fallback models
• Input validation and tool permission restrictions
• Working with external APIs: timeouts, retries, and error handling
• Tool call auditing and execution trace storage
• Practice: Build a secure toolset, configure AI Gateway, and publish selected tools through MCP.

• Orchestrator: task decomposition and dependency graphs
• Supervisor pattern: a central agent plans and aggregates results
• Pipeline pattern: sequential processing across agents
• Swarm pattern: multiple agents propose solutions while an aggregator selects the best one
• Communication through Queues and Service Bindings
• Result evaluation: confidence scoring and conflict resolution between responses
• Practice: Implement an orchestrator and multiple specialized agents with parallel and sequential task execution.

• LangGraph: state graphs, nodes, edges, and checkpoints
• AutoGen: collaborative agent interaction and round control
• CrewAI: roles, tasks, and execution workflows
• Comparing frameworks with Cloudflare Workers implementation
• Framework selection criteria for specific projects
• Practice: Build identical scenarios in LangGraph, AutoGen, and CrewAI and compare them with a Cloudflare Workers implementation.

• Sources of unreliability: tool failures, infinite loops, and context overflow
• Circuit Breaker for tools: state management through KV
• Retry strategies with exponential backoff
• Fallback model through AI Gateway when the primary model is unavailable
• Human-in-the-loop: pause at checkpoints and confirmation handling
• Tool idempotency and partial results as valid responses
• Practice: Add Circuit Breaker, fallback models, and user approval checkpoints.

• Key risks: attacks through user input and knowledge base documents
• Input and output protection through middleware
• Tool permission restrictions: least-privilege access and allowlists
• Action auditing: immutable logs of tool calls and results
• Resilience testing against common attack scenarios
• Practice: Add input/output protection, restrict tool permissions, and test the agent against common attacks.

• Observability through AI Gateway: tokens, latency, errors, and cost tracking
• Structured logging of agent execution steps
• Evaluating language model responses against defined criteria
• Evaluation datasets: test prompts and reference answers for regression testing
• Comparing agent versions by quality, speed, and cost
• Practice: Configure metrics collection, create evaluation tests, and automatically compare agent versions.

• Agent versioning: prompts as code and prompt registries
• CI/CD pipeline: code validation, quality testing, and automated deployment
• Quality gates: blocking deployment when metrics degrade
• Progressive rollout: limited traffic allocation for new versions
• Cost optimization: model routing, caching, and reasoning-depth control
• Practice: Build a CI/CD pipeline with quality checks, progressive deployment, and cost optimization.

• C4 Model for agentic systems: Context, Container, Component, and Code
• Production readiness checklist: observability, auditing, resilience, and security
• Final Architecture Decision Record (ADR): key decisions and trade-offs
• Cost estimation: models, storage, queues, and expected workload
• Practice: Deploy a complete system — orchestrator and multiple specialized agents — with a delivery pipeline, C4 documentation, and a production readiness checklist.

Yes, we cooperate with various government support programs through which different categories of applicants may receive funding for education, including not only unemployed individuals but also employed residents of Estonia.

Submit an application to find out which government support programs may be available in your case.

Development experience and a basic understanding of how web applications work are recommended. Familiarity with language models is a plus, but not required — the course starts with the architectural foundations of agentic systems.

Most lab assignments are completed using Cloudflare Workers AI, which provides a free tier for developers. Some additional costs for premium models may apply during comparative exercises — requirements will be clarified before the course starts.

The course teaches engineering discipline — architecture, reliability, security, and production readiness — rather than focusing on a single framework. Students explore multiple approaches (Cloudflare Agents SDK, LangGraph, AutoGen, CrewAI) and learn how to choose the right tool intentionally.

The schedule is flexible — classes take place 2–3 times per week, and course materials remain available to you permanently. Even if you miss a class, instructors will help you catch up with the material.

You will receive an international-format certificate from the MYEDU training center, as well as a certificate from the S.E. School of Systems Analysis confirming your qualification. This document is valued by employers in the IT industry.