Agentic AI

August 14, Calgary, Canada

Agentic AI Workshop 2026: The Builders' Workshop

The Builders' Workshop — One Day, Two Tracks, Hands-On

Submit your Proposal
Register Now

Parallel Tracks

10+ Sessions
60% Hands-On Time

About the Workshop

The Agentic AI Workshop 2026 is an intensive, one-day event designed for practitioners who build, deploy, and scale AI agent systems. This workshop prioritizes hands-on learning — at least 60% of the program is dedicated to active coding, building, and experimentation.

Featuring two parallel tracks — Agent Architecture & Frameworks and Enterprise Orchestration & Production — the workshop bridges the gap between cutting-edge research and production-ready implementation. Whether you are prototyping your first autonomous agent or scaling multi-agent systems across enterprise infrastructure, this workshop provides the interdisciplinary ecosystem to accelerate your work.

We are now accepting proposals for hands-on labs, technical tutorials, and short talks. We seek practitioners, researchers, and engineers who can share real-world experience building agentic systems with frameworks such as LangGraph, CrewAI, AutoGen, and the emerging MCP and A2A protocols.

Topics of Interest

We welcome proposals related to the following topics

Foundations for Software Engineers

These sessions target software engineers who are new to AI. They assume programming skills (Python, APIs, software architecture) but no knowledge of LLMs, prompts, or agents. The goal is to establish core mental models and vocabulary, and build the first agentic solution.

From Software Engineer to AI Engineer: The Conceptual Bridge

Maps familiar software engineering concepts (APIs, state machines, event loops) to their AI agent equivalents. No math, no ML theory — just a mental model translation for developers.

Build a working application that calls an LLM API, handles structured outputs, implements retry logic, and manages token budgets. Treats the LLM as a powerful API endpoint.

Systematic prompt engineering using software engineering principles: version control for prompts, testing strategies, output parsing, and structured generation with Pydantic models.

Defines the spectrum from simple LLM calls to fully autonomous agents. Introduces the ReAct pattern, tool use, and planning — the three pillars that distinguish agents from chatbots.

From zero to a working agent: participants build a research assistant that can search the web, summarize documents, and answer questions using LangChain and OpenAI. No ML knowledge required.

Implement function calling and tool use from scratch. Build custom tools (database queries, API calls, file operations) and wire them into an agent loop. Covers OpenAI, Anthropic, and open-source patterns.

Architecture and Frameworks

These sessions target engineers who have experimented with LLM APIs and perhaps built a simple chatbot or RAG system, but have not yet built production-grade agents. They are ready to learn frameworks and architectural patterns.

LangGraph from Zero to Hero: Stateful Agent Workflows

Build a multi-step agent using LangGraph’s graph-based architecture. Covers nodes, edges, conditional routing, state management, and human-in-the-loop checkpoints.

Design and deploy a crew of role-based agents that collaborate on a complex task (e.g., market research report). Covers agent roles, task delegation, and inter-agent communication.

Evolve basic RAG into agentic RAG: self-correcting retrieval, query decomposition, multi-hop reasoning, and adaptive chunking strategies. Hands-on with LlamaIndex and LangChain.

Implement MCP servers and clients from scratch. Connect your agent to databases, file systems, and APIs using the standardized protocol. Covers the specification, security model, and real-world patterns.

Architectural patterns for agent memory: conversation buffers, vector-based long-term memory, entity memory, and episodic recall. When to use each and how they compose.

Build multi-agent conversations using AutoGen’s conversation patterns. Integrate with Azure services via Semantic Kernel. Covers group chat, nested agents, and code execution sandboxes.

A pattern language for agent architectures. Covers the Router pattern, Plan-and-Execute, Self-Reflection, and Critic agents. When to use each and how to combine them.

Techniques for ensuring agents produce machine-readable outputs: JSON mode, Pydantic validation, constrained generation, and graceful fallback strategies.

Production Engineering and Scale

These sessions target engineers who have built working agents and are now facing the challenges of reliability, evaluation, cost, and deployment at scale. They understand frameworks and are ready for production engineering.

Agent Evaluation: Metrics, Benchmarks, and Continuous Testing

Build an evaluation pipeline for your agents: task success rate, tool-use accuracy, latency budgets, and regression testing. Covers RAGAS, DeepEval, and custom evaluation harnesses.

Implement input/output guardrails, content filtering, PII detection, and hallucination prevention. Build a safety layer using NeMo Guardrails and custom validators.

Instrument your agents with LangSmith, Arize Phoenix, or OpenTelemetry. Build dashboards for token usage, latency, error rates, and decision traces. Debug production failures from traces.

Patterns for coordinating multiple agents: supervisor architectures, hierarchical delegation, shared blackboards, and consensus mechanisms. Covers failure handling and deadlock prevention.

Practical strategies for reducing agent costs: model routing, caching, prompt compression, batching, and hybrid local/cloud architectures. Real case studies with before/after metrics.

Implement approval workflows, confidence thresholds, escalation paths, and interactive correction loops. Build agents that know when to ask for help.

Implement Google’s A2A protocol for agent interoperability. Build agents that discover, negotiate with, and delegate to other agents across organizational boundaries.

Package agents as production services: Docker containerization, message queue integration, horizontal scaling, health checks, and graceful degradation patterns.

Architectural patterns for agents that run for hours or days: durable execution, checkpoint/resume, idempotency, and handling LLM provider outages mid-task.

Enterprise and Advanced Topics

These sessions target senior engineers and architects working in enterprise environments or specialized domains. They address advanced topics including security and compliance, model fine-tuning, self-improving systems, multi-modal capabilities, and regulated industry deployments.

Enterprise Agent Architecture: Security, Compliance, and Governance

Design agent systems that meet enterprise requirements: role-based access control, audit logging, data residency, SOC 2 compliance, and secure tool execution sandboxes.

Train specialized agent models using reinforcement learning from human feedback (RLHF) and direct preference optimization (DPO). Covers data collection, training pipelines, and evaluation.

Architectures for agents that improve over time: self-reflection loops, experience replay, automated prompt optimization, and meta-cognitive strategies.

Build agents that process images, generate code, and interact via voice. Covers GPT-4o vision, Whisper integration, code interpreter sandboxes, and multi-modal tool chains.

Case studies of deploying agents in regulated industries. Covers domain adaptation, compliance requirements, validation frameworks, and the unique challenges of high-stakes automation.

Case studies of deploying agents in regulated industries. Covers domain adaptation, compliance requirements, validation frameworks, and the unique challenges of high-stakes automation.

Join the Agentic AI Workshop 2026​

Share ideas, connect with global experts, and be part of the Agentic AI 2026.
Register Now