AI is advancing at breakneck speed—from basic rule-based systems to autonomous agents. Over 240,000 AI papers are published annually, with 1.8M+ projects on GitHub and 80+ large language models released in 2024 alone. Forecast AI spend is expected to top $632B by 2028. Amid the hype, the focus must be on delivering real value and preparing for what’s next.
AI is Changing Everyday Life
AI is incredibly versatile, transforming industries and even our everyday lives. There is a lot of hope and a lot of nervousness around what it can enable and what it could potentially do. Now that generative AI is in the hands of anyone with an internet connection and a device, the opportunities and the risks have become so much more tangible and so much more understandable by everyone who uses it. AI may feel magical—like stepping into a self-driving taxi—but once embedded, it becomes mundane, like real-time GPS navigation.
Today organisations are rapidly integrating AI into their operational practices – with objectives ranging from cost optimization to industry disruption by redesigning entire workflows – and into their digital products as AI capabilities become an expected component of any digital application. Hence, modern applications are now expected to be AI-native.
AI-Native Applications: The Next Evolution in Software Development
We are seeing a fundamental shift in how software is written and in what the building blocks and abstractions to build it are. This shift towards AI-native applications is reminiscent of the shift of how Service Oriented Computing, the internet, and the cloud have transformed software development in the last twenty years. APIs revolutionised the way applications were built by enabling seamless interactions between different services, making software more modular, scalable, and interconnected. Before the standards emerged that let us interact with remote APIs seamlessly, developers had to build such functionalities from scratch – if even possible – leading to brittle applications that were difficult to support.
Similarly, the need to build AI-native applications is changing the way software is built by embedding AI as a foundational element rather than an add-on feature. These applications are designed with AI at their core, leveraging machine learning models, automation, and intelligent decision-making from the outset. Just as APIs have become fundamental building blocks of modern applications, AI capabilities are now at the center—powering tasks like contextual reasoning, multimodal interaction, and predictive analytics.
AI is useless alone. It comes to life when integrated into your data, your APIs, your enterprise computing fabric and architecture. Foundation models have shifted the burden of creating and running AI native applications farther from core algorithms and closer to strong integration and distributed systems capabilities.
We see this change happening along three related but distinct axes:
- AI for Code: Embedded AI boosts productivity across the dev lifecycle—from requirements to deployment.
- Code for AI: New building blocks are emerging to support building AI-native applications throughout the tech stack.
- Natural Programming: Programs have become a hybrid blend of deterministic code with vague human modalities like language, images, and speech.
Bringing AI into the fold: From Automation to Autonomy
A key challenge in today’s landscape is the broad and often ambiguous use of the term “AI” and its derivatives. AI-native applications can be understood as those that embed generative AI in meaningful ways, ranging from basic features like text summarization, to more advanced use cases like contextual retrieval-augmented generation (RAG) grounded in domain-specific data, to intelligent agents that can reason and act, and ultimately, operate autonomously. Supporting this full spectrum within enterprise architecture—from lightweight enhancements to fully autonomous systems—requires a thoughtful, integrated approach rather than treating AI as an afterthought or add-on.
AI systems will likely not do the same thing given the same input twice due to their nondeterministic nature. Unlike traditional software, failures often cannot be fixed by simply changing a few lines of code. Safely embedding AI at scale is necessitating changes to the development lifecycle. We see a significant shift from traditional ‘testing’ to continuous AI ‘eval’,’ and an accompanying shift in effort from development to quality.
Applications are evolving to be a blend of deterministic code and non-deterministic AI, and we are evolving the tools to build them that offer better ways to naturally program this hybrid blend. As the focus moves to advanced, agentic AI systems, new considerations are emerging for governance, management and trust.
Adoption and the Rubric for Responsible AI
Mistakes, hacks, hallucinations and misuse have shown AI’s vulnerabilities. There is understandably much concern about AI safety. A path forward is twofold: to learn how to adopt AI responsibly and to focus on valuable use cases where its shortcomings can be either mitigated or tolerated. We refer to the Decoding Trust rubric for responsible AI as a strong framework and in-depth explanation of current risks and opportunities.
This ‘cost of being wrong’ is a good litmus test for deciding where to deploy such solutions. Consider an analogy from the early days of cloud computing, when reliability was still low. The advice was that deploying a movie streaming service to the cloud made sense because, in the worst case, your movie skips a few frames. However, core banking systems were advised to wait because a glitch could cause the loss of a substantial amount of money.
Two questions many organisations are grappling with is how to handle the nondeterministic nature of AI’s generated responses and where to lay the blame when it gets things wrong. AI’s nature necessitates new evaluation methods to ensure reliability and accountability. What we are seeing is that using AI itself to evaluate AI responses has emerged as a new approach to assess performance beyond traditional accuracy metrics. “LLM as a judge” methods—where models evaluate each other—are helping assess AI reliability beyond accuracy metrics. Still, human oversight remains critical.
Moving Forward
AI’s ongoing evolution reflects decades of efforts to improve human-computer interaction.
Without a doubt, AI needs management and guardrails, awareness of its current limitations, and a software stack that natively supports its development. Practices include request-response mediation, data quality checks, and user interaction monitoring – all of which are becoming increasingly important. Using multiple AI models is being explored, where one model generates responses and another judges them. However, natural language remains too ambiguous for every application, making a case for supporting a combination of natural language and deterministic logic in code. Organisations are still determining AI performance KPIs and exactly how to measure return on investment, but enterprise tools are increasingly beginning to quantify AI’s value.
With all this change, a question is often whether to wait until more of the weaknesses are addressed or proceed? Our answer is to wholeheartedly go ahead – with eyes open.
Ultimately, AI is improving software development and enabling AI-native applications, balancing human oversight with new automation capabilities. This stage of AIs evolution will continue to rapidly transform so much around us. In fact, according to Satya Nadella, Chairman and CEO of Microsoft: “More so than any previous platform shift, every layer of the application stack will be impacted… Thirty years of change is being compressed into three years.”
AI-native applications blend generative power with traditional code—focused on usability, trust, and scale. The future of software is AI built-in, not bolted on.
