A hybrid agent does the work with deterministic automation, makes the genuine decisions and analysis with AI, and continuously re-evaluates its own automation for improvements, but never at run time. The result is a process that is consistent and reliable on every single run, yet keeps getting smarter over time. It is the architecture that makes AI agents cheap enough and trustworthy enough to put on production operations work.
Why not just let the LLM run everything?
The obvious way to build an agent is to put a large language model in the driver's seat: at each step it looks at the situation, decides what to do next, and does it. This is a pure-LLM agent, and it's genuinely impressive. It's also the wrong tool for repetitive operations work, for two reasons that compound with every run.
- Token cost. Every decision is a model call, and every model call costs tokens. When the same 40-step workflow runs hundreds of times a day, you're paying the model to re-derive the same plan over and over. The bill scales with volume, which is exactly the wrong direction for operations.
- Reliability. An LLM asked to decide each step is non-deterministic by design. The same invoice can be handled two different ways on two different runs. For back-office work that has to be auditable and correct every time, “usually right” is not a spec you can deploy.
The basics
What is a pure-LLM agent?
An agent that asks the model what to do at every step. Flexible and fast to prototype, but every run re-plans from scratch, so cost and behavior both vary with each execution.
What is Caddi?
A hybrid agent: the workflow runs as deterministic code for speed, cost, and repeatability, AI handles the bounded judgment calls inside it, and a separate improvement loop uses AI to make the code better between runs, never during them.
The two loops that make a hybrid agent
The key idea is that a hybrid agent has two separate loops, and they run at different times.
The run-time loop is deterministic. When the agent actually does the work, it executes as code: the same inputs produce the same outputs, fast, cheap, and fully auditable. AI is called only at the specific points where the task genuinely requires judgment or analysis, for example classifying an ambiguous email, extracting a field from a varied document, or flagging an exception. Those AI calls are bounded and purposeful, not a running commentary on every step. Nothing about the automation's structure is being re-decided while it runs, which is what keeps every run consistent.
The improvement loop uses AI, and it runs between executions. In the background, the agent re-evaluates its own deterministic automation: where it's brittle, where a step could be simpler, where a new edge case has started showing up. It proposes improvements to the code. Because this happens away from the hot path, the process gets smarter over time without ever making a live run less predictable. You get the compounding intelligence of AI with the steadiness of code.
| Pure-LLM agent | Caddi | |
|---|---|---|
| Run-time execution | Model decides every step | Deterministic code |
| Role of AI at run time | The whole engine | Bounded judgment calls only |
| Same input, same output? | Not guaranteed | Every time |
| Token cost per run | High, and scales with volume | Low and flat |
| How it improves | Re-plans live, each run | AI re-evaluates the code between runs |
| Auditability | Hard: reasoning varies | Full: it's code with logs |
The payoff: cost and reliability stop being a trade-off
With a pure-LLM agent you're usually choosing: pay more tokens for more capability, or constrain the agent for more predictability. A hybrid agent refuses the trade. The deterministic run-time loop keeps cost flat and behavior identical no matter how many times it runs; the AI improvement loop keeps the agent learning. You don't sacrifice one to get the other.
How Caddi builds hybrid agents
Caddi's agents are hybrid by construction, and the way they get built matters as much as how they run. Caddi is an agent that builds agents, and it learns from you the way a new hire would: an ops person teaches it a workflow over a screen share and a bit of back-and-forth conversation, and Caddi figures out how the work should run. It turns what it learns into deterministic code that executes the workflow the same way every time, calls AI for the bounded judgment steps inside a run, and keeps a background loop refining that code as tools and edge cases change, never at run time. That's what lets a cloud agent run the same workflow hundreds of times a week reliably, at a cost that doesn't balloon with volume.
See a hybrid agent run your operations
Learn what a cloud agent for operations is, see how your team manages operations AI agents, or book a demo to watch one of your workflows built as deterministic code with AI where it counts.
Do more with less
See Caddi in action
Tell us where to reach you and the calendar opens right here. In 30 minutes we'll show you how Caddi automates the back-office work that grows with your clients—built, run, and maintained for you.
Frequently asked questions
What is a hybrid agent?
A hybrid agent does the work with deterministic automation, makes the genuine decisions and analysis with AI, and continuously re-evaluates its own automation for improvements, but never at run time. The result is a process that behaves identically and reliably on every run while still getting smarter over time. It's the architecture that makes AI agents cheap enough and trustworthy enough for production operations work.
How is a hybrid agent different from a pure-LLM agent?
A pure-LLM agent puts the model in the driver's seat, deciding what to do at every step. That's flexible but expensive (every step is a model call, so token cost scales with volume) and non-deterministic (the same input can be handled differently on different runs). A hybrid agent runs the workflow as deterministic code, calls AI only for bounded judgment steps, and improves the code between runs. It keeps run-time cost flat and behavior identical while still learning over time.
Why do hybrid agents cost less to run?
Because the AI is out of the hot path. In a pure-LLM agent, every step of every run is a model call, so a 40-step workflow that runs hundreds of times a day pays the model to re-derive the same plan over and over, and the bill scales with volume. A hybrid agent executes as deterministic code, so the marginal cost of another run is close to the cost of running code, not another full re-planning session. AI is reserved for the specific decision and analysis steps that genuinely need it.
If the automation is deterministic, how does a hybrid agent get smarter?
Through a second loop that runs between executions, not during them. In the background, AI re-evaluates the agent's own deterministic automation, looking for brittleness, simpler steps, and new edge cases, and proposes improvements to the code. Because this happens away from the hot path, the process improves over time without ever making a live run less predictable. Consistency comes from the code; improvement comes from AI; the two never conflict at run time.
How does Caddi use hybrid agents?
Caddi's agents are hybrid by construction. An ops person screen-shares a workflow once and Caddi turns it into deterministic code (record-to-code) that runs unattended with an audit trail. AI handles the judgment steps inside each run, and a background loop keeps refining the automation as tools and edge cases change. That's what lets a Caddi cloud agent run the same workflow hundreds of times a week reliably, at a cost that doesn't balloon with volume.