Software as Models
The end and beginning of computer software in the AI era
Nvidia CEO Jason Huang once said that generative AI is not only for the future but also for the past and present. He said this is because the systems/applications we created in the past and present need to be redone on top of the new generations of AI. I’m not sure how soon his words will become a reality, but I believe it’s worth pondering what software is becoming with generative AI.
Software as a Model
I think the software will paradigm shift to Software-as-Models (SaM). This is moving from software-as-code (or compiled code), which we’ve known for many years. Let me explain this thinking.
We used to compare software development with constructing a building to make the point that why software is “soft.” With software, we can continue to patch it, debug it, swap parts of it or reshape it, etc.. We always work on the software development cycle initiated by the famous phrase “user requirements” towards a critical milestone called “release,” and, the iteration cycles go on as the software lives. However, generative AI, or for now, the large language model (LLM), has changed the notion of softness. The software has become hardware.
When designing and developing a piece of software, we have a specification. This is down to each module, aka function or method, etc. If we do it 100% right (wishful but never in reality), the software should function exactly as we specified, no more, no less. Once the chunk of binary/scripting file (aka software) is shipped to our customer, it’s nothing different functionally from a piece of hardware you would buy from Home Depot. It does exactly what it’s designed for; otherwise, it has bugs. As with SaaS or other cloud computing-based systems, they merely distribute the code to different places to execute and provide various payment models. Fundamentally, they are the same old software.
An AI model is different. It has capabilities that can’t be specified as a functional bill-of-material (BOM, a manufacturing term for hardware production) . It does what you ask (prompt) for; the result could be correct (over time) but nondeterministic and occasionally illusional (for now).
When we think backward to find the root reason we have software or any computational tool, we see what our users really want is the result, not the means. If an AI model can give what the software does, then the software paradigm shifts.
When we look forward, how does the software we are working on today transition towards software as a model tomorrow?
Expertise as Data
To answer the question, we need to know why our customers buy our software. Software is a tool to help our customers do their jobs. A piece of software, either a small utility or extensive enterprise system (ERP, GIS, CRM, etc.), contains specific domain knowledge and expertise that our customers need and are willing to pay for. This domain expertise is hard-coded into the software using computer programming languages. Although we call those expertise algorithms in the context of software, they are piles of codes. An AI model, however, is trained (not coded) to gain the capabilities. All the code we’ve accumulated over the years, all the knowledge we’ve documented, all the use cases we’ve gathered, and so on are the training data. Hence, if we believe the software is becoming a capable AI model, we must start treading everything that makes up a software and support service as training data.
The accumulated deep domain expertise, the know-how of applying them gained over time, and the advanced ability to represent them in software is the moat for domain-specific technology enterprises, hence their business value. The critical aspect of AI is that it could reduce the time/duration elements mentioned above. Once it’s trained, it is capable. And the training doesn’t take too long. It’s a matter of who has the training data set and who does it. Hence, the traditional guardrail of niche businesses is seemingly becoming fragile in the AI age.
Another noticeable distinction between software and AI models is that no general do-it-all software exists. It’s just not feasible to achieve that. However, a general AI model, such as the large language model (LLM) or the emerging multi-mode model, is close enough to be a do-it-all, a characteristic of intelligence: generalization first and specialization later. This leads to the halo effect that comes with the creation of AI models, which could impact existing technology enterprises. As we’ve learned, the LLM models are tested/evaluated based on their ability to understand language and reasoning, take standard exams, solve mathematic problems, etc. Understanding and solving spatial problems is another factor for multi-mode models such as video generation. All these foundational capabilities could potentially be correlated to existing technology products and services, though the goal of AI is not targeting them.
Then comes the challenge and opportunity for the technology enterprise to preserve the gained expertise, transition it into data, build software as a model, and provide the customer with intelligent new value.
When we look at where we are, is there a pathway in that direction?
Autonomous Agents and Agent Workflow
To answer the above question, we must bring out a common pain point of using technology that has been taken for granted: the learning curve of using technical tools. There is a well-accepted “nature” in that a sophisticated technical tool can produce a wide variety of quality results depending on who uses it. Unlike art or another creative field, the technical driving business asks for consistency, efficiency, accuracy, and productivity from tools. AI can help reduce the variations caused by human operations between the tools and outcomes. Before reaching software-as-models, I think the means to level the gap is via Autonomous Agents and Agent Workflow.
The autonomous agents’ capability bridges the existing software infrastructure and GenAI. They help understand the users’ intentions, plan the workflow to get to the result, and organize and utilize the existing technical capability to produce the result. They provide a new and simplified user experience (UX) for using technological tools via expressing intention rather than clicking the right buttons. This UX-first approach will give the software room and time to evolve into the new AI era. Also noteworthy is that the agents’ operations will be the facility to transition the code-based expertise into data, which is the foundation of software-as-models.
We’re expecting much-accelerated evolution in the autonomous AI agent area while the number of LLMs is stabilized. This challenges the enterprise to adapt to the agent solution because the software developers are used to building things from the ground up, with good intentions of solid architecture, and it takes time. The “solid-ness” might be problematic for this rapidly changing field. Hence, the software engineering we’ve conducted for many years might also need a paradigm shift. But that’s another topic.
I’m optimistic about advancing technology and its benefit to us and our users’ lives. It’s never been so exciting to experience another turn of technology achievement. It should be a good ride.
