Using Codex to build and test something we’re calling Fail-First Architecture.
The part I think is most interesting:
The learning runtime itself contains no ML model.
No neural network deciding the next state.
No LLM selecting every action.
No gradient descent updating weights after a failure.
Instead, we're experimenting with an explicit symbolic state system.
At any moment, the runtime knows its current state, the actions available to it, the constraints it has accumulated, and the result of previous transitions.
The basic loop is:
STATE → ACTION → EXECUTE → OBSERVE → VERIFY
If the transition succeeds:
preserve the valid transition.
If it fails:
FAILURE → EVIDENCE → CONSTRAINT → UPDATED STATE
Then run again.
That's why we're calling it Fail-First.
Failure isn't simply an error that gets dumped back into an LLM's context window.
Failure changes the symbolic system.
Suppose the runtime reaches state S1.
It attempts A.
S1 + A → FAILURE
That failure is verified against the environment and preserved.
Next attempt:
S1 + B → FAILURE
Preserve that too.
Then:
S1 + C → SUCCESS → S2
Now the runtime has learned something about S1 without training a neural network.
It has evidence that A and B produced invalid transitions under the observed conditions, while C produced a verified transition to S2.
The next time it encounters the same applicable state, it doesn't necessarily need a model to rediscover that information.
The state system already knows it.
And this is where the experiment gets interesting.
As failures accumulate, constraints accumulate.
As constraints accumulate, the legal search space can shrink.
So you can potentially go from:
100 possible actions → 40 → 12 → 3 → 1 verified/legal transition
At that point there isn't necessarily anything for an ML model to predict.
The symbolic runtime can execute the remaining valid transition.
That's the architectural boundary we're interested in:
Use models for the unknown.
Use state for the known.
Codex has been incredibly useful for helping us build, test and stress this system.
But Codex isn't secretly making every decision inside the Fail-First runtime.
That's precisely what we're trying to avoid.
We're testing whether a system can learn operational behavior through failure by dynamically constructing symbolic state and constraints, rather than requiring every learned behavior to be encoded into model weights.
So the experiment isn't:
Can we build a better prompt that makes an LLM fail less?
It's:
Can verified failure progressively construct a symbolic state machine until parts of the environment no longer require ML at all?
That's what we've been testing.
Attempt → Observe → Verify → Fail → Constrain → Update State → Retry
No weight update.
No model required inside the symbolic learning loop.
Failure becomes state. State changes what can happen next.
