Enterprise AI Strategy: Java, Determinism, and Agent Control
Rod Johnson argues against the Python-centric AI narrative, advocating for Java-based enterprise AI integration. He details the Embabel framework's use of deterministic GOAP planning to ensure explainability and control in agentic workflows, challenging the 'vibe coding' approach.
The End of the Python-Only AI Narrative
A prevailing misconception in the industry is that Python is the mandatory language for AI development. Rod Johnson, creator of Spring and CEO of Embabel, argues this is "completely nonsensical" for enterprise applications. Since Large Language Models (LLMs) operate via simple HTTP calls, the host language does not dictate inference performance. The critical factor is adjacency: enterprise business logic, domain models, and existing services are predominantly built in Java. Rewriting these in Python to access AI capabilities introduces significant risk and maintenance overhead without technical benefit. The strategic imperative is to integrate AI into existing Java stacks, leveraging frameworks like Embabel that bridge the gap between JVM applications and LLM capabilities seamlessly.
Determinism as a Core Enterprise Requirement
A major failure mode in current AI adoption is the "alien stack" problem, where AI teams disconnected from core business logic drive strategy. This often results in non-deterministic, unpredictable agent behavior that is unacceptable for business processes. Embabel addresses this by implementing Goal-Oriented Action Planning (GOAP), a deterministic pathfinding algorithm originally used in gaming. Unlike LLM-driven planning, GOAP uses type systems and preconditions to ensure actions are executed in a valid, explainable order. This allows enterprises to maintain audit trails, ensure consistency, and right-size LLM invocations by using smaller, more focused prompts for specific steps rather than massive, unpredictable agentic loops.
The Developer's Role in the Agentic Era
As coding agents generate the majority of code, the developer's role shifts from typing syntax to architectural oversight. Johnson emphasizes that "vibe coding" is acceptable for disposable UIs but dangerous for serious software. Developers must retain deep understanding of the architecture to correct agent errors and prevent design degradation. The most effective workflow involves using agents for speed and volume while the human provides the strategic direction and quality control. This hybrid approach yields higher quality and faster results than either humans or agents working alone.
Strategic Implications for Leaders
Organizations must move away from blanket mandates to "AI all the things." Instead, they should identify specific, high-value use cases where deterministic logic is insufficient, such as complex form processing or natural language understanding. By starting with small, measurable wins and building confidence, enterprises can integrate AI effectively without compromising system stability. The future of enterprise AI lies not in replacing existing stacks, but in enhancing them with deterministic, controllable, and explainable agentic frameworks.
Key insights
-
LLM inference is a network call, not a local computation, rendering the host language irrelevant for AI performance. Enterprise Java stacks should remain the primary integration point for AI features.
Impact: Prevents costly and risky rewrites of core business logic, allowing enterprises to leverage existing investments while adopting AI.
-
Deterministic planning algorithms like GOAP provide superior control and explainability compared to LLM-driven agentic loops for business process automation.
Impact: Ensures compliance, auditability, and reliability in critical business workflows, reducing the risk of unpredictable agent behavior.
-
The "alien stack" problem arises when AI teams lack understanding of core business applications, leading to misaligned strategy and integration failures.
Impact: Highlights the need for cross-functional collaboration between AI and core engineering teams to ensure AI initiatives align with business reality.
-
Developers must maintain architectural oversight of AI-generated code to prevent design degradation and technical debt in complex systems.
Impact: Ensures long-term maintainability and quality of codebases, preventing the "mess" that results from unchecked agentic coding.
-
Model Context Protocol (MCP) is useful but not a universal solution; direct exposure of native methods as tools is often more efficient and type-safe.
Impact: Encourages pragmatic tooling choices that prioritize developer experience and system integration over adopting new standards for their own sake.
Action items
-
Audit existing enterprise applications to identify high-value AI use cases where deterministic logic is insufficient, starting with small, measurable wins.
Impact: Builds confidence and demonstrates ROI without disrupting core systems, creating a foundation for broader AI adoption.
-
Implement deterministic planning frameworks, such as GOAP, for business process automation to ensure explainability and control.
Impact: Reduces the risk of unpredictable agent behavior and ensures compliance with business rules and audit requirements.
-
Train developers to focus on architectural oversight and quality control of AI-generated code, rather than manual syntax writing.
Impact: Improves code quality and maintainability by leveraging the speed of agents while retaining human strategic control.
-
Evaluate the need for MCP in your stack; prefer direct exposure of native methods as tools when possible to simplify integration.
Impact: Reduces complexity and improves type safety, leading to more robust and maintainable AI integrations.
-
Establish a professional maintenance model for open-source frameworks, ensuring critical fixes and robustness through paid, full-time developers.
Impact: Ensures the reliability and longevity of critical infrastructure, reducing the risk of security vulnerabilities and performance issues.
Quotes
“The LLM is not running in your Python process. The universe would end before Python could execute inference. So the LLM is a very, very simple HTTP call away.”
“I think one of the major anti-patterns is this idea of we must use more AI without like, why? What for? Because much as I love and am fascinated by AI, if you can do any single thing without using an LLM, well, of course you do it without using an LLM.”
“I do believe that you can vibe code things like, you know, some classes of UI apps, sure, they're disposable anyway. agents are very, very good at that. You cannot vibe code serious software.”