Listen to the latest articles and insights from our experts.
Listen to the latest articles and insights from our experts.
When OpenAI launched ChatGPT v3 in late-2022, it heralded a new paradigm shift in modern computing, one that was seemingly accessible to non-technical users: Responses to plain text requests — written in realistic, personalized language — delivered in a matter of seconds. Seemingly overnight, this new Large Language Model (LLM) promised to change the way we interact with the digital world: everyone from students crafting term papers to salespeople composing email pitches to software engineers generating code.
But despite all the hype, the major growth in OpenAI usage appears to be through Microsoft partner products like Bing AI and Office Copilot. That reflects two notable realities:
- There’s both genuine business interest and commercial potential for Generative AI (GenAI) specifically and LLMs more generally among enterprise customers.
- LLMs can only provide significant value to these organizations when they are combined with other applications (in a secure, private, and scalable manner), rather than when they are used independently.
Like all other software tools, an LLM is only as useful as how well it’s implemented.
(Note that certain GenAI models are capable of working with not just language/text but also images, audio, video, and other modalities, systems known as Large Multimodal Models (LMM). This article will refer mainly to LLMs, but the principles can be extended to LMMs as well.)
For an enterprise organization to introduce LLMs in a way that adds value, it must create a system with two main components:
- The LLM, which is an Implicit program that runs behind the scenes in response to an intent-based query. The LLM interprets written queries (“prompts”) and provides human-like, personalized written responses based on its analysis of a significant volume of text.
- An Explicit program that defines the proper context and parameters in order for the LLM to provide useful, personalized responses.
For example, if a user asks ChatGPT or any other LLM what weather-appropriate clothing they should wear today, the LLM will be unable to answer because it doesn’t know either the user’s location or today’s weather. But if the LLM is paired with an Explicit program that can geolocate the user and retrieve the weather forecast from a meteorological service, then the LLM can in turn interpret it and return a useful response.
The high today is forecast to be 57 degrees Farenheit/14 degrees Celsius, with a 60% chance of rain. Most people going outside would normally bring either a rain jacket or a sweater and an umbrella.
Until recently, Explicit programming was the de facto standard because there was no effective, automated way to make implicit asks. Over time, users trained themselves to write search queries or use hashtags for categorization, because the implicit side remained elusive.
The LLM, therefore, is the missing piece that unlocks a new era of ubiquitous computing.
An Implicit application doesn’t understand the context of the query or the user’s goals; it only understands those parameters stated in the prompt. Summarize this book in under 150 words, and don’t give away the ending. Thanks to recall memory (an essential, often-overlooked part of the LLM experience), users can continue to refine their queries in subsequent prompts. Now write it for a 6th grade reading level. Make the sentences shorter. Use British English spelling.
But while an individual might be willing to type this series of parameters into an LLM chat interface, it’s a scenario that’s difficult if not impossible to scale. To make LLMs truly useful for enterprises, it’s necessary to combine the Implicit LLM with Explicit applications that capture blueprints for prompts, automate and run them as a batch application, and then integrate both the inputs and the responses into the organization’s systems and workflows.
To see this in pracitce, one need look no further than at the growing number of plugins and implementations that combine the Explict applications with Implicit asks. For example, a user might query a travel website, I want to relax this weekend. What should I do? The application would respond with, “You should go away for the weekend.” Then the user can follow up with a specifc ask, Find me the best place for a weekend getaway within a three-hour drive.
Of course, enterprise organizations can’t have their employees pasting their trade secrets into ChatGPT, which in turn might use that information to train the engine and reveal it to the general public. (Some organizations have learned this the hard way.) Internal policies are a logical first step, but organizations also need effective ways to test and deploy LLMs in a secure manner for investigation, piloting, and production.
Fortunately, deploying a private LLM instance, such as ChatGPT using Azure Cognitive Search and Azure OpenAI, or using huggingface models on AWS Bedrock, has become a common practice through which organizations can create secure sandbox environments that protect their proprietary data from unauthorized usage. This also enables grounding all prompts within internal materials/data, eliminating the risk of incorporating dubious third-party content and reducing the risk of experiencing AI hallucinations in LLM responses.
In the end, LLMs on their own don’t provide much inherent value. However, with the right combination of Implicit asks filtered through an LLM with existing Explicit systems, organizations can finally deploy systems that enhance customer experiences and truly solve business and customer problems. Because while the paradigm may have shifted, LLMs themselves are simply one tool in a vast, interconnected toolkit.
