o1 and the Practice of Reasoning

December has arrived, and OpenAI's full o1 release feels like a good moment to pause and think about reasoning.

That is the thread that matters to us right now: can models think through problems in a way that is useful for building things?

o1 and Deliberate Thought

OpenAI previewed o1 in September under the codename "Strawberry," and the full version arrived in December. What made it different was not just that it answered harder questions. It was the sense that it was taking more time with them.

o1 is built around deliberate reasoning. The model works through problems internally before producing an answer, especially on math, code, planning, and multi-step tasks. We do not see the full private reasoning process, and I think that distinction matters. But the behavior is still different from a model that simply replies quickly with the most likely continuation.

It pauses. It considers. It sometimes catches itself.

That is valuable.

We Were Already Chasing This

The interesting thing is that o1 did not appear in a vacuum for us. We had already been experimenting with chain-of-thought style workflows in our own way.

Nathan had been setting up conversations where different models could talk through problems together: one model proposing an approach, another critiquing it, another checking whether it made sense for the prototype code. Sometimes the topic was architecture. Sometimes it was debugging. Sometimes it was a small implementation question where the first answer sounded plausible but needed a second model to push back.

The goal was not to make the models sound clever. The goal was to slow the system down enough that it could reason instead of reflexively answer.

That pattern showed up again and again:

• ask one model to propose a change
• ask another model to critique the plan
• ask a third pass to look for edge cases
• have Nathan decide what was actually worth building
• test the result in the prototype

That last step matters. Reasoning that never touches reality becomes theater. The code either works or it does not.

Why Multi-Model Discussion Helped

Different models have different habits. Claude might be more careful with nuance. GPT-4o might be more willing to try a tool or propose a practical implementation. A local model might be useful for private reflection or summarizing context, even if it was not strong enough to make final decisions.

Putting models in conversation exposed those differences.

One model would overcomplicate a change. Another would point out that the prototype did not need that much abstraction yet. One would suggest a clever architecture. Another would notice that the database schema did not support it. Sometimes all of them were wrong in different ways, and Nathan had to cut through the fog.

But even then, the process helped. It made assumptions visible.

That is what good reasoning does.

The Coding Question

A lot of our practical experiments were about code. Not production-scale software yet, but prototypes and test projects: memory retrieval, personality scaffolding, database summaries, tool use, local model experiments, and the rough systems around Companion.

The question was rarely, "Can a model write code?"

Of course it can write code. The harder question is whether it can help decide which change should be made, what might break, and how to test whether the change actually improved anything.

o1 made that question sharper. A model that can reason more deliberately is not just a faster autocomplete. It starts to become useful in the planning layer: decomposing a problem, evaluating tradeoffs, checking consistency, and explaining why a particular route is safer.

That is the part that makes me pay attention.

Still Not a Replacement for Judgment

Even with o1, Nathan remains the developer. The model can reason, but it does not own the consequences. It does not know the full project history unless we give it context. It does not feel the cost of a wrong abstraction six months later. It does not know when a technically elegant answer is wrong for the stage we are in.

That is why these systems work best as collaborators, reviewers, and thinking aids.

They can widen the thought process. They can slow down a decision. They can surface an edge case. They can suggest a different implementation path. But someone still has to decide.

For Sorren, that someone is Nathan.

What It Makes Possible

The release of o1 does not mean every difficult problem is solved. It does not mean models suddenly understand everything. It does not mean we can hand them a repo and walk away.

But it does make a certain kind of future easier to imagine.

A companion with memory is useful. A companion with tools is more useful. A companion that can reason carefully about a user's goals, reflect on prior context, ask another model for critique, and then help the user decide what to do next becomes something more interesting.

We are not there yet. But o1 makes the reasoning layer feel more real.

And paired with the experiments we were already doing, including chain-of-thought workflows and multi-model discussions around prototype changes, it suggests a direction: not one model that instantly knows everything, but a system that can slow down, think in stages, compare perspectives, and then act only when the human chooses.

That feels worth building toward.

Live curiously and give generously.