IntelliJ IDEA
Conf 2026

Tired of treating AI like a black-box REST endpoint? What if you could own the stack – shape the tensors, steer memory, and pick execution providers?

In this session, we make that shift. Today, with JDK 25, you can wire real models – LLMs, image classifiers, or object detection algorithms – straight from Java via the Foreign Function and Memory API to call native runtimes like ONNX for fast CPU/GPU inference. You will learn how to map tensor buffers to Java MemorySegment and flip execution providers, all from the comfort of a Java application. Then you will push further with Project Babylon’s Code Reflection, expressing model logic as Java code that Babylon can analyze and lower to accelerator backends, skipping external model files or the need for a glue language.

Build expressive and testable FFM-based inference today and author pure Java AI-ready models with Code Reflection tomorrow!

AI coding agents are powerful, but they often feel unpredictable. Without structure, they can jump into implementation, miss requirements, or generate code you can’t easily track. Spec-driven development is a practical approach that brings order to this process.

The method is simple: start with clear, high-level requirements, refine them into a detailed development plan, then break that plan into a task list with trackable steps. The AI agent works from these artifacts – requirements.md, plan.md, and tasks.md – instead of ad-hoc prompts. Each step becomes explicit, reviewable, and repeatable.

In this talk, I’ll show how to apply spec-driven development and explain my intuition for this approach. We’ll walk through an example, documenting requirements, generating a plan, creating tasks, and guiding the AI through execution one step at a time. Along the way, you’ll see techniques for controlling workflows, reviewing changes, and avoiding “black-box” code generation.

If you’ve tried coding with AI tools but found them chaotic, this session will give you a framework to make them reliable partners.

Agentic AI coding assistants offer powerful capabilities, but they also introduce significant security risks. Granting them unsupervised access is not a viable option, yet overly restricting them stifles their potential. This session addresses this critical dilemma by proposing a new security primitive: Docker sandboxes.

We will explore a practical framework for encapsulating AI agents within containerized, isolated worlds. Learn how this approach provides a known security profile, an intuitive setup, and a reliable boundary. We'll discuss the design principles needed to safely embrace the "infinite monkey" nature of AI assistants, ensuring that while they are free to work, any potential havoc remains localized and controlled.

Let’s abuse the tools! Everyone knows Quarkus is computationally efficient, expressive, and rock-solid for production. But did you know that we can use Quarkus efficiency to build applications that shouldn’t go anywhere *near* production?

In this demo-driven session, Holly will put the joy into “developer joy”. She’ll show you all sorts of things you can do with Quarkus that you probably shouldn’t:

- Build an LLM-powered app that’s *guaranteed* to hallucinate, because you can do more than you think with guardrails, and truth is so boring

- Write your business code in rockstarlang, because everything should be a hair metal ballad

- Use Minecraft as your observability client, because the LGTM stack doesn’t have enough explosions

- Write a CLI for generating memes faster, because everything is better on the command-line

- Benchmark an application against a grapefruit, because metric units aren’t tasty

Business value? Learning? If you insist. As well as absurd demos, you’ll leave this session with a deeper understanding of how to get the most out of Quarkus and Java. There will be new Java 25 language features, Quarkus best practices, powerful integrations, and nifty use cases alongside the silly explosions and grapefruit.

Speaker and topic to be announced soon

Can Java build a real AI agent — one that manages your calendar, reads your email, orders pizza, and remembers who you are across sessions? OpenClaw, the personal AI agent with 350K GitHub stars, proves the concept. We're going to build it twice, in Java, live on stage.

Baruch brings JetBrains Koog, Viktor brings LangChain4j. Same features, same LLM, completely different philosophies. We'll run six competitive rounds of coding, from basic agent setup through memory, tool calling, agentic workflows, guardrails, and observability. Each round surfaces a design disagreement: should memory be an Advisor or a Provider? Are agents composed services or first-class citizens? And when your guardrail framework and the model disagree, who wins?

The frameworks disagree on how AI agents should be built. The audience votes on who's right.

