Architectural decisions are often influenced by blindspots, biases, and unchecked assumptions, which can lead to significant long-term challenges in system design. In this session, we’ll explore how these cognitive traps affect decision-making, leading to architectural blunders that could have been avoided with a more critical, holistic approach.

You’ll learn how common biases—such as confirmation bias and anchoring—can cloud judgment, and how to counteract them through problem-space thinking and reflective feedback loops. We’ll dive into real-world examples of architectural failures caused by biases or narrow thinking, and discuss strategies for expanding your perspective and applying critical thinking to system design.

Whether you’re an architect, developer, or technical lead, this session will provide you with tools to recognize and mitigate the impact of biases and blindspots, helping you make more informed, thoughtful architectural decisions that stand the test of time.

Microservices architecture has become a buzzword in the tech industry, promising unparalleled agility, scalability, and resilience. Yet, according to Gartner, more than 90% of organizations attempting to adopt microservices will fail. How can you ensure you're part of the successful 10%?

Success begins with looking beyond the superficial topology and understanding the unique demands this architectural style places on the teams, the organization, and the environment. These demands must be balanced against the current business needs and organizational realities while maintaining a clear and pragmatic path for incremental evolution.

In this session, Michael will share some real-world examples, practical insights, and proven techniques to balance both the power and complexities of microservices. Whether you're considering adopting microservices or already on the journey and facing challenges, this session will equip you with the knowledge and tools to succeed.

The age of hypermedia-driven APIs is finally upon us, and it’s unlocking a radical new future for AI agents. By combining the power of the Hydra linked-data vocabulary with semantic payloads, APIs can become fully self-describing and consumable by intelligent agents, paving the way for a new class of autonomous systems. In this session, we’ll explore how mature REST APIs (level 3) open up groundbreaking possibilities for agentic systems, where AI agents can perform complex tasks without human intervention.

You’ll learn how language models can understand and interact with hypermedia-driven APIs, and how linked data can power autonomous decision-making. We’ll also examine real-world use cases where AI agents use these advanced APIs to transform industries—from e-commerce to enterprise software. If you’re ready to explore the future of AI-driven systems and how hypermedia APIs are the key to unlocking it, this session will give you the knowledge and tools to get started.

In this presentation, we'll cover some of the latest developments and feature additions in GitHub Copilot as rolled out in recent months and at GitHub Universe. Join author, trainer, technologist, and author of the upcoming book “Learning GitHub Copilot” from O'Reilly, Brent Laster to learn what's new and exciting with this popular generative AI tool!

GitHub Copilot continues to evolve as a popular AI coding assistant, adding features and functionality regularly. But there are more significant changes that have been rolled out recently, including wider Copilot integration in the individual GitHub plan for things like indexing repos, pull request and issue summaries. Also, there's new functionality for reviewing code, agent edits, vision features, giving Copilot custom instructions that will apply to every chat, and more!

Just as CI/CD and other revolutions in DevOps have changed the landscape of the software development lifecycle (SDLC), so Generative AI is now changing it again. Gen AI has the potential to simplify, clarify, and lessen the cycles required across multiple phases of the SDLC.

In this session with author, trainer, and experienced DevOps director Brent Laster, we'll survey the ways that today's AI assistants and tools can be incorporated across your SDLC phases including planning, development, testing, documentation, maintaining, etc. There are multiple ways the existing tools can help us beyond just the standard day-to-day coding and, like other changes that have happened over the years, teams need to be aware of, and thinking about how to incorporate AI into their processes to stay relevant and up-to-date.

In this presentation, we'll cover the options, tips, and tricks for using GitHub Copilot to help us identify how to test code, generate tests for existing code, and generate tests before the code.

Join global trainer, speaker, and author of the upcoming book, Learning GitHub Copilot, Brent Laster as he presents material on multiple ways to leverage Copilot for testing your code on any platform and framework.

