In a world without apps, engineers don’t disappear, they become the architects of intent, wiring agents to act with context and control.
The application is dying. Not all at once, and not in the way some might hope, but gradually, as its scaffolding erodes under the weight of systems it was never meant to carry.
This is the foundational tension in Alon Horev’s view of what comes next. As CTO of VAST Data, Horev isn’t waxing theoretical about the end of software as we know it. He’s watching its underpinnings shift in real time.
“We’re going to be in a post-applications world quite soon,” he says. Not post-software. Not post-code. But post-application: a future in which discrete, monolithic tools give way to composable agents. Think less standalone software glued to the rest of a codebase and more along the lines of model-aware processes that act, reason, and interface with infrastructure on their own terms.
We are already seeing the first traces of this. It’s what enables platforms to swap twenty overlapping microservices for a single vector-aware function. Or as Horev describes, in the real world, it’s what makes it possible to build a real-time traffic analysis system, not by writing an app, but by wiring together a few tightly scoped agents and letting them speak the language of inference.
But of course, iif the stack changes, so too must the people who build it.
And while the fashionable idea is that legions of software engineers are about to be replaced by LLMs and agents and more abstraction layer, Horev isn’t buying it. Not even close.
He sees a different future, where the role of the engineer is amplified, not erased. A future where “building software” no longer means shipping an app, but rather shaping the connective tissue that lets intelligent agents act responsibly and in context.
And so yes, the monolithic application is disappearing. But the engineers aren’t. They’re just working at a different layer now.
It will be less about building platforms and more along the lines of wiring intent to infrastructure.
If you're still picturing software engineers as people building user-facing apps in full-stack frameworks, you're already behind.
In Horev’s world, software engineers aren't building applications anymore. They’re building relationships. Not between users and GUIs, but between systems, services, and the agents that speak for them.
In one ongoing project with an APAC government, Horev’s team is helping build an agentic platform designed to support everything from traffic analysis to public safety. At its core is a video model that can describe what’s happening in any given clip: a car running a red light, a fire starting, a person falling.
“It doesn’t need a new app for each detection category,” he explains. “What it needs is a new agent…a function wired into that platform that knows what to look for, what to trigger, and who to notify.”
That’s where the engineers come in and stay in.
“They’re going to hire software people that are going to implement agents,” Horev explains. “But it’s not software engineers that are going to build infrastructure.” The heavy lifting–real-time ingestion, storage, retrieval, vector indexing–that all happens under the hood.
What remains for humans is the vital connective layer between models and consequences.
Think about what it takes to respond to an alert in real-time, he asks. Spot a fire? Someone has to decide how to notify the fire department. Through an API? A paging service? A citywide alarm? That isn’t a model’s decision. That’s not coming from a retrieval index. That’s a policy choice embedded in infrastructure and it has to be coded by a human who understands the system’s obligations.
One step further, the future isn’t app developers writing UIs for databases. It’s systems developers wiring identity, policy, data, and action together across stacks they didn’t build but are now responsible for steering. And the number of services involved (legacy SaaS, proprietary databases, embedded sensors, cloud-native microservices) hasn’t gone down. If anything, the stack is multiplying. The difference is that now it needs to move in real time, with AI-level awareness.
So the new job is not about writing applications. It’s about writing intent. Writing the glue that ensures the agents we invoke don’t just run, but run in the right direction.
The thing that no one wants to say out loud is that this “glue” is the product now.
For decades, integration was treated like an afterthought, but in an agentic world where models are interchangeable and every workflow is bespoke, the real complexity shifts to the seams. And that’s where the value moves, too.
Horev knows this because he’s watching it play out in the field. That APAC government project isn’t a PowerPoint fantasy, it’s a functioning testbed for what post-application architecture really looks like.
You want to scan license plates in real time and cross-reference them against a list of stolen vehicles? That’s not a pre-built app. That’s a persistent agent watching a stream and acting on a live query against a mutable database. You want to flag a suspect moving through restricted city zones? That’s geospatial inference fused to identity logic, woven together with policy gates and response automation.
And none of that exists off-the-shelf.
This is where the engineers reenter the picture, not to build the detection models, but to give them consequence. To connect the dots from vector search to civic action. To ask and answer the maddeningly human questions: What do we do with this information? Who needs to know? What should happen next?
And how do we do all of that without accidentally letting the wrong person see the wrong thing?
In a sense, what Horev’s describing is a new definition of software, not a product to be shipped, but an interface between real-world decision trees and machine-readable possibilities.
The engineer becomes less of a builder and more of a translator, someone who takes civic or commercial intent and encodes it into flows systems can act on.
And that’s not just glue, that’s architecture.
“We’re not going to replace all the enterprise systems in a year, and not in two,” he says. Not because the tech isn’t moving fast enough, but because humans, policies, and institutions don’t flip overnight.
The agentic future isn’t something you install. It’s something you bridge to. And bridges need builders.
For the foreseeable future, software engineers will live in that in-between point….writing applications that don’t just showcase AI, but that reconcile it with a deeply imperfect ecosystem of legacy systems, siloed permissions, regulatory constraints, and fractured data. They’ll build tools that operate at the edge of what’s possible, precisely because what’s possible is changing every six months.
The biggest mistake an enterprise can make right now is assuming that infrastructure alone gets you to AI.
Horev is explicit about this: if you want agents that can reason across your business, act in real time, and respect the boundaries of what should and shouldn’t be seen or done, then someone has to write that logic.
Someone has to wire the data, enforce the rules, and understand what the hell is actually supposed to happen when a model says “fire detected on level four.”
You can’t buy your way out of that but you can staff for it.
So yes, the future is arriving faster than expected. But no, that doesn’t mean fewer people. It means smarter systems, and more responsibility for the ones still writing the code behind them.