Your AI Agent Demo Was Great. Production Is a Different Job.

Bucharest Tech Week
2 days ago
5 min read

Ask a team that's six weeks into building an AI agent what's hard, and they'll talk about prompts, which model to call, which RAG setup to use. Ask the same team eight months later, after the demo has to survive real users, real edge cases, and a compliance review, and you'll get a completely different answer.

Nobody complains about the model anymore. They complain about everything around it.

That gap between “we built an agent” and “we run an agent in production” is where most of the industry's AI budget is quietly disappearing right now. It's also the real subject underneath one of the sharper technical talks at Bucharest Tech Week 2026, Yuriy Bezsonov's session on building production-grade agents in Java. Not because his talk was a warning story. Because it happened to be a working demonstration of exactly what the data below is about to say.

The pattern he showed matches what the data is now confirming everywhere else.

MIT's Media Lab, working with what's since become known as the “GenAI Divide” report (August 2025), found that 95% of generative AI pilots inside companies delivered no measurable P&L impact. Only 5% of the systems studied created real, trackable value. The dividing line wasn't the model quality or the size of the budget. It was integration: the 5% that worked were built into existing workflows, with tools that could learn and adapt, usually sourced from specialized vendors rather than built as one-off internal experiments.

Gartner reached a similar conclusion from a different angle. Their June 2025 forecast puts the number at over 40% of agentic AI projects abandoned by the end of 2027, and names the reasons plainly: escalating costs, unclear business value, and inadequate risk controls. As Gartner analyst Anushree Verma put it, most agentic AI work right now is “early stage experiments or proof of concepts that are mostly driven by hype,” and that hype “can blind organizations to the real cost and complexity of deploying AI agents at scale, stalling projects from moving into production.”

Cost and complexity. Not the model. That's the part almost nobody budgets for.

Yuriy said the same thing, just from inside the build, not from a research report.

In the written interview he gave us ahead of the event, he was direct about it:

“Everyone's focused on the model, which LLM, which prompt, which RAG strategy. But the hard part in production is everything around the model: how agents coordinate, how you trace decisions across multi-step workflows, how you handle failures, and how you maintain guardrails at scale.”

From reviewing proof-of-concept architectures and supporting large enterprise migrations, his read is blunt:

“A demo agent is easy. A production agent that handles edge cases, respects compliance, and can be debugged when it goes wrong, that's a different problem.”

Across the demos he walked through, that meant starting from an empty Java application and treating every new piece, memory, retrieval, live tools, access to existing enterprise systems, as infrastructure to be added on purpose, not as something a bigger model would eventually hand you for free. The pattern under all of it: nothing on that list was about picking a smarter LLM. Every single addition was about giving the agent a way to behave reliably outside a controlled demo.

The clearest version of that argument shows up the moment an organization moves from one agent to several of them at once. That's the 90 seconds worth pulling out of the full talk on its own:

“I felt myself like in the Wild West with MCP. Everyone is downloading different MCP servers, installing them on their own machine, and trying to do something with them. It's a nightmare for enterprise, it's a nightmare for security. We need a central point, an agent gateway, to work with all of those MCP servers instead.”

https://youtu.be/1L955STyXSg?si=HNGCN4nR6xLVgNSk

That's the Gartner finding in miniature. “Escalating costs, unclear business value, inadequate risk controls” isn't abstract when it's a hundred different MCP servers with overlapping tool names and nobody accountable for any of them. The fix Yuriy pointed to wasn't a bigger model either: a central gateway in front of every MCP server, plus semantic search over tools so an agent only ever sees the small subset relevant to the job at hand. An infrastructure decision, not a prompting trick.

It's also, in his telling, why Java has quietly become a serious agent-building language rather than a legacy one to work around, which lines up with where enterprises are actually putting their production AI workloads. Azul's 2026 State of Java Survey (2,039 enterprise respondents) found that 62% of enterprises now use Java to power AI functionality in production, and in nearly a third of them, more than half of their Java codebase already contains AI logic. “Modern Java is not the Java people remember from 2010,” as Yuriy put it, and the reasoning behind that claim tracks the same divide MIT and Gartner are describing: “building agents isn't building models. It's orchestrating them, integrating them into business workflows, and operating them at scale.” Orchestration, type safety, mature concurrency, and mature clients for every enterprise system already in place, that's the terrain Java was built for, long before agents existed.

So where does this go next?

If the operational layer is where the real work is, expect the next eighteen months to be less about which foundation model wins and more about the plumbing around it: agent observability and tracing becoming a standard line item rather than an afterthought, gateways and governance for MCP maturing the same way API management did a decade ago, and evaluation pipelines that catch quality drift before a customer does. One detail from the talk points at where this is heading next: agent-to-agent payments are starting to happen using HTTP status code 402, a code written in the early 1990s and never used for thirty years, now being pulled off the shelf because agents transacting with other agents is no longer hypothetical.

None of that is a reason to slow down on agentic AI. It's a reason to budget for the boring parts on purpose, before a pilot stalls out for exactly the reasons Gartner and MIT already measured.

This is exactly the kind of applied, no-hype conversation the Business Summits stage exists for, engineers talking about what actually breaks in production, not what a vendor slide claims will. So we'll turn the question back to the people building this right now: which part of “everything around the model” is your team still underestimating, memory, evaluation, tool governance, something else? Tell us in the comments, we're taking notes for what gets on stage next.