Workshops

Who should attend?

This hands-on workshop is designed for:

• Developers, QA engineers and BAs building AI-powered applications

• Security engineers responsible for securing LLM integrations

• Software architects designing agentic systems

What can participants expect?

In this 100% hands-on workshop, participants will explore AI-age attack vectors and the emerging AI Kill Chain through a Capture The Flag (CTF) format.

Using a pre-configured, zero-friction GitHub Codespaces environment, participants will follow an Attack - Defend approach:

1. See it: Watch live demonstrations of real-world vulnerabilities.

2. Attack it: Exploit vulnerabilities in isolated, safe sandboxes.

3. Defend it: Implement architectural security controls to address the vulnerabilities.

4. Verify it: Use automated Pytest checks to validate that the fixes work.

The goal is to move beyond understanding AI security risks to experiencing how attacks happen and learning how to build systems that can withstand them.

Key learning outcomes

By the end of the workshop, participants will be able to:

• Understand the AI Kill Chain: See how vulnerabilities such as prompt injection, vector manipulation (data poisoning) and jailbreaking can be chained together to create enterprise-level breaches.

• Implement the Dual-LLM Pattern: Separate untrusted data extraction from highly privileged execution contexts to reduce the impact of malicious inputs.

• Build structural defences: Use strict schema validation with Pydantic to defend against instruction injection, rather than relying on traditional regex-based filtering.

• Design defence-in-depth architectures: Apply stateful middleware guardrails to prevent denial-of-service loops and use output sanitisation pipelines to secure agentic workflows.

Prerequisites

Participants should have:

• A laptop with a standard web browser

• A GitHub account to access the pre-configured GitHub Codespaces cloud IDE

• An LLM API key, such as Anthropic, a free API key from Groq, or a local Ollama setup

• Basic familiarity with Python, as the workshop uses Python 3.11, Docker and Pytest

Who should attend?

This hands-on workshop is designed for software engineers and tech leads who are comfortable reading and writing Python and want to learn how to optimise real-world LLM-powered applications.

No prior AI, LLM or agent-building experience is required. Everyone starts with the same working baseline. The workshop is best suited for intermediate-to-advanced engineers rather than those new to programming, as participants will write real code to implement architectural optimisations, not just watch a demo.

What can participants expect?

Participants will learn practical, transferable LLM optimisation skills using a custom AI coding agent as a hands-on testbed. The workshop starts with a small, working agent harness built from scratch, without framework magic. The agent can read and write files, run shell commands, and track its own token usage and cost.

Participants will then choose and implement a real-world optimisation technique used in production LLM applications, such as:

• Conversation summarisation
• Response caching
• Model routing
• Context window trimming
• Prompt optimisation

Each optimisation will be implemented as a self-contained, pluggable module within the agent harness and tested to prove that it works.

Rather than relying on a visual demo, participants will run the same task through the same model with the optimisation switched on and off. They will compare real token and cost metrics alongside a pass/fail correctness check. The workshop will close with a comparison of results across the different techniques, helping participants build a practical understanding of which optimisation strategy to use in different LLM applications.

Key learning outcomes

• Transferable LLM optimisation skills: Understand how LLM-powered applications, including coding agents and other agentic loops, work under the hood and how to manage their cost and performance in production environments.
• Modular architecture for AI: Gain hands-on experience building cost and performance optimisations as clean, isolated modules using patterns such as dependency injection and clear interfaces.
• Data-driven evaluation: Learn a repeatable approach to proving whether an optimisation actually works using before-and-after token and cost metrics, along with correctness benchmarks.
• Strategic decision-making: Develop a practical understanding of the cost and performance trade-offs across different optimisation techniques, so you can choose the right approach for different LLM use cases.

Prerequisites

Participants should have:

• A laptop that can install and run Python 3.12+ on Mac, Linux or Windows
• Comfort with Python and basic terminal or command-line use
• Basic Git familiarity, such as cloning and committing, is helpful but not essential
• An API key for Claude (Anthropic) or OpenRouter. Please check with the organisers beforehand whether an API key will be provided or if you should bring your own. API costs for the session are typically small, ranging from a few pence to a few pounds.
• Nothing else needs to be prepared in advance. The session will begin by setting up the shared base agent harness together, so there is no take-home setup required.

Who should attend?

This hands-on workshop is designed for software engineers, tech leads, product managers and anyone curious about building real multi-agent systems.

No prior agent-building experience is required. Everyone starts from the same working baseline and builds the system step by step.

What can participants expect?

In this 2-hour, hands-on workshop, participants will build a complete multi-agent system layer by layer. Rather than watching a demo, you will configure and build a working system yourself using OpenClaw, a local-first agent gateway that connects multiple isolated agents to Telegram, with each agent having its own workspace, memory and persona defined in plain Markdown.

The workshop starts with a single agent and progressively adds capabilities:

• Connect agents to real-world tools such as Gmail and Google Sheets
• Route tasks between local LLMs, where possible, and cloud-based LLMs
• Orchestrate multiple agents that collaborate on tasks
• Enable agents to delegate and hand off work to one another
• Connect everything into an end-to-end workflow

By the end of the session, you will have configured and built a working multi-agent system that can interact with real tools and coordinate tasks across multiple agents.

Key learning outcomes

• Multi-agent architecture: Learn how to design, configure and orchestrate multiple isolated agents that collaborate on real tasks, with separate workspaces, memory and role-based personas using OpenClaw's gateway pattern.
• Tool use and MCP integration: Gain hands-on experience connecting agents to real-world tools through MCP servers and function calling, turning LLMs from chatbots into systems that can take action.
• Agent-to-agent communication: Understand how agents delegate, route and hand off tasks to one another as part of a multi-agent pipeline, from email classification to finance processing.
• End-to-end orchestration: Learn how individual agents and tools can be connected into a coordinated workflow that solves a larger business task.

Prerequisites

Participants should have:

• A laptop with Docker Desktop preinstalled. Mac, Linux and Windows are supported.
• The workshop GitHub repository cloned on your laptop. The repository will be shared before the workshop.
• Comfort with basic terminal or command-line use
• Basic Git familiarity, such as cloning and committing, is helpful but not essential
• A Google account. A spare account is recommended for Gmail and Google Sheets integrations used by the agents during the workshop.
• A Telegram account for agent notifications and interaction
• An API key for Claude (Anthropic) or OpenRouter. Please check with the organisers beforehand whether an API key will be provided or if you should bring your own. API costs for the session are typically very small, ranging from a few pence to a few pounds.