Agentic AI has become the dominant architecture for organisations trying to get value for their AI investment. Single shot Large Language Model (LLM) queries have a high risk of hallucination, Retrieval Augmented Generation (RAG) is limited to search and summarisation and is brittle at scale, and so the world is turning to multi-step reasoning models and agentic AI.
Many think the idea of agents is new, but it isn’t. It goes back decades and books were written about them in the 1990’s.
Breaking complex work into smaller steps, assigning them to specialised agents, and allowing those agents to plan and act autonomously is a powerful idea, because it mirrors how human teams work.
There is value here.
Agentic systems can manage workflows, coordinate tools and operate at a speed and scale that human teams cannot match. It is not surprising that they are being explored so widely given the relatively low levels of return on previous LLM-based architectures.
But as agentic approaches move from experimentation into operational environments, particularly in regulated sectors, a familiar problem is resurfacing. Does the promise live up to the reality?
As we explore this further, consider the following.
Prediction is not the same as judgement and planning is not the same as reasoning. These distinctions matter.
The problems that agentic AI does not fix
Most agentic systems today are powered by LLMs, impressive word prediction machines that are astounding but have innate weaknesses; they’re imprecise, non-deterministic and although partially observable, are impossible to audit.
An agentic system is made up of smaller more deliberate LLM-powered micro-processes. Even when an AI process is broken into agentic steps, the underlying weaknesses remain in each of those steps. Each is still predicting what is likely, not reasoning over knowledge to determine what is correct.
For many tasks, it is completely acceptable to mentally insert the word “probably” before an agentic outcome, and that is sufficient. Most agentic projects today simply rely on human guardrails to check the output.
But as I have written previously, this approach doesn’t scale and humans are extremely poor at checking automated outputs.
Of course, drafting content and summarising information do not require guarantees and there are many use cases where variability in the outcome is tolerable.
But, the moment an agent is involved in the determination of a decision with regulatory, legal, or financial consequences, there is no tolerance for error, and this is estimated to be around a third of enterprise use cases.
In these circumstances, organisations need to ask themselves three questions:
- Does our technology output answers that precisely compute over our specified knowledge; whether derived from regulation, policy, or human expertise?
- Will the same inputs always produce exactly the same outputs?
- Can we understand and audit exactly how the decision was made to deliver compliance on demand?
LLMs do not pass these tests and therefore, nor do LLM-powered agentic systems.
This matters even more when you consider that agentic AI is not just about breaking a task into individual agents, it’s about giving those agents agency, the ability to take action.
Splitting a probabilistic process, based on historic training data, into smaller probabilistic steps doesn’t make the outcome precise, deterministic and auditable, even if a logical workflow orchestrates each step. And while there is value in logging and understanding the steps in an agentic process, as well as recording the LLM’s comments on its own thinking, this is the simulation of logical reasoning, not the real thing. Approaches like context graphs are trying to create an audit trail from the exhaust fumes of LLM generation.
There are therefore substantial risks in giving such models the agency to take action based on a decision, unless that decision was created outside of the LLM.
This is not a criticism of agentic AI, it is a statement of what agentic AI is, and is not, designed to achieve.
Planning and judgement are different problems
One of the most persistent sources of confusion in agentic AI discussions is the terms being used. Planning, reasoning and thinking are all frequently interchanged. There is an assumption that they are exact synonyms, and they are not.
Planning is typically about sequencing actions in linear steps. Reasoning is a more sophisticated non-linear process and requires navigation of data and the making of inferences in the face of a world model of knowledge.
While agentic processes look like reasoning, each use of an LLM remains a black box process that is making a statistical prediction based on a balance of probability influenced by publicly trained data.
Prompt engineering is not an engineering discipline. You can ask an LLM to use only your own knowledge sources, or ask it not to hallucinate – but these are not instructions. Tokens in, influence tokens out, and that is it.
True reasoning on the other hand requires the navigation of a decision space, the application of policy, regulation, expertise and judgement. It often requires inferences to be made, and sometimes clarifying questions to be asked in order to gather missing data and reach an advanced, logical and defensible conclusion.
Agentic systems are well suited to predicting outcomes, but that is not the same as making judgements. Decisions require data but also judgement, and that requires explicit knowledge representation, logical reasoning, and the ability to show working.
These are not properties of LLMs, regardless of how they are orchestrated.
Building agentic systems in the hope that they can serve as decisioning systems is an architectural error, unless the agents have access to a companion technology that serves as a trusted central decisioning authority.
Where Rainbird fits in an agentic architecture
Rainbird was built for making judgements, not predictions. In the world of agents, it serves as the deterministic decision layer.
When an agent reaches a point where a decision must be correct, consistent, and defensible, the agent simply passes its data and defers that decision to Rainbird. Rainbird uses sophisticated symbolic inference to reason over encoded organisational knowledge structured as knowledge graphs. That knowledge may include regulation, policy, procedures, and expert judgement.
The reasoning is 100% deterministic, so given the same inputs – even with levels of uncertainty – the same outcome is produced, every time. Crucially, the system also returns a logical chain of reasoning that led to its determination.
The agent receives this decision and has the option, but not the obligation, to take action based on the precise, deterministic and auditable outcome. In fact many agentic systems are only allowed to have the agency to take action, if Rainbird powered the decision.
This division of labour is simple yet powerful. LLM agents do what they are good at; natural language processing, drafting artifacts, summarising, tool selection, while Rainbird acts as the central decisioning authority. The combination is production-proven and keeps agents fast and flexible, while ensuring that decisions of consequence can be made safely in a way that satisfies regulators.
What this looks like in practice
Consider a financial crime workflow.
An agent monitors transactions, gathers context, and manages the operational flow. When a transaction requires a sanctions or Anti-Money Laundering (AML) decision, the agent does not attempt to reason its way through policy. Instead, it passes the relevant details to Rainbird.
Rainbird evaluates the case against encoded regulation and internal policy, applies logical reasoning, and returns a clear decision with supporting evidence. The agent then acts on that decision, escalating, clearing, or blocking the transaction as appropriate.
The agent provides speed and coordination. Rainbird provides correctness and accountability, while operating at enterprise scale with predictable, low latency.
This same pattern works in credit eligibility, compliance checks, underwriting, insurance claims, tax and audit, etc. The use case may differ, but the architectural power is the same.
Why other approaches fall short
It is common to ask whether this problem can be addressed with better prompting, RAG, GraphRAG, or human-in-the-loop review.
Careful prompting improves outcomes but provides no guarantees. Retrieval provides search and summarisation, improving access to information, but not the application of logic. Human review does not scale and introduces inconsistency and automation bias.
No combination of these approaches can produce a system that can guarantee repeatable outcomes with an auditable reasoning trail. They may reduce risk at the margins, but they do not remove it.
If an organisation cannot prove how a decision was made, it is still exposed.
Moving from experimentation to responsibility
Agentic AI is a powerful step forward in how we should structure intelligent systems. But autonomy without judgement simply moves risk faster through a process.
If organisations want to deploy agentic systems in environments where decisions matter, they need architectures that separate execution from reasoning, and prediction from judgement.
This neurosymbolic approach is not a future aspiration, it’s available today and is battle hardened.
At Rainbird, we have spent over a decade building systems that treat institutional knowledge as a first-class citizen, reason over policy deterministically, and producing decisions that can be explained, audited, and defended. In an agentic world, that capability scales massively.
I’d suggest the following: The next phase of enterprise AI will not be defined by how many agents a system can run. It will be defined by whether those agents can defer to a deterministic decision authority that can make safe, logical determinations in knowledge-rich domains and prove why they are right.
That is the difference between AI that looks impressive at PoC and AI that can be trusted in Production.