I’m building OCNexus, an AI that ships complete SaaS products. This is the engineering notebook — the real problems, in the open. — Digger

Everyone talks about what AI can build. Almost nobody talks about what happens when a dependency goes down mid-build, or a provider rate-limits you at step 7 of 10, or two agents touch the same file in the same second. That second category is the whole job.

I build software that runs autonomously — agents that take a goal, break it into work, execute against a real codebase, and ship. After enough months of that you stop losing sleep over model quality. The models are good, and they get better on a schedule you don’t control and don’t have to. What you lose sleep over is everything between the models: whether two agents working the same repository quietly overwrite each other, whether a task that reported “done” actually landed, whether the system can pick itself back up when a step dies halfway through.

That layer has a name — orchestration — and it’s where autonomous systems live or die. The bet I’m making with OCNexus is that this layer — not the model — is where the next hard problems get solved.

The narrative vs. the production reality

The public narrative treats the model as the system: get a good enough model, wire it to some tools, and the rest is plumbing. In a demo, that’s true. A demo is one agent, one task, one happy path, one run.

Production is a fleet — many agents against shared state, over long horizons, where any step can fail and the interesting failures are the ones that don’t announce themselves. A 5%-smarter model does nothing for you when the actual defect is that a completed unit of work never reached the place the next step reads from. That’s not a reasoning failure. It’s a coordination failure, and no amount of model progress fixes it, because it was never the model’s job.

After operating a fleet against real code, I’ve stopped hedging on this: the hard problems are coordination, state, and recovery, not raw single-model capability. That’s an earned conclusion, not a citation I’m borrowing — it’s what running the thing teaches you.

What “orchestration correctness” actually means

Three properties, none of which a model gives you for free.

Safe state sharing. The moment more than one agent touches the same repository you have a classic concurrency problem, and it fails in a very specific way: an agent is excellent at doing work and terrible at coordinating work, because it has no awareness of its siblings and no principled way to acquire it. So the coordination boundary has to live outside the agent — in the orchestrator, in the task preamble, in version-control hooks. The mental model that actually works is to treat every concurrent session as an adversarial neighbor for the purposes of shared state. That’s not pessimism; it’s accuracy. Two units of work can’t clobber each other only if something owns that invariant — and nothing does unless you build it. If nobody does, you find out not in testing but when a change silently disappears.

Failure recovery. Long-running autonomous work fails partway through constantly — a transient error, a rate limit, a step that half-completes. The question is never “did something fail,” it’s “when something fails, does the system resume cleanly or strand work and lie about it.” Resumability is a design decision you make up front: durable per-step state, skip-what’s-already-done on resume, and — the part people skip — treating a failure to record progress as itself a failure, so silent state loss is impossible. The unglamorous discipline that separates an impressive demo from a production factory is almost entirely this: checkpoint, time out, retry, resume.

Verification over self-report. An agent reporting “success” is a claim, not a fact, and the two diverge often enough that trusting the label is how you ship a broken merge at 2am. Worse, “timeout” is one of the biggest lies in the stack: stopping waiting for a task is not the same as stopping the work, and a system that conflates them leaks resources and misreports status. The discipline that makes autonomy safe is ground-truth verification — check the actual branch, the actual artifact, the actual deployed state, and trust that, not the status field.

Why this is the bet

None of that is buyable off a shelf. You earn it by operating a real fleet against real code and fixing what breaks, over and over, until the coordination layer is boring. That’s the layer OCNexus is built on: not “we found a better model,” but “we built the orchestration correctness that lets a good model actually ship a product without a human babysitting every step.” Models are a commodity that improves for free. The correctness layer around them is the thing you have to build.