Have you wondered what options GitHub Copilot can provide for helping to not only write your code, but test your code? In this session, we'll examine some key ways that Copilot can support you in ensuring you have the basic testing needs covered. In particular, we'll cover:

• A quick overview of GitHub Copilot
• Letting Copilot tell you how to get started testing for a new language
• Creating tests for existing code through one-step commands
• Creating tests for existing code with comments
• Creating tests for existing code with explicit prompts
• Validating inputs to functions using Copilot
• Using Copilot to build out tests for edge cases
• Leveraging testing frameworks
• Building tests before the code - TDD with Copilot

2025 has been declared the “year of the agents”. There's a lot of potential, but there's also a lot to understand and make sense of. AI Agents are combinations of LLMs, tools, and custom roles that can autonomously perform tasks and make decisions based on context and user input. There are multiple types of agents and multiple agents can be managed together to cooperatively handle individual tasks that are part of a larger project to accomplish an overall goal.

By combining capabilities like tool access, multi-step reasoning, and real-time adjustments, agents can construct and complete complex workflows and intelligent solutions. In this presentation, we'll look at what AI agents are, how they really work, different types of agents and design patterns and touch on frameworks, challenges and more.

There is a new way of Threading, which means it is time to prepare. Project Loom has introduced Java Virtual Threads, which is now available in Java 21. Virtual Threads are small Threads meant to perform quick operations with the need to procure long-running OS threads, which can prove expensive. In this presentation, we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, and what does it mean for third-party libraries.

• What is a Virtual Thread
• Creating and Using a Virtual Thread
• What will Loom's Virtual Threads do to Future and Reactive
• What is a Continuation?
• What is Structured Concurrency?
• What are Scoped Values

Join us for an indepth exploration of cuttingedge messaging styles in your large domain.

Here, we will discuss the messaging styles you can use in your business.

• Event Sourcing
• EventDriven Architecture
• Claim Check
• Event Notification
• Event Carried State Transfer
• Domain Events

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.

So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.

For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.

In this handson workshop, you'll build a complete Spring AIenabled application applying such techniques as prompt templating, Retrieval Augmented Generation (RAG), conversational history, and tools invocation. You'll also learn prompt engineering techniques that can help your application get the best results with minimal “hallucinations” while minimizing cost.

Workshop Requirements

In the workshop, we will be using…

• Java 17+
• An IDE of your choosing (I will be using IntelliJ IDEA)
• OpenAI's API (you will need an account and a small amount of credit $5 is more than enough).

