Deterministic AI Agents: An Overlooked Opportunity

Today, the default assumption in the AI field is that agents need LLMs. You define a task, wire up tools, pick a frontier model, and let it reason its way through. For many use cases, that's the right call. But for an unignorable percentage of use cases, it isn't.

There's a category of AI agent use cases that have well-defined decision logic, bounded input spaces, and explicit success criteria. They require reliability, speed, and auditability rather than emergent reasoning and creativity. For this category, a deterministic, rule-based agent architecture outperforms an LLM on every practical dimension: cost, speed, correctness, and transparency.

I built a proof of concept to test this: a blockchain investigation agent that intelligently traces fund flows, detects mixing activity, and identifies KYC exchange deposits for user identification. In a single run, it produced over 38,000 tokens of structured reasoning, making 195 tool calls while doing so, and completed in under 30 seconds, all while running on a VM with only 3 CPU cores and without a GPU.

The more interesting result is what the architecture demonstrates, not what this specific application does.

What is a Deterministic AI Agent

A deterministic AI agent follows explicit, pre-specified rules to make every decision. Given the same input, it always produces the same output. There are no probability distributions, no sampled tokens, no temperature parameters. The agent's behavior is fully explained by its code, making it fully auditable and predictable.

Structure does not mean simplicity or robotic outputs. A well-built deterministic agent can:

• Call external APIs and tools dynamically
• Adapt its path based on what it finds at each step
• Follow multi-hop reasoning chains across many tool calls
• Generate structured, human-readable analysis of its findings
• Handle branching logic, scoring systems, and multi-factor decisions

What it cannot do is reason outside the bounds of what its rules can express. If a situation falls outside the defined logic, the agent has no mechanism to improvise. That's not a bug. It's a feature. The constraint is exactly what makes it valuable for the right use cases, and what makes it wrong for others.

The interface, from the outside, can look identical to an LLM agent. The blockchain investigation agent streams a <think> block in real time, showing tool calls, tool results, and reasoning text as they happen. The "thinking" is generated from templates filled with real data. It's human-readable with zero chance of hallucination.

The Practical Advantages

Speed

Current SoTA (state-of-the-art) open source LLMs, models like Kimi K2 (1 trillion parameters) or GLM-5 (745 billion parameters), require tens of thousands of dollars in GPU infrastructure to run at scale. Even with that hardware, generating 38,000 tokens with 195 tool calls takes meaningful time and significant cost per run.

My deterministic agent ran at over 1,200 TPS (tokens per second) on commodity hardware with no GPU. The bottleneck was network latency on external API calls, not compute.

Cost

The marginal cost of a deterministic agent run is essentially the cost of the API calls it makes to external data sources. There's no inference cost besides less than 100 watts of electricity. A 195-tool-call investigation that would cost several dollars via a frontier LLM API costs fractions of a cent in deterministic compute.

I actually built the Blockchain Detective with an LLM agent approach as well. The final outputs of the deterministic agent and the LLM-based agent were comparable in quality. But one cost ~1,000x less than the other, and was 10x faster.

This changes what's economically feasible. Longer agentic flows, higher call volumes, more frequent re-runs, all become practical in ways they aren't when tokens have a high price.

Auditability

Every finding in a deterministic agent's output traces back to a specific rule and a specific data point. There's no "the model said so" or "it just learned that behavior during training". There's a decision tree you can inspect, thresholds you can review, and source data you can verify.

For domains where findings need to be legally defensible, this matters enormously. An LLM-generated analysis is difficult to audit in court. A rule-based analysis with a complete decision trace is straightforward to defend.

No Hallucinations

A deterministic agent cannot fabricate information. It has no mechanism to do so. The output is a function of the input data and the rules. Nothing else. This is a categorical difference in what's even possible with LLMs.

For high-stakes applications such as financial analysis, medical triage, and legal evidence, this property is non-negotiable.

The Real Tradeoffs

Deterministic agents are not a better version of LLMs. They're a different tool with a different applicable problem set.

