I want to tell AI what I want done.
I do not want to learn why request #83 got a 429.
Yet somehow we are normalizing this.
429 means one thing.
403 means something else.
504 might mean the model did the work and the transport died afterwards.
A reply can stop because it ran out of output tokens.
Another can hit an iteration ceiling with the final answer already sitting there.
Same experience for the user.
AI broke.
We went through 17 terminal failures inside YieldBrain recently.
Not one was the model failing to think.
5 were tool or harness failures, 4 rate limits or quota, 4 transport, 2 output budget, 1 auth and 1 insufficient evidence.
Zero semantic model failures.
That is insane to me.
Not because plumbing fails. Of course it fails.
Because we still expect the user to know what kind of plumbing failed.
Take a 429.
One NIM model can be unavailable while another NIM route is fine. We built the fanout so one model hitting 429 does not block the others.
If I see that failure, I know not to declare NIM dead.
Why the fuck should the user know that?
Same wif retries.
Some failures should back off.
Some should reroute.
A retired model route should not be retried at all.
We even found an 83 character harness error in the database that could be counted as an answer.
Imagine asking AI to do something and the system quietly records “yep, replied” because an error stub exists in the reply field.
kek.
This weekend made the problem painfully obvious in our own system.
On Friday I said publicly that we would release the first open source part of YieldBrain this weekend.
The kernel.
We did not.
It is still not publicly released.
The Director got the goal on Friday and kept working on it through the weekend.
The brief told it not to bulldoze through failures just to satisfy the release goal.
If something useful was repairing itself, leave it running.
If a provider looked dead, verify it.
If a harness broke, repair that lane first.
And public actions still belonged to me.
So the release kept uncovering work.
Fix one thing, verify it, then find the next thing behind it.
That does not fit neatly inside “this weekend.”
I was the one who said this weekend anyway.
The machine had a goal.
I made the promise.
By Sunday the kernel source had been promoted into our canonical internal control, but public release was still disabled.
There were still decisions around licensing, the namespace and the sanitized public export.
Those are human decisions.
So it stopped there.
Which is actually what I asked the system to do.
This is not the part where I claim our AI fixed itself and everything worked perfectly.
It didn't.
YieldBrain still works too often because I know what the fuck I am looking at.
I know that a 429 on one route is not automatically a dead provider.
I know why a 410 after that changes the diagnosis completely.
I know an output limit is not a network failure.
I know when the thing claiming to be an answer is actually garbage from the harness.
Of course I know.
I built the thing.
The user didn't.
That is the bug.
I don't want to build a better cockpit and teach everyone to become a pilot.
Fuck that.
The user should be able to say what they want done.
Then the system should deal with as much of the ugly shit underneath as it can.
If one route dies, it should know what that means before bothering the user.
If work can continue somewhere else, continue.
If the evidence is garbage, don't pretend the job succeeded.
And when it reaches something that actually needs the human, stop.
That is much closer to what I mean by “just works.”
A hosted coding subscription can own more of this plumbing because it controls more of the stack.
YieldBrain is different. It coordinates models, tools and compute the user already legitimately has access to.
So right now we see more seams.
I want fewer of them.
Not by pretending the machinery isn't there.
By making the system understand enough of its own machinery that the user doesn't have to.
That is also why putting the kernel out publicly matters to me.
As long as this thing only works in my setup, with me standing next to it knowing where all the weird bodies are buried, we have not proven the thing I actually care about.
Can the knowledge leave my head?
Can someone express a goal without first learning our little religion of queues, routes, retries and provider weirdness?
Not yet.
That is the honest answer.
There are roughly three hours left in the weekend while I write this.
Maybe the kernel goes public tonight. Maybe it doesn't.
I am not making another promise.
But the attempt already found the thing I wanted the release to test.
Too much of YieldBrain still works because its architect knows how YieldBrain works.
The user has better shit to do.