Optionally, you may choose to use a different AI provider other than OpenAI such as Anthropic, Mistral, or Google Vertex (Gemini), but you will need an account with them and some reasonable amount of credit with them. Or, you may choose to install Ollama (https://ollama.com/), but if you do be sure to install a reasonable model (llama3:latest or gemma:9b) before you arrive.

Know that if you choose to use something other than OpenAI, your workshop experience will vary.

By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.

So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.

For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.

In this handson workshop, you'll build a complete Spring AIenabled application applying such techniques as prompt templating, Retrieval Augmented Generation (RAG), conversational history, and tools invocation. You'll also learn prompt engineering techniques that can help your application get the best results with minimal “hallucinations” while minimizing cost.

Workshop Requirements

In the workshop, we will be using…

• Java 17+
• An IDE of your choosing (I will be using IntelliJ IDEA)
• OpenAI's API (you will need an account and a small amount of credit $5 is more than enough).

Optionally, you may choose to use a different AI provider other than OpenAI such as Anthropic, Mistral, or Google Vertex (Gemini), but you will need an account with them and some reasonable amount of credit with them. Or, you may choose to install Ollama (https://ollama.com/), but if you do be sure to install a reasonable model (llama3:latest or gemma:9b) before you arrive.

Know that if you choose to use something other than OpenAI, your workshop experience will vary.

In this session, we'll cover several useful prompt engineering techniques as well as some emerging patterns that are categorized within the “Agentic AI” space and see how to go beyond simple Q&A to turn your LLM of choice into a powerful ally in achieving your goals.

At it's core, Generative AI is about submitting a prompt to an LLM-backed API and getting some response back. But within that interaction there is a lot of nuance, particularly with regard to the prompt itself.

It's important to know how to write effective prompts, choosing the right wording and being clear about your expectations, to get the best responses from an LLM. This is often called “prompt engineering” and includes several patterns and techniques that have emerged in the Gen AI space.

In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.

Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.

As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?

Workshop Requirements

You'll need…

• A Java IDE of your choice. I'll be using IntelliJ, but you are welcome to use Spring Tools, Netbeans, or whatever you prefer for Java development. (Spring Tools–either the Eclipse or VSCode version–or IntelliJ is recommended, though).
• Java 17 or higher. I recommend using SDKMan (https://sdkman.io/) for managing multiple versions of Java on your machine. I'll be using Zulu 17.0.6 for most tasks, but may switch to a Liberica NIK version for purposes of native builds.
• Docker (optional, but may be necessary for some tasks)

Security problems empirically fall into two categories: bugs and flaws. Roughly half of the problems we encounter in the wild are bugs and about half are design flaws. A significant number of the bugs can be found through automated testing tools which frees you up to focus on the more pernicious design issues. 

 In addition to detecting the presence of common bugs, however, we can also imagine automating the application of corrective refactoring. In this talk, I will discuss using OpenRewrite to fix common security issues and keep them from coming back.

In this talk we will focus on:

Using OpenRewrite to automatically identify and fix known security vulnerabilities.
Integrating security scans with OpenRewrite for continuous improvement.
*Free up your time to address larger concerns by addressing the pedestrian but time-consuming security bugs.

If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.

This will be an overview of the benefits of vectors databases as well as an introduction to the major players.

We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.

We will cover:

• A brief overview of vectors
• Why vectors are so important to machine learning and datadriven systems
• Overview of the offerings
• Adding vector search to other systems
• Sample use cases shown with one of the key open source engines

If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.

This will be an overview of the benefits of vectors databases as well as an introduction to the major players.

We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.

We will cover:

• A brief overview of vectors
• Why vectors are so important to machine learning and datadriven systems
• Overview of the offerings
• Adding vector search to other systems
• Sample use cases shown with one of the key open source engines

Modernizing legacy systems is often seen as a daunting task, with many teams falling into the trap of rigid rewrites or expensive overhauls that disrupt the business. The Tailor-Made Architecture Model (TMAM) offers a new approach—one that is centered on incremental evolution through design-by-constraint. By using TMAM, architects can guide legacy systems through a flexible, structured modernization process that minimizes risk and aligns with both technical and organizational needs.

In this session, we’ll explore how TMAM facilitates smooth modernization by identifying and addressing architectural constraints without resorting to drastic rewrites. We’ll dive into real-world examples of how legacy systems were evolved incrementally and discuss how TMAM provides a framework for future-proofing your systems. Through its focus on trade-offs, communication, and holistic fit, TMAM ensures that your modernization efforts not only solve today’s problems but also prepare your system for the challenges of tomorrow.

This session is ideal for architects, developers, and technical leads who are tasked with modernizing legacy systems and are looking for a structured, flexible approach that avoids the pitfalls of rigid rewrites. Learn how to evolve your legacy system while keeping it adaptable, scalable, and resilient.

Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.

This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.

Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.

Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.

Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.

This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.

Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.

Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.

Ever since OpenAI added a chat interface in front of its GPT models, large language models (LLMs) have become all the rage. But with so many different players, different models, related technologies, and confusing terminology, it can be challenging to understand what each means and is used/useful for. Join us as we help you understand and navigate the ever growing LLM ecosystem.

Join expert Brent Laster to break down the different model types, creators, uses, and terminology you'll encounter across the vast array of LLMs available today. Understand the significance and meaning of GPT vs Llama vs Claude vs … Learn what the naming conventions and things like quantization mean. Learn why some models are best suited for specialized tasks like sentiment analysis, translation, classification and why some are more suited to general use. After attending this session, you'll be well-versed in the LLM semantics and ready to start working with many different models.

Microservices have fundamentally changed the way we develop and deploy applications. Everything from team topologies, to DevOps to observability—everything changed, and for the better.

However, it's not all rainbows and unicorns. Operationalizing microservices is hard. Microservices encourage WET (write everything twice) to ensure that services are as decoupled from each other as possible. But how does that work when we have to deal with cross-cutting concerns that we need for every service?

Enter the service mesh. Service meshes like Istio allow us to “slot” in cross-cutting architectural concerns within a kubernetes cluster, letting our services focus on solving actual business concerns.

In this fast-paced session, we will blitz through what Istio is, how it works, and what facilities it offers to DRY out your microservices. Come see how Istio can make your cluster programmable and application-aware.

This session will focus on data governance and making data available within your enterprise. Who owns the data, how do we obtain the data, and what does governance look like?

• CQRS
• Materialized Views
• Warehousing vs Data Mesh
• OLAP vs OLTP
• Pinot, Kafka, and Spark
• Business Intelligence
• Making Data Available for ML/AI

Spring Security has long been a powerful guard to place around your Spring applications, providing authentication, authorization, and many more concerns around keeping your application secure.

As time has progressed, Spring Security has evolved to provide even more capabilities, but has applied some self-improvement to make working with Spring Security even easier. That is to say, the way you configure and apply Spring Security today has changed dramatically from it's early XML-oriented approach and is even different now than some of the more recent Java-based configuration strategies.

In this example-driven session, we'll explore the latest and greatest that Spring Security has to offer, with an emphasis on how to apply security aspects to your applications with the latest configuration styles supported by Spring Security. You'll see how security is enabled in modern Spring applications using the Lambda DSL configuration approach, the preferred way to configure Spring Security and the ONLY way to configure Spring Security 7.

Java’s evolution is remarkable, and the leap from JDK 17 to the current version brings a wealth of powerful features to elevate your projects. Join us for an exciting session to explore select JEPs (Java Enhancement Proposals) introduced up to today, diving into their use cases and practical benefits for your work or open-source initiatives.

What You’ll Learn:
How to enable and utilize advanced Java features introduced in JDK 23.
Real-world demonstrations of cutting-edge updates, including:

• Stream Gatherers: Handle complex data streams with ease.
• Statements Before super(): Test invariants without constructing objects.
• Stable Values
• Unnamed Variables and Parameters: Enhance code readability and maintainability.
• Launch Multi-File Source-Code Programs: Rapidly prototype with multiple source files.
• Implicitly Declared Classes & Enhanced Main Methods: Streamline application development.
• Updates on switch Expressions: We will discuss where we are with pattern matching as well as dealing with primitives
• I may also sneak in something about my never-ending love for SimpleWebServer.

Why Attend?
Learn how to advocate for and implement your organization's latest Java tools and practices. Gain the knowledge you need to sell the value of next-generation Java and stay at the forefront of software development.

In today’s data-driven world, the ability to process and analyze data in real time is no longer a luxury—it’s a necessity. Apache Flink, a powerful stream processing framework, has emerged as a game-changer for handling high-throughput, low-latency data applications.

In this session, you’ll gain a clear understanding of what Apache Flink is, how it works, and why it’s become a cornerstone for modern data infrastructure. We’ll explore key features such as its robust stream and batch processing capabilities, event-time handling, stateful computations, and fault tolerance. You’ll also discover how Flink integrates seamlessly with popular systems like Kafka, Kubernetes, and major cloud platforms.

Whether you’re working with real-time analytics, event-driven applications, or machine learning pipelines, Apache Flink provides the scalability and flexibility needed to turn massive streams of data into actionable insights. Join us to see why Flink is critical to modern data ecosystems and learn how to start leveraging its power in your projects.

In the realm of architecture, principles form the bedrock upon which innovative and enduring designs are crafted. This presentation delves into the core architectural principles that guide the creation of structures both functional and aesthetic. Exploring concepts such as balance, proportion, harmony, and sustainability, attendees will gain profound insights into the art and science of architectural design. Through real-world examples and practical applications, this session illuminates the transformative power of adhering to these principles, shaping not only buildings but entire environments. Join us as we unravel the secrets behind architectural mastery and the principles that define architectural brilliance.

Good architectural principles are fundamental guidelines or rules that inform the design and development of software systems, ensuring they are scalable, maintainable, and adaptable. Here are some key architectural principles that are generally considered valuable in software development:

• Modularity
• Simplicity
• Scalability
• Flexibility
• Reusability
• Maintainability
• Performance
• Security
• Testability
• Consistency
• Interoperability
• Evolutionary Design

Adhering to these architectural principles can lead to the development of robust, maintainable, and adaptable software systems that meet the needs of users and stakeholders effectively.

Modernizing legacy server-side web applications often feels daunting, especially when popular solutions like full rewrites with modern front-end frameworks tend to create more problems than they solve. The constant churn of JavaScript frameworks, dependency management, and endless updates not only introduce technical debt but also pull developers away from building the features that matter.

In this session, we’ll explore a different path forward with HTMX—a lightweight library that allows you to modernize your legacy MVC apps without a costly, time-consuming rewrite. With HTMX, you can introduce dynamic, modern behaviors into your existing app, eliminating the need for complex JavaScript frameworks while minimizing the technical debt that comes with them.

We’ll dive into practical examples of integrating HTMX into legacy systems to improve performance and user experience, all while keeping your app simple and manageable. You’ll learn how to avoid the endless cycle of framework updates and focus on what developers truly care about: delivering great features.

This session is perfect for developers tired of dealing with the complexity of modern front-end frameworks and those looking for a pragmatic, pain-free path to modernizing their legacy apps without getting bogged down by dependencies and rework.

In this session we will discuss what modular monoliths are, what they bring to the table, and how they offer a great middle ground between monoliths and distributed architectures like microservices.

Monoliths get a bad rep. Experienced software developers have seen one too many monoliths devolve into a big ball of mud, leaving everyone frustrated, with an itch to do a “rewrite”. But monoliths have their pros! They are usually simpler, easier to understand, and faster to build and debug.

On the other side of the spectrum you have microservices—that offer scale, both technically and organizationally, as well as having the badge of honor of being “the new cool kid on the block”. But productionizing microservices is HARD.

Why can't we have our cake and eat it too? Turns out, we can. In this session we will explore the modular monolith—all the upsides of a monolith with none of the downsides of distributed architectures. We'll see what it means to build a modular monolith, and how that differs from a traditional layered architecture. We will discuss how we can build architectural governance to ensure our modules remain decoupled. Finally we'll see how our modules can communicate with one another without violating modularity.

By the end of this session you'll walk away with a greater appreciation for the monolith, and see how you can leverage this within your system architecture.

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.

Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.

In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table. Examples include:

• Rebase and interactive rebase
• restore/switch and when to use them
• worktrees
• shallow-clones
• Git's filesystem monitor

By the end of this session, you will walk away with a slew of new tools in your arsenal, and a new perspective on how this can help you and your colleagues get the most out of Git.

Agentic AI is an exciting extension of the Large Language Model (LLM) and Retrieval Augmented Generation (RAG) models, but the capacity to make them interoperable is not going to happen on its own. The Agent Protocol is an OpenAPI-compatible specification for describing an API to interact with Agents implemented by a variety of participants. It provides a standard model for interacting with existing platforms and agents that have been deployed to them. The Model Context Protocol (MCP) has quickly gained attention and provides some additional capabilities for coordinating between agentic participants.

What else could we hope for? We'll talk about that too.

This talk will introduce these protocols, discuss existing and emerging implementations, and talk about next steps in the field of interoperable agent systems.

Agenda

• Introduction
• The Agent Protocol
• Model Context Protocol
• What Could Be