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.

AI is accelerating code and test creation, leading to larger changes and rapidly expanding codebases. This growth, however, intensifies the complexities of troubleshooting.

To keep up with AI, we need faster feedback cycles, as well as actionable insights. Inspired by DORA, we measure this with Developer-local or CI-local Time To Restore (TTR), for a failing local or CI build, respectively.

Only AI-powered troubleshooting can help streamline AI-powered development, and what better place to observe and troubleshoot builds and tests than inside your IDE, like IntelliJ IDEA or Android Studio?

In this presentation, we'll explore the use of the free Develocity IntelliJ plugin and Develocity’s AI features for rapidly troubleshooting failures and performance issues within the comfort of your IDE.

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.

This session will demonstrate how GraalVM enables multiple programming languages to run and interoperate within a single, secure, and high-performance runtime. It will highlight practical use cases such as adding flexible scripting to JVM-based applications, safely executing AI-generated code in a sandboxed environment, and building unified data-processing pipelines that combine the strengths of both the Python and JVM ecosystems in one application. The session will also show how IntelliJ IDEA’s enhanced polyglot tooling streamlines development, debugging, and navigation across mixed-language projects.

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.