01
The pipeline, not the weights
How training data is selected, cleaned, weighted, or synthesized is often more claimable than the architecture, and harder for a competitor to design around.
Software and data inventions face a hurdle mechanical ones do not. A software patent attorney earns their fee at the drafting stage, deciding how the invention is framed, because that decision is close to unfixable afterward.
Drawings from expired US patents. Lit: US 1,773,980, Philo T. Farnsworth, Television System, filed 1927, granted 1930.
An examiner reading a software application asks whether the claims recite an abstract idea, and if they do, whether anything in them amounts to significantly more than that idea run on a computer.
The same invention passes or fails that test depending on how it was written. Claims that recite a business outcome read as abstract. Claims that recite a specific change in how a system operates, and a specification that explains what that change improves, give the examiner something concrete to allow.
We draft with that examination in view. Where the improvement is in latency, memory, throughput, accuracy, or security, the specification says so and says by what mechanism, because that sentence is the one an examiner quotes when allowing the case.
Teams often assume the model is the invention. Frequently the defensible claim sits somewhere adjacent to it.
01
How training data is selected, cleaned, weighted, or synthesized is often more claimable than the architecture, and harder for a competitor to design around.
02
What gets retrieved, how it is ranked, and how context is assembled before inference are concrete steps a system performs, which makes them easier to claim than the generation itself.
03
Batching, caching, quantization, and routing between models produce measurable resource effects, and measurable effects support an eligibility argument.
Yes. Software is patentable in the United States when the claims recite more than an abstract idea implemented on a generic computer. The invention has to improve how something works, and the application has to say what that improvement is.
The label matters less than the drafting. Two applications covering the same system routinely get different outcomes because one described a technical improvement and the other described a business result.
Not as mathematics on its own. A mathematical formula, an abstract idea, and a law of nature are all outside what a patent can cover.
An algorithm applied to produce a specific technical effect is a different question, and that application is what the claims have to capture. The distinction sits in the wording, which is why algorithm-heavy inventions repay careful drafting more than almost anything else we handle.
They protect different things and most software companies end up with both. Copyright attaches automatically to the code as written and stops someone copying it. It does not stop a competitor writing their own code to do the same thing.
A patent covers the method, so it reaches an independent implementation. Where the value is in what the system does rather than in the particular lines that do it, the patent is the instrument that protects it.
An app is protected the same way any software is: through the underlying method it performs, not through the app as a product. The interface may separately support a design patent, and the name and icon are trademark questions.
A first call usually sorts out which of the three is carrying your actual commercial value.
Two separate bills arrive: attorney fees for searching, drafting, filing, and prosecution, and USPTO fees paid to the government. Software applications commonly run longer than mechanical ones because the specification has to carry more supporting detail.
We quote each stage before starting it, so you approve the cost of a step before we take it. Small and micro entities pay substantially reduced USPTO fees, and we check entity status before filing.
You can seek protection for what the system does and how it does it. A trained model's weights are not themselves the sort of thing a patent claim captures well, and disclosing them publicly is rarely what a company wants.
In practice the durable claims tend to sit in the pipeline around the model: how data is prepared, how retrieval and context assembly work, and how inference is served. Some of that may be better kept as a trade secret, which is a conversation worth having before anything is filed.
Describe what the system does differently and we will tell you where the claimable surface is, and whether it is worth filing on.