Skip to content
Linear Horizon Training

Ready-made course · 2 days · Advanced

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.

“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.

Who it is for
Intermediate and advanced developers who will implement or review tool-using and agentic systems.
Before you start
Solid software engineering and prior experience calling LLM APIs. The RAG fundamentals course, or equivalent experience, is helpful if the agent will retrieve documents.

You will be able to

  • Define an agent in engineering terms: tools, state, loop, boundaries and stopping conditions.
  • Implement function calling with schema validation, permissions and least privilege.
  • Compare planning, ReAct-style loops and explicit workflows, and choose the simpler design that works.
  • Add memory and state without confusing conversation history with durable application data.
  • Handle retries, tool failure, timeouts and partial completion.
  • Implement human-in-the-loop approval for consequential actions.
  • Evaluate and observe agents using traces, task success and cost, not only the final message.

Modules

8 quarter-day modules. Each one can go into a custom course on its own.

  1. Workflows versus agents

    • The spectrum from a single call to an autonomous agent.
    • Chaining, routing, parallel calls and evaluator loops.
    • Choosing the least autonomy that does the job.
    • Exercise: redesign an over-agentic system as a workflow.
  2. Designing tools for models

    • Tool names, descriptions and schemas a model uses correctly.
    • Validating arguments before any side effect.
    • Errors the model can recover from.
    • Lab: wrap an existing API as a set of tools.
  3. Agent loops, planning and state

    • The agent loop, step by step.
    • Planning, ReAct and reflection.
    • State, memory and stopping conditions.
    • Lab: build a loop without a framework, then compare one.
  4. Context engineering and memory

    • What goes into context, what is retrieved and what is left out.
    • Long conversations: truncation, summaries and their failure modes.
    • Short-term and long-term memory, and when to forget.
    • Prompt caching and its effect on cost and latency.
  5. Agent failures, permissions and human approval

    • How agents fail: loops, drift and confident wrong actions.
    • Permission boundaries and scoped credentials.
    • Human approval at the decisions that matter.
    • Lab: add approvals and limits to a working agent.
  6. Orchestration and multi-agent systems

    • Orchestrator and worker patterns.
    • Hand-offs, shared state and context isolation.
    • Frameworks compared, and the cost of adopting one.
    • When several agents are worse than one.
  7. Evaluating agents and multi-step systems

    • Scoring the outcome against scoring the path taken.
    • Tool-call accuracy, step counts and recovery from errors.
    • Simulated users and environments.
    • Lab: evaluate an agent on a task set and find its weakest step.
  8. Lab: build a working agent

    • A task from your own work, chosen at the start.
    • Tools, a loop and a stopping condition.
    • Limits, approvals and a small evaluation set.
    • Demonstrate it, then list what production would still need.

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.

You take away

  • 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

Combine it with

Contact