You Run Open Models. Your Vendor Still Owns the Loop.

Most companies that say they've gone open-weight are running those weights inside a closed harness, and the harness is where the dependency lives. OpenAI's Codex now runs any open model. Claude Code is closed and will run them through a proxy. Every lab's agent tooling is happy to host a competitor's weights, because the lab keeps what it actually wanted: the user, the defaults, the upgrade path, and the usage data that trains its next model. We call the story a team tells itself at that point the open-weight alibi. It's the belief that because the model is open, the stack is independent. The weights were never the lock-in. The loop around them is, and swapping the model inside someone else's loop changes nothing about who owns it.

What is the open-weight alibi?

It's the claim of independence a company makes when it runs open models inside a vendor's harness.

An alibi is a story that explains why nothing has to change. We've written about the efficiency alibi, where a cost cut gets credited to a capability that doesn't exist yet, and the governance alibi, where a dead pilot gets blamed on process so the operating model survives. The open-weight alibi works the same way. A team downloads a strong open model, points a vendor's coding agent or orchestration product at it, and reports to leadership that single-model risk is handled. The report is wrong in a specific way. The model is replaceable, the thing it was plugged into is not, and that thing is now collecting every prompt, correction, tool call, and outcome the team produces.

Why does the harness matter more than the weights?

Because the harness holds the user, the defaults, and the exhaust, and those three compound. Weights don't.

A model is a static file. It gets better only when someone retrains it. A harness is a running system, and it improves with every session that passes through it, because the sessions are the training data for whatever runs inside it next. That's the engine the labs are competing to own, and it's why they've stopped fighting over whose weights you use. The lab that owns the most-used harness accumulates the usage that keeps its own models competitive inside it, whatever model you picked this quarter. We've argued since the harness gap that the layer around the model is where production difficulty concentrates. It's also where the advantage concentrates, and a company that owns none of it has bought a model and rented a business.

Doesn't an open license settle this?

No. License is a property of the model. The loop runs regardless of what the model is licensed under.

This is where the alibi gets its credibility, because the license really is clean. The model might ship under MIT, which we covered in the license line, with no strings at all. The harness might even be open source itself. OpenAI's Codex client is Apache-licensed, and the usage still routes to OpenAI. The license tells you what you may do with the code. It says nothing about where the sessions go, who sees the corrections, or whose next model learns from your team's work. A permissive license on a component that reports home is still a component that reports home. You can read every line and change every line and the loop still closes somewhere you don't control.

Where does the exhaust actually go?

Into the harness owner's post-training pipeline, and out of your learning ledger.

Follow one working session. An analyst runs an agent on a vendor's platform against your open model. The agent drafts, the analyst corrects, the agent retries, the task completes. Four things just happened that have value: the task, the correction, the retry pattern, and the outcome. The task result is yours. The other three are the know-how, and they were captured by the platform, not by you. Multiply that across every seat for a year and the vendor holds a detailed record of how your company makes AI work in your specific context, which is exactly the asset we said companies should be banking for themselves. The open model didn't protect it. The open model was the bait that made the harness feel safe enough to standardize on.

Isn't a vendor harness just the practical choice?

Often, yes. Using a vendor harness is fine. Calling it independence is the alibi.

Plenty of teams should run a vendor's agent product. The tooling is good, the setup is fast, and for experimentation, prototypes, and low-stakes work there's no reason to build your own. The problem is the sentence that gets attached to the decision. "We're on open models, so we're not locked in" is false for any harness you don't own, and the false sentence is what stops the actual mitigation from getting funded. This is a cousin of rented optionality, where the flexibility you thought you held was leased from the vendor you wanted flexibility from. Here the model is yours and the flexibility still isn't, because switching harnesses means leaving behind the configurations, the skills, the memory, and the accumulated behavior that only exists inside the one you're leaving. Name the dependency correctly and you can price it. Call it independence and you'll never look.

What does owning the loop look like?

A thin harness you control, where the model is a guest and the sessions land in your store.

It's smaller than it sounds. The pieces that matter are the orchestration logic, the tool connections, the memory and context store, and the logging of every session, correction, and outcome. None of those require you to train a model or build a platform. They require you to decide that the loop closes on your side of a boundary, the same boundary we described in the model socket. Open-weight models earn their place inside that design, because a model you hold behind a harness you own is the one configuration where nobody else gets the user, the defaults, or the exhaust. Open weights inside a closed harness give the vendor a free model to serve you with. Open weights inside your own harness give you the only version of independence that's real.

What should you do about the open-weight alibi?

The question you're really asking is whether your open-model strategy bought you independence or just a cheaper model. Trace one session and you'll know.

Pick any production agent your company runs on an open model. Follow a single task from the prompt to the outcome and write down where each of four things landed: the session log, the human corrections, the tool calls, and the final result. If three of the four live in a vendor's system, you have the alibi, and the fix isn't to abandon the vendor tool tomorrow. It's to stand up the thin harness for the workflows where the know-how is worth owning, start with the beachhead you already trust, and move the loop one workflow at a time. Keep the vendor harness for everything that doesn't compound. Open models were supposed to be the hedge. They only hedge anything when you own the thing they run in.

If you want the loop closed on your side, with open models behind a harness you own, start with an AI Blueprint or reach us at contact@theyor.com