KotlinConf 2026: When Type Safety Meets Intelligent Systems

What happens when a language built on clarity and reliability meets a setting driven by AI and speed?

At this year’s KotlinConf, one thing became clear: the future is not about choosing between structure and intelligence, but about bringing both together.

Our MB.ioneers Renato Rosa, Ricardo Mano, and Pedro Henriques joined the global Kotlin community and returned with a shared perspective: Kotlin is evolving quickly, and many of the practices we are already embracing are aligned with where the ecosystem is heading.

From “AI is messy” to “AI you can trust”

For Renato, one talk stood out, not because it introduced something flashy, but because it challenged a deeply rooted assumption:

It challenged my assumption that AI is inherently unstructured and unreliable.

What he saw instead was a different approach where AI agents are built with rules, permission hierarchies, and type-safe structures, designed for real production environments, not just demos.

It suggests that AI doesn’t have to be unpredictable. With the right engineering principles, it can become something structured, reliable, and scalable, something that fits naturally into modern software systems. And Kotlin plays a big role here.

Kotlin’s null-safety and type system can be leveraged to make invalid states impossible to represent in code.

Instead of catching errors at runtime, Kotlin moves logic enforcement into the language itself, turning the compiler into a safety net. For a world increasingly driven by AI, this kind of foundation is more relevant than ever.

Koog, AI agents, and a familiar name on stage

What was a recurring theme across the conference? AI, but not just as a buzzword.

Ricardo highlights how quickly things are moving:

Many sessions focused on AI, and I saw several demos showing how quickly you can spin up agents and MCP servers in Kotlin, often in just a few minutes.

One specific project kept coming up: Koog, JetBrains’ AI agent framework.

And here’s where it gets interesting. Our MB.ioneers weren’t just learning about it, they saw Mercedes-Benz.io mentioned in the opening keynote as a real-world example of using Koog to build something meaningful.

For Renato, that moment stood out:

It was striking to see Mercedes-Benz.io highlighted… This validates our direction in a world where everyone competes to be a front-runner.

It’s not just about experimenting with emerging technologies, but about applying them in ways that align with business logic, constraints, and real product needs. Beyond AI, another clear signal stood out: the momentum of the Kotlin ecosystem. With new tools and evolving language features, Kotlin continues to grow in step with the needs of modern development.

Ricardo points to a few highlights:

• Kotlin-first tools designed for today’s developer needs
• Strong momentum around multiplatform development
• Increasing focus on ergonomic, developer-friendly improvements

One tool he’s especially curious about is TestBalloon, a Kotlin-native testing framework built with coroutines and parallel execution in mind, a potential shift away from legacy JVM-first approaches.

There was also a strong focus on AI-for-AI patterns, where agents evaluate and improve the output of other agents, this may be a simple idea yet it quality and consistency in generated content.

What does this mean for us?

For Pedro, KotlinConf wasn’t about a single “aha” moment, but brought a certainty equally valuable, a confirmation on what’s being done.

The conference provided validation that we’re already aligned with modern best practices.

From multiplatform to tooling to developer experience, many of the ideas discussed weren’t new, yet they helped connect dots and reinforce the direction teams are already taking internally.

Sometimes, the biggest takeaway isn’t learning something entirely new, it’s realising you’re on the right path. And beyond the talks, there was something just as important: people.

One of the most valuable aspects of the conference was networking with peers… listening to challenges and solutions other teams are facing was inspiring.

Across all three perspectives, a pattern emerges:

• Type safety and structured systems matter more than ever
• AI is becoming practical, not just experimental
• Our current direction is not only relevant, but validated
• There’s still room to explore, experiment, and evolve

Kotlin it’s evolving in a direction that aligns with how we already think about software: structured, scalable, and increasingly intelligent.

If we had to sum it up in one line? The future isn’t just AI-first, it’s AI, built right.