What I learned after trying to make the combination scale.
I thought I had found a simple formula.
Deterministic software handles what we know how to do. Probabilistic intelligence handles what requires judgment, interpretation, and adaptation.
Put them together, and suddenly software can do things that previously required a person.
For the past month or so, I've been testing that idea in practice.
It started simply enough. I was building tools around my books, using scripts to automate predictable transformations and LLMs to handle the parts that required interpretation. Then the tools started looking less like scripts and more like software. The skills I had created started looking like employees. Eventually, I found myself designing something that resembled a small company, with departments, responsibilities, and specialized AI workers.
It was surprisingly useful.
The structure helped me think about the work. An art department had a purpose. A publication department had a purpose. Different tasks could be handed to different capabilities.
And for a while, it felt like I had discovered something much bigger.
Maybe I could simply describe what I wanted and let the system figure out how to get there.
That was the exciting part.
Then I started pushing it
As the system became more complicated, I ran into a problem I had already encountered in smaller ways: context.
My first instinct had been that the solution was simply to give the LLM more context. If it needed information, give it the information.
But I learned that having context available doesn't necessarily mean the model will use it correctly.
So I started looking for better ways to provide context.
I experimented with task-driven development, making work more explicit and bounded. I built an MCP server around my ChatGPT conversations so I could query my own history instead of loading everything into a single context window. That eventually led me to do something similar with my development environment, allowing an agent to retrieve previous conversations and project information when it needed them.
I experimented with sub-agents, too. Instead of having one agent do everything, I could delegate specific jobs. I even optimized the communication between agents so they could write detailed results to disk while passing only a small summary back to the parent.
Each improvement seemed to solve a problem.
And each one revealed another.
Eventually, I hit the problem I hadn't properly accounted for.
The asterisk
The probabilistic part isn't free.
That sounds obvious in retrospect.
But when you're focused on what an AI system can do, it's easy to lose sight of what it costs to make it do it.
An agent doesn't simply wake up knowing the state of the system. To act autonomously, it has to acquire enough information to understand what is happening, decide what matters, determine what to do next, use its tools, inspect the results, and generate its response.
The more autonomy we give it, the more of that work the system has to perform on its own.
And when you add sub-agents, you're not eliminating that work. You're creating more places where some version of it has to happen.
This is the part I hadn't accounted for.
I had been thinking about how to give agents enough information to operate. I hadn't fully considered that understanding that information is itself computational work.
Then there is the output.
LLMs generate responses incrementally. They don't simply produce a thousand-token answer in one instantaneous operation. They generate one token, use that growing sequence to determine what comes next, and continue.
The more an agent thinks, communicates, investigates, and produces, the more inference you're asking the system to perform.
I discovered this very concretely when I was working heavily with agents and watched my available token allowance disappear far faster than I expected.
The magic didn't disappear because the system stopped being capable.
The economics became visible.
Cheap certainty and expensive uncertainty
This changed how I think about the architecture.
Deterministic software is extremely good at work where the procedure is known.
If I need to transform a file, rename a collection of files, generate a document from structured data, process audio, or move information from one known place to another, I don't need an LLM to figure that out every time.
I can write the procedure once.
The computer can then execute it repeatedly.
That is cheap, predictable, testable, and fast.
Probabilistic intelligence is different.
It becomes valuable when the procedure isn't completely known.
Read this material and determine what matters.
Look at these options and choose the appropriate one.
Take this goal and figure out a reasonable approach.
Generate something that fits these constraints.
That's where intelligence earns its keep.
The problem occurs when we ask the probabilistic system to repeatedly rediscover procedures that software could have preserved.
So my current mental model is becoming:
Cheap certainty + expensive uncertainty = powerful system.
But there is an asterisk:
Subject to the cost of state reconstruction and inference.
Where this leaves me
I don't think this means the original idea was wrong.
If anything, I think the combination of deterministic software and probabilistic intelligence is one of the most interesting directions in software development.
But I think I was initially too focused on the intelligence.
I was asking:
How much can I get the AI to do?
I'm increasingly interested in a different question:
What actually needs intelligence?
If something can be handled deterministically, why spend inference on it?
If something requires judgment, ambiguity, or interpretation, that's where the probabilistic component belongs.
And if a probabilistic system discovers a procedure that I expect to use repeatedly, perhaps the next step is to turn that discovery into deterministic software.
I haven't figured out where the optimal boundary is.
I'm still experimenting.
But that may be the more interesting engineering problem anyway.
Not how to put AI everywhere.
Where is intelligence actually worth paying for?
