Skip to content
Linear Horizon Training

Ready-made course · 1 day · Intermediate

Build an AI Agent in a Day

A hands-on workshop for developers: build a working agent with tool calling, state, structured outputs, error handling, permissions and a first evaluation.

This is a build day, not a survey of agent frameworks. You start with a task that actually needs tools, then implement function calling, state, planning, structured outputs, error handling and permissions. The day ends with a functioning agent and a short evaluation, not with a presentation about autonomy.

The course keeps the agent small enough to finish and strict enough to be worth finishing: validated tool arguments, a stop condition, and a permission boundary. Planning is introduced where it helps the task, not as a default.

Developers who need the deeper two-day agents course still benefit from this workshop as a first implementation. Teams that only need one internal agent often stop here and take the code into their own repository.

The output is a practical agent you ran, with traces and a list of the safeguards still required for production.

Who it is for
Developers who need to implement a first agent and will learn faster from a complete path than from a lecture.
Before you start
Professional software development and prior experience calling an LLM API. Teams new to LLMs should take the engineering or fundamentals course first.

You will be able to

  • Implement tool calling with schemas and argument validation.
  • Add state and a bounded planning or looping step.
  • Handle tool errors, retries and invalid model output.
  • Apply a permission boundary so the agent cannot call arbitrary tools.
  • Evaluate the agent against a small task set and inspect traces.

Modules

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

  1. 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.
  2. 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.
  3. 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.
  4. 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

You build one agent through the day. Typical tasks are internal operations, research with tools, or a constrained workflow. The agent runs, has traces, and is evaluated on a handful of tasks including a failure case.

You take away

  • A functioning practical agent
  • Tool schemas and a permission map
  • Traces and a small evaluation set
  • A list of production safeguards still to add

Combine it with

Contact