The AI Conference for Developers

2026 Edition

Most AI tutorials stop at the "Hello World" of conversational bots. This intensive training takes you far beyond the basics, equipping you with the practical skills to build, optimize, and scale production-ready AI agents using LangChain.

Whether you are transitioning from a weekend side-project to an enterprise-grade system, this workshop provides the real-world patterns, architectures, and techniques needed to engineer robust AI solutions.

What Sets This Training Apart?

• A Complete 360° Understanding: We don't just glue APIs together. You will gain a fundamental, comprehensive mastery of every aspect of agent development, from the foundational logic to advanced orchestration.
• Core Components Demystified: Understand exactly how the "engine" works beneath the abstraction. We break down every core component of the LangChain ecosystem and the agent development process so you have total control over your system's behavior.
• Moving Far Beyond the Basics: We tackle the complex challenges of real-world AI engineering. You will dive deep into advanced topics like implementing robust middleware, PII detection strategies, dynamic agent selection, and precision context engineering.
• Built for Production: Learn what it takes to actually ship. We cover critical, practical topics like guardrails, Human-in-the-Loop (HITL) workflows, and bridging the gap between AI and Traditional Engineering for seamless deployment and observation.
• Engaging, Step-by-Step Instruction: Benefit from a highly refined teaching style backed by over two decades of software development experience and international public speaking. Complex architectural concepts are built step-by-step with clear, practical examples in an environment that is as fun as it is educational.

Workshop Curriculum

Module I: The Fundamentals

• The Agent Loop: Understanding autonomous action, observation, and context.
• Core Mechanics: Mastering model configuration, system prompts, and enforcing structured outputs.
• Equipping Your Agent: Defining, configuring, and utilizing tools efficiently.
• State & Multimodality: Managing short-term memory (AgentState) and handling multimodal messages (PDFs, images, etc.).

Module II: Beyond the Basics

• Mastering Middleware: Implementing Node-style and Wrap-style hooks for tracking, transforming outputs, and early termination.
• Security & Context: Applying PII detection strategies, setting up operational guardrails, and mastering Context Engineering to provide the LLM exactly what it needs.
• Advanced Workflows: Dynamic model and tool selection, RAG architecture integration, and implementing Human-in-the-Loop for critical decision-making.

Module III: Production-Ready Systems

• Multi-Agent Architecture: Designing complex systems using Subagents, Supervisors, Routing, and Handoff patterns to distribute tasks.
• Protocol & Scale: Utilizing the Model Context Protocol (MCP) to expose external APIs and resources to your models.
• Real-World Operations: Handling infinitely long conversations, advanced prompt engineering, and mastering Traditional Engineering practices for deployment and system observability.

What to Expect

By the end of this workshop, you will walk away with a comprehensive, deep understanding of how to architect and build resilient, production-ready AI agents using a real-world, industry-standard framework.

Hands-on

During the workshop, participants will implement a fully functional multi-agent application based on the workshop content.

Your instructor: Nir Kaufman

Full-stack Agentic AI Tech Lead at Tikal with over two decades of engineering experience, specializing in robust web architectures and multi-agent AI systems. As a Google Developer Expert (GDE) in Web Technologies, international keynote speaker, and technical author, he is dedicated to bridging the gap between cutting-edge AI and scalable software engineering. Outside of pure tech, he drives industry engagement as the founder of the Tech a Hike community, and channels his creativity into playing the bass guitar and experimenting with vegan cooking.

AI is moving into the browser, and that changes the economics of AI-powered applications.

With browser-native AI APIs, tasks such as prompting, summarization, writing, translation and proofreading can run directly on the user's device. This can reduce cloud inference costs, API dependencies, data transfer and token usage, potentially to zero for supported workloads.

Combined with MCP and WebMCP, applications can expose structured tools and actions directly to AI agents without relying on expensive, context-heavy DOM automation.

In this hands-on workshop, you will learn how to build local-first, agent-ready web applications designed around one goal: do more AI work in the browser, send less to the cloud and minimize token costs.

High-Level Workshop Agenda

Block 1: The AI-Native Browser

From Cloud AI to Browser AI

• Tokens, context windows, latency and API costs
• What changes when inference moves into the browser?
• Local-first, cloud-first and hybrid AI architectures
• Privacy, latency, offline capabilities and cost

Browser Built-in AI