The fundamental limitation is that the agent's intelligence ceiling is a developer's ability to specify rules and understand the domain they are working in. Every edge case the rules don't cover is a gap. Every novel situation the logic doesn't anticipate produces either an error or a wrong answer. LLMs handle novel situations gracefully; deterministic agents handle them poorly or not at all.

This means deterministic agents are appropriate when:

• The decision logic is fully specifiable in advance
• The input space is bounded and well-understood
• Correctness is verifiable against explicit criteria
• The same situation should always produce the same response

LLMs are appropriate when:

• The problem requires insights or connections not capturable in rules
• Input is genuinely ambiguous or open-ended
• Creative or nuanced judgment is required
• Edge cases are too numerous or unpredictable to enumerate

A large fraction of real-world AI agent use cases fall in the first category. Compliance checking, fraud pattern detection, data extraction, report generation from structured sources, automated triage using defined criteria are all problems where the logic is specifiable and determinism is an advantage.

The LLM-Like UX (User Experience) Layer

One underappreciated design choice in deterministic agents is the interface. Exposing the agent's decision process as a stream of natural language reasoning text, with tool calls, observations, and intermediate conclusions, makes the system interpretable to users who aren't engineers.

This is what the <think> block pattern accomplishes. Deterministic AI agents are not actually producing the thinking tokens. Rather, they are presenting the execution in a readable, natural text format that makes the output trustworthy and inspectable in a way that a raw JSON result is not, especially for those less technical.

The "thinking tokens" pattern, originating from reasoning LLMs, is genuinely useful independent of whether the underlying system is probabilistic or deterministic. Users can follow the agent's logic, spot where it made a decision, and verify that the decision was correct. That transparency is harder to achieve with opaque model outputs.

Historical Context

Some are currently conflating the terms "AI" and "LLM". The truth is that it's more like a square and rectangle. Not all AI systems are LLMs, but all LLMs are AI. Let me provide an example:

IBM Watson won Jeopardy in 2011 using a system with no trained neural network. Rather, it was a combination of information retrieval, NLP pipelines, and statistical scoring across analytical techniques. The public and the industry accepted it as AI. The label followed capability and usefulness, not architecture.

The field has always included rule-based systems, expert systems, statistical models, and hybrid approaches alongside neural networks. The LLM moment has compressed that history out of the common narrative.

Deterministic agents aren't just a throwback or a blast from the past. They're a pattern that remained valid throughout the deep learning era and is increasingly worth reconsidering as LLM costs and complexity push teams to look for alternatives where they can find them.

What This Looks Like in Practice

The blockchain investigation agent scores every transaction it encounters against defined thresholds:

• CoinJoin mixer detection uses an additive scoring system across input count, output count, output value uniformity, and transaction size. A score above 10 produces a "very high confidence" mixer finding. A score below 4 produces no finding.
• Exchange detection uses transaction volume, total BTC received, and balance ratio to generate a likelihood score.
• Fund flow tracking follows a specific amount through the chain with a 1% fee tolerance, handling splits, consolidations, and high-volume addresses via separate logic paths.

Every threshold has a rationale. Every output can be challenged, reviewed, and defended.

The agent made 195 decisions across a single investigation run, chaining tool calls based on what it found at each step, and produced a complete structured report, all in under 30 seconds.

Moving Forward

The interesting question is how broad the applicable problem space is. My expectation is that it's larger than the industry currently treats rule-based AI solutions.

Every AI agent deployment carries ongoing inference costs. Every LLM-based agent carries hallucination risk. Every opaque model output creates auditability challenges. For use cases where the logic is specifiable and the stakes are high, those are costs worth avoiding.

The deterministic agent pattern is one way to avoid them. The engineering investment is front-loaded. You have to specify the logic explicitly rather than delegating it to a model, but the operational properties are substantially better for the right workloads.

As open source LLMs continue scaling toward trillion-parameter territory, the compute gap between "use an LLM" and "write explicit rules" will only widen. For the use cases where explicit rules are sufficient, that gap represents a compounding advantage.

Live Demo: blockchain.acampi.dev