Eclipse Theia 1.72 Shows What AI-Native IDEs Really Need Next

The latest Eclipse Theia release isn’t the kind of announcement that arrives with fireworks, sweeping claims, or a promise to reinvent software development by lunchtime. That’s probably a good thing.

Version 1.72, announced by EclipseSource on June 15, is a practical release. But for those of us watching the evolution of AI-native development environments, it’s also a revealing one. The work here isn’t just about adding another chat panel to an IDE. It’s about making the underlying development platform faster, safer, more extensible, and better suited to the way real-world software projects are organized.

Theia, hosted at the Eclipse Foundation, is both an IDE and a platform for building custom cloud and desktop development tools. That second part is important. Theia isn’t only competing for end users. It’s also used by teams and vendors that want to build their own tailored, domain-specific, or white-labeled development environments.

That makes the 1.72 release especially relevant for enterprise development teams. The most obvious improvement is build performance. EclipseSource says Theia 1.72 adds esbuild as an alternative bundler to webpack for browser, browser-only, and Electron applications. In its measurements, full build time dropped from roughly 20 seconds to about 2 seconds, a tenfold improvement.

That may sound like plumbing, but plumbing matters. If you’re maintaining a custom IDE, every build, rebuild, integration test, and packaging cycle affects developer velocity. Faster builds don’t make a tool smarter, but they make the people building and customizing the tool faster. For organizations investing in tailored developer platforms, that’s not a small thing.

The more interesting part, at least for readers of this column, is what Theia 1.72 does with AI agents.

AI agents in Theia can now operate properly across multi-root workspaces. Previously, agent actions such as file access, task lookup, launch configurations, and command execution were effectively scoped to the first workspace root. In 1.72, agents can see and address all roots using a clearer root-name and relative-path convention.

That’s a meaningful change because enterprise codebases are rarely tidy, single-folder affairs. A modern workspace may include several repositories, shared libraries, generated artifacts, documentation, service definitions, test harnesses, and deployment code. If an AI coding agent can’t understand that broader workspace structure, it’s going to feel impressive in a demo and frustrating in production.

The release also introduces a new Fast model alias for simpler agent tasks. The idea is straightforward: not every AI-assisted IDE operation needs a heavyweight reasoning model. Some tasks, such as exploration, project information lookup, command help, and chat-session naming, can often be handled by faster, cheaper models.

That’s a small architectural decision with larger implications. Enterprise AI development tools will need model routing, not just model access. Some coding tasks may justify a more capable model. Others won’t. If AI-native IDEs call the largest model for every small action, they’ll be slower and more expensive than necessary.

Theia 1.72 also tightens the default posture around tool use. The default for new tool confirmation has changed from "auto-allow" to "confirm." Newly added tools that an agent uses will ask for confirmation unless the user explicitly opts in to automatic approval.

That’s exactly the kind of change AI coding environments need more of. As agents gain the ability to inspect files, run commands, use external tools, and interact with developer environments, the old IDE security model starts to look insufficient. A smart assistant that can act on your behalf is useful. A smart assistant that can act too freely is a risk.

The release adds another boundary mechanism: allowed external paths for read-only AI tools. By default, Theia keeps AI tools scoped to the workspace. In 1.72, users can allow read-only access to specific paths outside the workspace, such as a documentation folder or a generated artifact tree. Write tools remain workspace-scoped.

Again, this isn’t a flashy feature, but it’s the right kind of feature. Developers often need AI tools to see context outside the active repo. At the same time, enterprises need clear limits on what an agent can read and write. Theia’s approach recognizes both needs.

There are also compatibility improvements. EclipseSource says Theia 1.72 improves support for Visual Studio Code extensions, including ESM extension support, and adds command-line support for attaching to running containers. Those details matter because Theia’s value proposition has long depended on being open and vendor-neutral while remaining compatible with the broader VS Code extension ecosystem, including extensions distributed through Open VSX.

The broader story here is that AI-native IDEs are entering a more mature phase. The first phase focused on proving that AI could write, explain, and modify code within a development environment. The next phase is about making those capabilities governable, economical, and useful in the complicated environments where software is actually built.

That means agents need to understand multi-root workspaces. They need confirmation flows. They need scoped permissions. They need access to outside context without unlimited access to the file system. They need cheaper model routing for simple subtasks. They need extension compatibility, container support, and faster platform builds.

In other words, they need the boring stuff.

That’s why Theia 1.72 is worth watching. It isn’t trying to win attention with a new AI coding mascot or another sweeping claim about replacing developers. It’s doing the less glamorous work of making AI-assisted development fit better into the IDE as a platform.

For enterprises, that may be the real test of AI coding tools. The winners won’t simply be the tools that generate the most impressive snippet in a benchmark. They’ll be the tools that can be embedded in real workflows, governed by real policies, tuned for real cost constraints, and trusted by real development teams.

Theia 1.72 is a reminder that AI-native development isn’t just about smarter models. It’s also about the architecture around those models. And in developer tooling, architecture still matters.

Posted by John K. Waters on June 23, 2026