Skip to content
DisrupsoftDisrupsoft
Institutional & Benefits (SENCE)

AI agents course: what a technical team learns in 24 hours

AI agents course in 24 hours: what a technical team learns about RAG, LangChain, Azure OpenAI, multi-agent and AgentOps to reach production.

AI agents course: what a technical team learns in 24 hours

The prototype worked in the demo. It answered questions about the internal manuals and everyone was happy. Then someone asked whether it could check stock in the ERP, open a ticket when it didn't know the answer, and show which document each fact came from. That was the end of the demo.

An AI agents course for a technical team has to cover exactly that gap: the stretch between a chat that answers well and an agent that works with the company's systems and that someone can actually supervise. At Disrupsoft Academy we built it as 24 hours split into five modules. This article walks through what each module covers, who it's for, and what the team should be able to build by the end.

If you're still working out where an agent fits in your architecture, start with How to integrate AI agents into your company's software. This piece assumes that conversation has happened and the job now is to prepare the people who will build.

What changes when you go from using AI to building agents

Using a chat assistant means typing a question and reading the answer. Building an agent is a different job. You have to decide which tools it can call, which data it can read, how it keeps context between steps, and what it does when it isn't sure.

Microsoft's Agent Framework documentation puts it this way: an agent uses a language model to process inputs, call tools and MCP servers, and generate responses. The hard part is the middle. A model that writes well is not much use if it calls the wrong API or if nobody can check why it made a decision.

That's why the course is intermediate to advanced. It doesn't teach prompt writing. It teaches how to design the system around the model.

The five course modules

ModuleHoursWhat it covers
1. Agent fundamentals4ReAct and Reflexion patterns, tool use
2. LangChain and RAG6Prompt chains, indexes and evaluations
3. Integrations and pipelines6APIs, events, queues and CI/CD
4. Multi-agent and AgentOps4Coordination, routing, testing and monitoring
5. Production capstone4Final project ready for production

Modules 2 and 3 are the longest, for good reason. In the projects we've reviewed, when an agent fails in production it's rarely the model's fault. Usually it retrieves the wrong information, or the integration with the company's systems was rushed.

The course runs in hybrid or online format and comes with a Disrupsoft certificate.

RAG: getting the agent to answer from your documents

RAG (retrieval-augmented generation) lets a model answer with company information instead of only what it learned in training. The Azure AI Search documentation defines it as a pattern that extends what the model can do by grounding its answers in your own content.

The same page describes two approaches, and the team needs to understand both. In classic RAG, the application sends a single query, gets results through hybrid search and semantic ranking, and passes them to the model; for simple questions that's enough. In agentic retrieval, a model breaks a complex question into subqueries, runs them in parallel and returns structured results for the agent to use.

A note on names: Microsoft now presents the service as Foundry IQ (Azure AI Search). If your team finds documentation under both names, it's the same thing.

Module 2 works with indexes and, above all, with evaluations. A RAG system without evaluations is one where you can't tell whether it got better or worse after you changed a document.

LangChain, Azure OpenAI and the Microsoft ecosystem

The course uses LangChain for orchestration and Azure OpenAI models. The two work well together. Microsoft documents how to use LangGraph and LangChain with Foundry Agent Service through the langchain-azure-ai package, including OpenTelemetry tracing.

Two changes in context are worth keeping in mind:

  1. Azure OpenAI now lives inside Microsoft Foundry. Current documentation lists it as Azure OpenAI in Microsoft Foundry models. If you come across tutorials using the old name, they point to the same service.
  2. If your team works in .NET and knew Semantic Kernel, Microsoft describes Agent Framework as its direct successor, and AutoGen's too. The same teams built it, and it's available for C#, Python and Go (Go is in preview).

Does that mean you have to pick a framework before the course? No. The patterns it teaches (ReAct, RAG, tool use, multi-agent flows) are the same in any of them. What changes is the syntax.

Multi-agent and AgentOps: what separates a demo from operations

A single agent that does everything tends to end up with very long instructions and unpredictable behavior. Module 4 works with several specialized agents that coordinate, plus the routing logic that decides which one answers.

For whoever will maintain the system, though, the part that matters most is AgentOps: testing, measuring and monitoring. Microsoft Foundry includes built-in evaluators for general quality, for RAG (groundedness and relevance), for safety, and for agents (tool call accuracy and task completion). Tracing is built on OpenTelemetry and plugs into Application Insights, so the team can follow each step of an agent's reasoning. There's also an AI red teaming agent, based on PyRIT, that simulates attacks before you go live.

The course covers traces, metrics, controls and service level objectives (SLOs). Governance and risk, including permissions, personal data and ownership, are covered in more depth in Enterprise AI agents: minimum security and governance. We suggest reading it before you define the capstone project.

Who it's for and what they should build by the end

Given its level, the course is aimed at developers, architects and data engineers who already code and have used AI models as users. If your team has never called an API, start with Introduction to Enterprise Artificial Intelligence.

After the 24 hours, the team should be able to:

  • choose between a ReAct pattern, one with reflection, or a multi-agent flow depending on the problem;
  • set up RAG over their own indexes and measure its quality with evaluations;
  • connect an agent to core systems such as ERP or CRM through APIs, events and queues;
  • put the agent into a CI/CD pipeline with tests;
  • instrument it with traces and metrics to know what it's doing in production;
  • present a capstone project that solves a real case from their area.

One caveat: the course prepares the team to build, but it won't decide for you who owns the agent or which processes are worth automating. That's a business decision, and it pays to make it first.

Frequently asked questions

Do I need to know how to code to take this course?

Yes. It's intermediate to advanced and works with code, APIs and pipelines. For non-technical profiles who want to build agents without coding, Copilot Studio is a better starting point.

Does the course only use Microsoft tools?

No. It uses LangChain, which is open source, together with Azure OpenAI models. The patterns it teaches also apply to other frameworks such as Microsoft Agent Framework.

What does the team walk away with?

A capstone project designed for production and the habit of evaluating and monitoring what they build. Each participant also receives a Disrupsoft certificate.

Next step

If your team has a prototype that can't make it to production, or you want the next agents built with a method from day one, look at the full program for AI Agents for Enterprise: Build & Deploy (24h) and let's talk about adapting it to your company's systems.

Agentes De AICapacitacionAzureDesarrollo De SoftwareAI

← View more articles