• Understanding the browser-native AI architecture
• Models, capabilities and feature detection
• Downloading and initializing browser models
• Capability detection and progressive enhancement

☕ Coffee Break

Block 2: Prompt API

• Interact with the browser's built-in language model
• Create and manage sessions
• Use system prompts and initial prompts
• Stream responses
• Generate structured output
• Manage context windows
• Explore multimodal possibilities

Lunch Break

Block 3: Task-Specific Browser AI APIs

Discover why specialized APIs can be preferable to generic prompting.

Summarizer API

• Summarize documents, articles and application content
• Configure summary types, formats and lengths
• Stream generated summaries
• Summarize large documents with small context windows

☕ Coffee Break

Block 4: Model Context Protocol and WebMCP

Model Context Protocol (MCP)

• Understand why agents need tools instead of prompts alone
• Work with resources, tools and structured interfaces
• Understand MCP clients and servers
• Connect applications and developer tooling to AI agents
• Explore where MCP fits into modern web architectures

WebMCP

• Bring agent-accessible tools directly into web applications
• Understand how WebMCP differs from traditional MCP
• Expose application functionality to browser agents
• Use declarative WebMCP with HTML forms
• Use imperative WebMCP with JavaScript parameters

Q&A Session

AI coding agents generate code faster than teams can review it. This one-day workshop covers the techniques that turn that speed into actual throughput: context engineering, loop engineering, graph engineering, and deterministic quality gates.

Everything is harness- and framework-agnostic, so the practices hold up as the tooling keeps changing.

What to Expect

• Foundations: The core concepts behind effective AI-assisted development.
• Live Demos: The techniques shown in action, step by step.
• Hands-on Exercises: Practice applying the methods yourself during the workshop.

You'll leave with practices you can apply to your own codebase immediately.

In this foundational workshop, you'll gain a clear understanding of modern software architecture principles tailored for the age of AI-assisted development. Whether you're building new applications or evolving existing systems, architectural thinking is more important than ever in a world where AI is transforming how we write and maintain code.

We will cover the core principles of modular, scalable, and testable system design, and explore how AI tools, from copilots to code generators, impact architectural decisions. You'll learn how to design clean, evolvable codebases that embrace automation without losing control of structure, quality, or maintainability.

Through hands-on exercises and real-world case studies, you'll walk away with practical knowledge to apply in your daily work, whether you're building microservices, monoliths, or hybrid architectures powered by intelligent components.

What You'll Learn

• Core Architectural Patterns: Learn how to apply proven patterns like layered, hexagonal, and event-driven architectures in AI-supported workflows.
• Designing for AI: Understand how AI assistants change the way we model, refactor, and document systems, and how to use them effectively.
• Trade-offs and Boundaries: Make better decisions around coupling, cohesion, team ownership, and long-term evolution of codebases.
• Architecture as Code: Discover tools and techniques for modeling and validating your architecture using modern developer workflows.
• AI Integration Points: Explore where and how to integrate AI-powered services, models, and APIs within robust software architectures.

Who Should Attend

Developers, tech leads, and architects who want to build strong architectural foundations while embracing AI-assisted tooling. No prior AI experience is required, just a passion for clean, thoughtful system design.

Future-proof your codebase and your career. Join us to master the fundamentals of software architecture for the AI-assisted era.

This workshop focuses on modern, long-lived Angular architectures and the key developments shaping frontend engineering in 2026. You'll learn how Signals, the Resource API, NgRx SignalStore, and Signal Forms work together to enable a reactive architecture, combined with proven concepts like vertical architectures, feature slicing, and enforceable architecture rules.

A special focus is on AI-assisted frontend engineering: how to make architectural decisions explicit, how to provide the right context through rules, skills, MCP, and hooks, how to evaluate modularization with AI and architecture tools, and how to use deterministic checks as guardrails for Coding Agents.

For this, we not only focus on the APIs but also place a strong emphasis on the underlying concepts. We discuss how the principles of good reactive design, modularization, and maintainable frontend architecture can be implemented with modern Angular, both with and without AI assistance.

Labs

All labs can be completed in the traditional way or with AI assistance, using rules, skills, MCP, and hook-based deterministic checks to keep the architecture under control.

Target Group

Developers with Angular experience who want to design and build modern Angular solutions that remain maintainable in the long run, and who want to understand how AI-assisted development changes the way we define, enforce, and evolve frontend architectures.