Key Takeaways
ChatGPT and large language models are exciting for language tasks but poorly suited to running business processes on their own, the post argues. LLMs struggle with mathematical and logical reasoning, can generate inappropriate output, and, most critically, are non-deterministic and opaque: they act on logic buried in model parameters, so when something goes wrong, like sending a wrong invoice, no one can explain why. Because business automations are inherently logical and procedural, injecting generative AI adds risky unpredictability. The proposed answer is an AI that executes actions deterministically and auditably while natively understanding human language, resolving context, ambiguity, and grammar the way people do. Kognitos is presented as that solution: it processes plain English, handles domain-specific language, and provides an auditable view of every run so users can see why an action happened. The takeaway: pair LLM power with determinism and transparency, echoing the case for explainable AI.
What are the limitations in using ChatGPT to automate businesses?
While the potential of ChatGPT and other NLP models to automate certain tasks that involve processing and generating human language is exciting, it is important to understand the limitations of this technology. One limitation is that ChatGPT and other NLP models are not adept at mathematical or logical reasoning. Additionally, these models can sometimes generate responses that are inappropriate or offensive, particularly if they are trained on a dataset that includes such language. Furthermore, NLP models like ChatGPT are not able to fully replace human workers, as they do not possess the ability to think and reason in the same way that humans do. This is because it is trained to generate human-like text based on a given prompt or conversation without a deep understanding of what is right and what is wrong. Tasks that involve critical thinking, such as math or business processes, are also hard for LLMs to do because they require precision and repeatability which isn’t a strong suite of LLMs.
Even if Generative AI is able to overcome the above mentioned issues, one major problem that remains with ML driven automation systems is the problem of “opaqueness”. The ML systems would just execute actions based on some logic deeply embedded in one of the model parameters, but we would never know the “why” part for any action. For example, an ML automation system could erroneously send out wrong invoices to your customers, and you would be left wondering exactly what caused it to do so. This means that resolving any bug or issue in the automation would be a nightmare for the IT team. Not just that, but business process automations are inherently logical and procedural. Using Generative AI (like ChatGPT) in this use case would just introduce non-determinism in such tasks that could cause unintended problems.
How can we solve this problem?
We need an AI system that is able to execute actions in a deterministic and auditable manner. Traditional programming languages already do this. But less than 1% of the human population knows how to even read code. Hence, there is a need for computers to natively understand statements in native language and know how to execute them (in the same way they know how to execute programming languages like python or java). However, this approach presents several challenges.
A language like English is very contextual. The same word could mean two very different things based upon the context it is spoken in. For example “Capital” can refer to financial assets or the city where a company is headquartered. Programming languages cannot handle such context based actions, and would require separate algorithms for each case.
Native languages are also very ambiguous. These languages were developed in a way that resolved such ambiguities via conversations. For example, if you say “we should call that employee”, if your listener has some doubt about which employee you are talking about, she would just ask you to clarify. Now programming languages are not built to be run in a conversational way. They just run a specific action, and any ambiguity that arises in the course of that would cause an exception.
One other difference between native and programming languages is the difference in their grammar rules. People do not think in terms of “functions” or “classes”. They think in terms of “actions”, “concepts” and “knowledge”. This is because programming languages are inherently mathematical, whereas native languages developed long before humans even had rudimentary knowledge of basic math.
One solution to this problem is Kognitos, which directly understands native language and is able to process it. Kognitos is able to overcome the challenges associated with native language by understanding the context, resolving ambiguity, and understanding the rules of grammar in a way that is similar to how humans understand them. Additionally, it is able to understand and process domain-specific language, making it more effective at automating tasks that involve human language. And, just like programming languages, it also provides a detailed auditable view into its runs, which the business users can use to gain insights into why an action happened or what might have gone wrong in case of an exceptional situation. Kognitos hence provides a way for businesses to reliably automate their tasks while leveraging the power of the latest LLM technologies.
Conclusion
In conclusion, while ChatGPT and other NLP models have the potential to revolutionize the way we interact with machines, it is important to understand their limitations. By enabling humans to directly communicate with computers in their native language and using technologies like Kognitos, we can overcome these limitations and make businesses more productive. As this technology continues to evolve, we can expect to see more advancements in the automation of tasks that involve human language.
How to Navigate LLM Limitations in Business Automation
- Identify business processes where accuracy and auditability are non-negotiable. Financial transactions, compliance decisions, and regulated workflows require auditable, deterministic outputs. LLMs that generate probabilistic outputs are not appropriate for these processes without explicit guardrails.
- Evaluate LLM outputs with a structured accuracy test. Before deploying LLM-based automation on any business process, test on 200 historical transactions. Compare LLM outputs to known-correct outcomes. Any process where the LLM error rate exceeds 0.1% for a financial or compliance decision requires a different approach.
- Deploy deterministic AI for rules-based business decisions. Rules-based decisions in AP, compliance, and HR should use deterministic AI that executes explicit rules rather than LLM inference. Deterministic AI produces the same output for the same input every time, which is required for audit defensibility.
- Use LLMs for exception handling interpretation, not primary decisions. LLMs are well-suited for interpreting exception context in plain English and routing to the correct resolution path. They are not suited for making the financial or compliance decision itself. Design LLM roles accordingly.
- Document the LLM model version and configuration for every business process deployment. LLM model updates can change output behavior. Document the model version, temperature setting, and prompt configuration for every business automation deployment. Version control LLM prompts the same way you version control code.