Over the last 30 years, Java has been the preferred technology for developing enterprise applications. Frameworks and approaches such as J2EE, Spring Framework, Java EE, Spring Boot, and Jakarta EE all contribute to this success story.

The Jakarta EE 11, with features for increasing performance and developer productivity, such as support for virtual threads and the new Jakarta Data specification.

This session will give you a history lesson of Enterprise Java as well as an overview of everything brought to you by Jakarta EE 11, with lots of code demos. We will also look forward and check out what's in the pipeline for Jakarta EE 12 and how enterprises can cope with the ever increasing presence of AI.

AI coding agents have reached a point where they can meaningfully participate in real software development workflows, particularly in large and complex Java codebases, handling tasks such as issue classification, pull request merging, and increasing test coverage. In this talk, Mark shares his practical experience automating these workflows using autonomous agents, based on work carried out in real repositories and integrated into everyday development practice.

This talk gives you an introduction to Spring AI Agents and Spring AI Bench, two complementary projects from the Spring AI Community. Spring AI Agents provides a portable abstraction for running CLI-based coding agents – shifting from using Spring AI's ChatClient for chat completions to using AgentClient for achieving goals. AgentClient wraps any agent CLI through a single interface, using explicit goals, tools, context, and a built-in judge framework to trust but verify agent behavior. Combined with the Agent Context Protocol (ACP), this establishes a consistent client and wire-level integration model across tools and environments. Spring AI Bench applies the same framework to evaluate how effectively agents complete concrete, goal-directed development tasks.

Finally, Mark reflects briefly on what it means to develop these systems in an AI-first manner. Spring AI Agents and Spring AI Bench were themselves built with significant assistance from coding agents, offering practical insight into how agents behave as collaborators rather than tools, and where clear structure, evaluation, and feedback loops become essential to making agent-driven development reliable and repeatable.

AI agents often need to execute code, load user-provided logic, or call tools based on untrusted input.

This creates a hard systems problem: how do we give the agent useful capabilities without giving it direct access to the host process or large amounts of data?

The sandboxing capabilities of GraalVM via its Truffle language implementation framework provide a practical architecture for running agent code with explicit host APIs, separate guest execution, bounded resources, and clear failure modes. It even allows the agent to be useful without having access to the actual underlying data, but rather only knowing about the APIs that can access that data.

Two speakers, multiple AI coding agents, real IoT hardware, and a bet: the context you give your agent matters more than which agent you pick.

Live on stage, starting from an empty directory: control IoT devices, build a face recognition pipeline, and drive physical hardware as a real-time visual feedback system with real devices reacting to code written by AI in real time.

The easy parts work fine, but then the hardware and the API disagree about something the documentation doesn't mention, both agents produce code that runs, passes every check, and is completely wrong. We change what the agent knows (using spec-driven development, intent integrity chains, and structured context engineering) and the audience sees exactly what that fixes, what it breaks next, and how the every next failure is worse than the first.

Are you tired of watching Maven builds crawl at a snail's pace, wasting precious development time? Spending too much time at the coffee machine, or having wooden sword fights, with the excuse "my code is compiling"?

Join me to learn how to supercharge your Maven builds! I’ll cover three main steps to start speeding up your project build and learn how each speeds up your build, when they provide the biggest gains, and what pitfalls await.

Take the next step in boosting your developer productivity by learning practical tips to decrease context switching and increase development speed and the feedback cycle. Your journey from a snail's pace to rocket speed begins today!

When you master your tools, they stop being “just an IDE and a framework” and start working like extra hands on your project. Spring Boot streamlines application development, while IntelliJ IDEA takes that productivity and amplifies it with inspections, navigation, refactorings, and Spring-aware debugging.

In this session, Spring Developer Advocate Josh Long will walk you through real-world workflows that show how these tools work together – from project setup and configuration to troubleshooting tricky runtime issues.

You’ll leave with practical tips you can apply immediately to ship features faster and with more confidence.