Advanced · 2 days
Building AI Agents
A two-day course for intermediate and advanced developers: design and build useful agents with tools, state, permissions and evaluation, rather than unsupervised demos.
2 days · Advanced · RAG & Agents · Intermediate and advanced developers
Overview
“Agent” is used to mean anything from a single tool call to an unsupervised loop that books travel and writes to production systems. Most organisations need the former, with the discipline of the latter. This course teaches how to build agents that are useful, bounded and operable.
You start with a precise definition: an agent as software that can choose tools, maintain state and iterate toward a task, inside limits set by the application. The course covers function calling, planning, reasoning loops, memory, workflows, structured outputs, retries and failure handling. Human-in-the-loop, permissions, evaluation, observability and cost are treated as design requirements.
The labs are multiple and progressive. The course ends with a production-oriented agent: clear tools, explicit boundaries, traces, and a path for a human to approve or stop work.
You leave able to choose between a deterministic workflow and an agentic loop, and to implement the latter without giving the model more authority than your organisation intended.
Audience
Intermediate and advanced developers who will implement or review tool-using and agentic systems.
Prerequisites
Solid software engineering and prior experience calling LLM APIs. The RAG fundamentals course, or equivalent experience, is helpful if the agent will retrieve documents.
Duration
2 days
Can be focused on a particular domain or tool set, or reduced to the one-day workshop for teams that only need a first agent.
Learning outcomes
- 01
Define an agent in engineering terms: tools, state, loop, boundaries and stopping conditions.
- 02
Implement function calling with schema validation, permissions and least privilege.
- 03
Compare planning, ReAct-style loops and explicit workflows, and choose the simpler design that works.
- 04
Add memory and state without confusing conversation history with durable application data.
- 05
Handle retries, tool failure, timeouts and partial completion.
- 06
Implement human-in-the-loop approval for consequential actions.
- 07
Evaluate and observe agents using traces, task success and cost, not only the final message.
Outline
- 01
What an agent is for
- A strict definition: model, tools, state, objective and authority.
- Deterministic workflows versus agentic loops, and the cost of the latter.
- Structured outputs and tool schemas as the real interface.
- Lab: wrap existing capabilities as tools and call them from a model.
- 02
Loops, planning and state
- Reasoning loops, planning, and why unconstrained iteration is an operations problem.
- State, memory, scratchpads and the difference between context and storage.
- Orchestration: sequential tools, fan-out, and when a graph is justified.
- Lab: implement a bounded loop with a clear stop condition.
- 03
Failure, permissions and humans
- Retries, idempotency, timeouts and compensating actions.
- Permissions, identities and preventing the model from choosing forbidden tools.
- Human-in-the-loop: approval, clarification, and handing work back to a person.
- Security: injection via tool results, and treating tool output as untrusted.
- Lab: add an approval gate and a denied-tool path.
- 04
A production-oriented agent
- Evaluation: task success, tool correctness, loops and human interventions.
- Observability: traces, token cost, wall-clock time and user-visible status.
- Cost controls, caching and knowing when to stop being agentic.
- Build: complete a useful agent against a realistic task, with traces and an evaluation set.
Practical work
Multiple labs: tool calling, a bounded loop, failure handling, permissions and a human approval step. The final system is a useful agent — for example research, operations or internal workflow — with traces, limits and evaluation rather than an open-ended autonomous demo.
Takeaways
- Working agent implementations with tools, state and traces
- Patterns for permissions, retries and human approval
- An evaluation approach for agent traces
- A decision guide for workflow versus agent
Delivery
Cognitecta delivers private corporate training, on-site or as remote live training. Courses can be run as published, or adapted to your organisation’s stack, domain and experience level.
Instructor
Nicholas Johnson, AI architect and software engineer. He has a degree in Artificial Intelligence and around twenty years of professional technology training, including hundreds of courses for engineering teams and large organisations. About.
Related courses
2 days · Advanced
Agentic RAG Systems
A two-day advanced course combining retrieval with agentic reasoning and tool use: multi-step retrieval, query planning, structured sources and a production architecture for complex knowledge work.
2 days · Intermediate
RAG: From Fundamentals to Production
A two-day course on retrieval-augmented generation as an engineering discipline: why naive RAG fails, and how to design a system that can be evaluated, secured and operated.