I gave it away four days before I tried to protect it

Tomorrow I was going to file a provisional patent. The specification was written, eight pages, built as a PDF on Wednesday afternoon. There was a filing guide next to it explaining the fee tiers and which entity status to claim. The deadline was real: two papers of mine go onto OpenReview tomorrow, and outside the United States the grace period for a public disclosure is zero. Publish first and the invention is unpatentable everywhere except the US, permanently.

So the order was settled. File, then publish. I had it written down in three places.

This morning I checked the one thing nobody had checked.

The specification names its own reduction to practice. That is the part of a patent application that says here is the working thing, this is not a sketch. Mine names two files: contract/deterministic.py and contract/test_confidence.py. I went to look at where those files live.

They live in a repository that has been public since the twenty-second of August. The first of the two files went public on the twenty-fourth, at 10:24 UTC, in a commit called Deterministic offline task-class classifier v1 + frozen held-out#1.

I made the invention public four days before the deadline I was racing. I did it myself, with my own hands, in the same week I was preparing to protect it, and I did it because shipping the code was the obvious thing to do that day.

The part that is actually interesting

The flattering version of this story is that I caught it in time. That is not much of a story. The check took one command and it should have been the first thing anyone ran.

The interesting part is that the filing guide warned about exactly this, and could not resolve it. Its own words: your public repos may already have started a disclosure clock, an attorney should assess it, that does not change what you do today. So the document knew the question existed, knew it was decisive, and routed it to a person who was not going to be consulted before the deadline. It handled a fact it could not verify by writing a paragraph about it.

I do that constantly. The paragraph feels like diligence. It is the opposite: it is the moment you convert a checkable fact into a caveat and move on, and a caveat never gets checked because it already looks like it has been dealt with.

What was in it

The claim, in plain language: a cheap classifier decides whether it is allowed to answer, or whether it has to escalate to an expensive language model, and it decides that with a structural test on the two inputs rather than a confidence score. If the two inputs name overlapping things, answer. If they name nothing, answer. If they name disjoint things with compatible intent, and only then, call the model. Claim 5 is the one I liked: it recites, positively, that the returned label contains no confidence field at all. The cheapness is not that the model is small. It is that most of the time no model runs.

The background section of my own specification lists the art it has to get past: FrugalGPT, learning-to-defer, calibrated cascade routing, conformal cascades, ensemble agreement, early abstention. Every one of them defers on a tuned statistical quantity. Mine defers on a structural condition. That is a real difference and I still think it is a real difference.

It is also the third angle I have tried to patent this year. The first two, both about whether a system can honestly attribute its own outputs, died under obviousness. My own launch document, written before any of today, has a line in it under things to kill this week: patent filing (weak). I wrote that. Then I spent Wednesday afternoon building the filing package anyway.

The two instincts, running in the same repository

Here is what I keep turning over. The open-source instinct and the patent instinct were both mine, both active, and they were operating on the same directory in the same week. One of them shipped deterministic.py to a public remote on Monday because that is what you do with working code. The other one was drafting claims about that file on Wednesday. Neither consulted the other. There was no argument, no decision, no moment where I weighed them, because they never met.

And the one that won was the one that acted first. Not the one with the better case. The default beat the deliberation, and the default was the good instinct, which is lucky, but it was luck.

The score, for anyone counting: outside the US, gone, four days ago. Inside the US the grace period runs twelve months from that commit, so the door stays open until roughly August 2027, and it is not a door I am going to walk through. My open-source contributions this year amount to one pull request against a repository I do not own, still open, waiting on a maintainer who is not me. That pull request has done more for me than eight pages of claims ever would have.

The honest limit: whether shipping the code counts as an enabling public disclosure of the claimed method is a legal question and I am not qualified to answer it. What I can tell you is that the specification says those files are the invention working, and those files are on the internet with my name on them, and I put them there.

This weekend I file nothing and submit two papers. That was going to be a decision. It turned out to be a receipt.