A successful agent demonstration is not the same as a dependable service. Production agents must operate across unreliable models, tools, data sources and networks while preserving permissions, state and accountability. They need to recover from failure, ask for help at the right moment and provide evidence that work was completed correctly.
This course teaches the architecture and engineering practices behind production-grade agents. Participants will learn to decide where autonomy adds value, design bounded tool interfaces, manage long-running work and combine probabilistic reasoning with deterministic controls.
The approach is deliberately framework-neutral. Labs may use current agent libraries, but the design principles apply across cloud platforms, open-source frameworks and custom implementations.
Learning Outcomes
Upon completion of this course, participants will be able to:
- Distinguish agents from deterministic workflows and choose appropriately
- Design an agent around clear goals, tools, state and operational boundaries
- Create tool interfaces that are safe, observable and easy for models to use
- Implement durable execution, retries, timeouts and idempotent actions
- Manage working context, persistent memory and task state
- Introduce human approval and escalation at risk-based control points
- Test multi-step behaviour and failure recovery systematically
- Design a deployment architecture for a production agent service
Course Outline
Choosing an Agentic Architecture
- Definitions of assistants, workflows and autonomous agents
- Identifying tasks that benefit from dynamic planning and tool selection
- Recognising when deterministic automation is safer and simpler
- Defining goals, success criteria and prohibited outcomes
- Setting autonomy levels according to business risk
- Mapping human ownership and accountability
Core Agent Components
- Model, instructions, tools, state, memory and orchestration
- The perceive-plan-act-observe loop in practical systems
- Structured outputs and machine-readable decisions
- Single-agent, supervisor and specialist-agent patterns
- Keeping architecture as simple as the use case allows
- Avoiding unnecessary multi-agent complexity
Designing Tools for Reliable Use
- Small, explicit tool contracts and validated schemas
- Separating read, propose and execute capabilities
- Returning useful errors and actionable observations
- Idempotency keys and protection against duplicate actions
- Timeouts, rate limits and downstream service failures
- Recording tool inputs, outputs and side effects
Context, State and Memory
- Working context versus durable task state
- Short-term, episodic and semantic memory patterns
- Retrieval based on relevance, authority and permission
- Preventing memory leakage between users and tasks
- Summarising long-running work without losing critical facts
- Expiration, correction and deletion of stored memory
Durable and Long-Running Execution
- Checkpoints, resumable tasks and explicit state machines
- Retry policies for models, tools and networks
- Detecting loops, stalled tasks and contradictory plans
- Scheduling asynchronous and event-driven work
- Handling partial completion and compensating actions
- Designing safe cancellation and rollback
Human Oversight and Control
- Human-in-the-loop and human-on-the-loop operating models
- Approval points for financial, destructive or external actions
- Presenting evidence and uncertainty to reviewers
- Step-up controls when risk changes during execution
- Escalation when information is missing or conflicting
- Avoiding meaningless approval fatigue
Testing Agent Behaviour
- Unit tests for tools, policies and deterministic components
- Scenario tests for multi-step task completion
- Simulating tool errors, stale data and malicious content
- Evaluating plans, decisions, outcomes and side effects
- Regression datasets and reproducible execution environments
- Defining release thresholds and stop conditions
Deployment and Operational Architecture
- Stateless services and durable backing stores
- Sandboxed execution and controlled network access
- Identity, secrets and permission propagation
- Queues, workflow engines and concurrency control
- Versioning models, prompts, tools and memory schemas
- Canary releases, rollback and production support
Practical Capstone
- Select and assess an enterprise workflow for agentic fit
- Design the agent, tools, state model and control points
- Implement a multi-step task with durable execution
- Inject failures and demonstrate safe recovery
- Add human approval for a consequential action
- Present the production architecture and operational evidence
Intended audience
This course is intended for software developers, AI engineers, solution architects and technical leads building agents for enterprise workflows. It is suitable for practitioners who understand LLM APIs and now need to design systems that are reliable, supportable and safe enough for production use.
Prerequisites
Those attending this course should meet the following:
- Proficiency in Python or another server-side programming language
- Experience working with APIs and structured data
- Basic understanding of large language models and tool calling
- Familiarity with software testing, authentication and deployment concepts