← All articles

Thought Leadership

Autonomous Agents Need to Decide: The Category Is Decision Infrastructure

Why autonomous agents need code, judgment models, and causal reasoning to make reliable decisions, from customer support to root cause analysis.

An autonomous agent considers a decision: understand, evaluate options, and decide.

In a recent article, TypeSafe proposes an interesting distinction: “Jev makes judgments, code makes decisions.” This makes sense when the decision rules are already known. Code provides control and predictability, both essential for deploying reliable agents.

But autonomous agents also need to decide in situations we have not fully described in advance. When the possibilities become too numerous and some information is unknown, applying rules is only part of the problem. Think of a Waymo deciding whether to move slightly to the left or continue straight: every possible situation and the right response cannot be written in advance.

We argue that the future of decision infrastructure lies in combining these capabilities. We’ll show why through a concrete example: root cause analysis.

1. When the rules are known, code is best

Let’s start with the customer support example in TypeSafe’s article. A customer asks for money back. The system needs to understand the request, check eligibility and decide whether to issue a refund or send it for review.

Some of these steps require judgment. Is the customer asking for a refund? Are they reporting an unauthorized charge? Others follow explicit rules: an eligible refund below a defined amount can be processed automatically.

Once these rules are known, encoding them in code is best for observability and repeatability. The policy is applied consistently, and when something goes wrong, we can distinguish an incorrect judgment from an incorrect rule.

Companies have been using Rippletide to transform past support traces into explicit rules and processes. These traces capture the information an agent collected, the actions it attempted and their outcomes.

In the telco support example below, Rippletide proposes rules from historical traces and lets the team replay them against past calls. Reviewers can inspect which actions would have been blocked before introducing a rule in Observe mode and later enabling enforcement.

Rules organized by action, with evidence and activation counts.

Rules organized by action, with evidence and activation counts.

At runtime, the trace shows the agent’s steps and where Rippletide intervened. In this example, the agent retrieved the customer’s profile and subscription and assessed churn risk before a subsequent action was blocked.

A support trace showing the action blocked before execution.

A support trace showing the action blocked before execution.

A proposed rule and its replay against historical traces.

A proposed rule and its replay against historical traces.

The rules remain visible and manageable, with separate Observe and Enforce modes.

This is how we see decision infrastructure evolving: reasoning helps discover candidate rules; replay and review help validate them; deterministic enforcement makes the approved rules repeatable.

2. Not every scenario can be written in advance: agents need to decide

Consider root cause analysis. A service slows down after a deployment. Database latency increases and requests start timing out. Is the deployment responsible, or are we seeing a dependency failure or exhausted resources?

With just 10 services, each healthy, degraded or unavailable, there are 3¹⁰ = 59,049 possible combinations. With 20 services, that exceeds 3.4 billion, before considering timing or recent changes. Not every combination requires a separate rule, but enumerating cases quickly becomes impractical.

This helps explain why general-purpose coding agents can outperform dedicated RCA workflows: they can follow evidence beyond a predefined investigation path, inspect code and revise their hypotheses as they learn. Despite excelling in following evidence and surfacing plausible candidates, these general-purpose agents falter at the next step, often picking the wrong cause from the right data.

Revisiting our Waymo example: deciding whether to move slightly left or continue straight depends on the situation unfolding around the vehicle. Every scenario and its response cannot be individually written in advance.

Code remains essential for enforcing constraints and executing actions. But when the predefined process no longer provides an answer, the agent needs to decide what to do next.

3. Different decisions require different capabilities

These examples point to a broader view of the decision category now gaining attention. It is neither a decision model, nor code, nor a judgment model alone, but decision infrastructure covering these different cases. Some decisions follow explicit policies. Others require fast judgments. Others need an investigation, with several hypotheses and incomplete evidence.

An autonomous agent may need all three within the same task. In root cause analysis, code can enforce access permissions, a judgment model can assess whether a log entry is relevant, and a causal decision engine (a system that reasons over how the services affect one another) can compare competing hypotheses, identify the evidence that distinguishes them and determine the most likely root cause.

4. Neither a decision model, nor code, nor a judgment model alone, but decision infrastructure

Fast, inexpensive decisions are a market in their own right. Classifying a request, routing a ticket or assessing whether a signal is relevant often requires a focused judgment. System 1 models serve this need, where latency and cost matter at scale.

We believe the larger market lies in complex, consequential decisions, where decision quality determines whether a use case is possible at all. A remediation agent writing changes to production, or an agent making credit decisions, must reason over vast amounts of incomplete and sometimes conflicting data. A cheaper answer has limited value if it cannot be trusted enough to act on.

Better decision quality therefore opens new use cases. It allows agents to take responsibility for work that previously required human investigation and judgment, expanding the scope of autonomy beyond routine workflows.

As an illustrative example, consider a US lender processing 500 credit applications a day, with five decisions per application. Moving from 85% to 99% accuracy means 350 fewer incorrect decisions daily, or $350,000 in potential daily savings, assuming $1,000 per error. You have just enabled the move from a previously unviable customer-facing agent to one that can now be deployed. The same applies to RCA, remediation agents, and many, many more.

This is the opportunity Rippletide is pursuing, with Tide-RCA as a concrete example: identifying root causes across complex systems from fragmented evidence, where the quality of the diagnosis determines what can safely happen next.

Which is the larger opportunity: selling software tools or enabling agents to do the work? The proof is left as an exercise for the reader.

Conclusion

TypeSafe’s article highlights an important part of decision infrastructure: combining fast judgments with explicit rules. As agents become more autonomous, they also need to investigate situations whose resolution cannot be specified in advance.

We believe the larger opportunity lies in consequential decisions, where better decision quality makes new use cases possible. This requires code, judgment models and causal reasoning to work together.

That is the direction we are building toward at Rippletide: decision infrastructure that expands the work agents can reliably take on.

Building agents where the cost of a wrong decision is high? Talk to us about decision infrastructure built for consequential decisions.

Put the decisions to work.

Explore Tide-1 More from Rippletide