Sequences

Page version 1.1.0

Benchmarks

How Sequences did in recorded tests, and what each result means for a patent search. The tests compare the search methods Sequences runs, BLAST among them.

What the tests found

The benchmark behind most of these answers searched 28,757,943 DNA sequences and 10,491,135 proteins from patents. Each question below names the release of Sequences it was tested on, and the release notes say what each later release changed.

Which search fits your task

The search for each task, and the test that shows how it did
Your taskUse
A primer, probe or other short DNAAutomatic, which adds an exact scan to BLAST for short DNADoes it find short DNA, such as primers?
A peptide or other sequence that must appear letter for letterExact textDoes it count every exact match?
A variant claim, such as at least 90% identical to a SEQ ID NOSmith-Waterman, which Automatic runs for proteinDoes it find variants of a sequence?
A claim that allows a set number of changed lettersWithin k changesDoes it find every near match?
A search you may have to defendAny method: each search keeps a record of the versions, data and settings it ran withDo I get the same answer twice?
A sequence listing, before you file itThe listing checkDoes the listing check catch ST.26 errors?

For every method, see Choosing a search method, and for how long each takes, Searches measured on the hosted service.

Does it count every exact match?

Exact and pattern counts against GNU grep. Tested on Sequences 0.22.0, November 6, 2026.

Yes In 105 of 105 searches, Sequences counted the same matches as GNU grep, an independent text search of the same sequence files.

When a claim recites a peptide or a primer, a prior-art or freedom-to-operate search has to list every patent sequence that holds it.

How it ran, with every number

Exact text and Pattern count every stored sequence that holds a query. The benchmark of Sequences 0.22.0, run on November 6, 2026, checked each count against GNU grep, which read the same sequence files and shares no code with Sequences.

Data: snapshot 2026-11-05-c456f6bdba29 of the patent sets, with 28,757,943 DNA sequences of 15,612,493,945 bases in all and 10,491,135 proteins of 1,718,205,235 residues.

Matches counted by Sequences and by GNU grep
QueriesSearchesCounted by SequencesCounted by GNU grepEqual
DNA fragments of 15 to 50 bases72145,561145,56172 of 72
Peptides of 8 to 30 residues2031731720 of 20
DNA patterns724,221,00124,221,0017 of 7
Protein patterns66,360,2466,360,2466 of 6

105 of the 105 counts were equal, query by query. A match is a stored sequence that holds the query, counted once for each DNA strand that holds it.

Evidence: biosequence-benchmark-0.22.0.json, version 2.0.0.

Does it find short DNA, such as primers?

The exact scan and BLAST on short DNA fragments. Tested on Sequences 0.22.0, November 6, 2026.

Yes Automatic listed all 132,309 patent sequences that hold the 72 short DNA fragments it searched, 15 to 50 bases long. BLAST alone listed 75,570, 57.1%: Sequences runs it with a limit of 5,000 sequences for each query, and 41 of the 72 fragments reached that limit.

Claims often recite primers and probes. A prior-art check for one has to find every patent sequence that holds it, however many there are.

Share of the sequences GNU grep found that each method listed, by fragment lengthExact text listed 100% at 15 bases, 100% at 18 bases, 100% at 21 bases, 100% at 25 bases, 100% at 30 bases, 100% at 50 bases. BLAST listed 49.5% at 15 bases, 95.7% at 18 bases, 96.9% at 21 bases, 99.3% at 25 bases, 29.0% at 30 bases, 100% at 50 bases.Exact textBLAST0%25%50%75%100%Exact text, 15 bases: 100%BLAST, 15 bases: 49.5%15Exact text, 18 bases: 100%BLAST, 18 bases: 95.7%18Exact text, 21 bases: 100%BLAST, 21 bases: 96.9%21Exact text, 25 bases: 100%BLAST, 25 bases: 99.3%25Exact text, 30 bases: 100%BLAST, 30 bases: 29.0%30Exact text, 50 bases: 100%BLAST, 50 bases: 100%50Fragment length in bases
Table view
Stored sequences that hold the fragments: those GNU grep found, and those each method listed
LengthGNU grepExact textBLAST
15 bases38,14238,142 (100%)18,878 (49.5%)
18 bases10,09710,097 (100%)9,658 (95.7%)
21 bases14,01914,019 (100%)13,590 (96.9%)
25 bases9,6939,693 (100%)9,624 (99.3%)
30 bases51,46951,469 (100%)14,931 (29.0%)
50 bases8,8898,889 (100%)8,889 (100%)
All132,309132,309 (100%)75,570 (57.1%)
Each bar is a method's share of the patent sequences GNU grep found. GNU grep found the 30-base fragments in the most sequences: 51,469. The table view gives every count.
How it ran, with every number

The benchmark of Sequences 0.22.0 cut 72 fragments of 15 to 50 bases from stored patent DNA, unchanged, 12 of each length. Each was searched with Exact text, which scans every stored sequence, and with BLAST, and GNU grep listed every stored sequence that holds it.

Fragments whose source sequence came back
LengthExact textBLAST
15 bases12 of 1210 of 12
18 bases12 of 1212 of 12
21 bases12 of 1212 of 12
25 bases12 of 1212 of 12
30 bases12 of 1211 of 12
50 bases12 of 1212 of 12
All72 of 7269 of 72

Exact text listed every sequence GNU grep found, 132,309 of 132,309. BLAST listed 75,570: it listed at most 5,000 sequences for each query, and 41 of the 72 fragments reached that limit. BLAST also did not return the stored sequence that 3 of the fragments were cut from. Automatic, which adds an exact scan for short DNA, listed all 132,309.

Evidence: biosequence-benchmark-0.22.0.json, version 2.0.0.

Does it find variants of a sequence?

Finding altered sequences. Tested on Sequences 0.22.0, November 6, 2026.

Mostly Smith-Waterman, which Automatic runs for protein, found 60 of 60 protein fragments that were 90% identical to their source, and 39 of 60 that were 40% identical. At every level of identity it found more than BLAST.

A variant claim reaches sequences that differ from the one it recites, such as those at least 90% identical to it. A prior-art or freedom-to-operate search has to find them too.

Queries found at each level of identity, of 60At 100% identity, Smith-Waterman found 60, BLAST 54 and Exact text 60. At 95% identity, Smith-Waterman found 60, BLAST 54 and Exact text 6. At 90% identity, Smith-Waterman found 60, BLAST 53 and Exact text 0. At 80% identity, Smith-Waterman found 58, BLAST 51 and Exact text 0. At 70% identity, Smith-Waterman found 58, BLAST 49 and Exact text 0. At 60% identity, Smith-Waterman found 55, BLAST 44 and Exact text 0. At 50% identity, Smith-Waterman found 48, BLAST 40 and Exact text 0. At 40% identity, Smith-Waterman found 39, BLAST 33 and Exact text 0.Smith-WatermanBLASTExact text015304560Smith-Waterman, 100% identity: 60Smith-Waterman, 95% identity: 60Smith-Waterman, 90% identity: 60Smith-Waterman, 80% identity: 58Smith-Waterman, 70% identity: 58Smith-Waterman, 60% identity: 55Smith-Waterman, 50% identity: 48Smith-Waterman, 40% identity: 39BLAST, 100% identity: 54BLAST, 95% identity: 54BLAST, 90% identity: 53BLAST, 80% identity: 51BLAST, 70% identity: 49BLAST, 60% identity: 44BLAST, 50% identity: 40BLAST, 40% identity: 33Exact text, 100% identity: 60Exact text, 95% identity: 6Exact text, 90% identity: 0Exact text, 80% identity: 0Exact text, 70% identity: 0Exact text, 60% identity: 0Exact text, 50% identity: 0Exact text, 40% identity: 0100%95%90%80%70%60%50%40%Identity to the source sequence
Table view
Queries found at each level of identity, of 60
IdentitySmith-WatermanBLASTExact text
100%605460
95%60546
90%60530
80%58510
70%58490
60%55440
50%48400
40%39330
Each line is a method, with the queries it found at each level of identity, of 60. A query counts as found when the sequence it was cut from comes back. The table view gives the same numbers.
How it ran, with every number

The benchmark cut peptides and proteins of 8 to 500 residues from stored patent proteins and changed letters at random, keeping 100% down to 40% of them, which is each query's identity to the sequence it was cut from, 60 queries at each level. A query counts as found when the stored sequence it was cut from comes back. For proteins, Smith-Waterman ran as the automatic choice.

In all, Smith-Waterman found the most of these queries, then BLAST, then Exact text, and the other altered sets gave the same order:

Queries found, by method
QueriesSearchedSmith-WatermanBLASTExact text
Proteins, letters changed at random, 100% to 40% kept48043837866
Proteins, letters changed as BLOSUM62 weighs them, 95% to 40% kept2101921593
Proteins with 2 to 10 insertions or deletions per 100 residues9083740
DNA fragments of 21 to 50 bases, 95% to 80% kept6053470

Evidence: biosequence-benchmark-0.22.0.json, version 2.0.0.

Does it find every near match?

Within k changes on the fragments Smith-Waterman missed. Tested on Sequences 0.95.0 before its release, November 15, 2026.

Yes Within k changes found all 20 changed DNA fragments it searched, among them the 7 of 60 that Smith-Waterman missed in the benchmark.

Some claims allow a set number of changed letters. Within k changes lists every patent sequence within that number, with no score cutoff, so its counts are complete.

How it ran, with every number

In the benchmark, Smith-Waterman missed 7 of the 60 altered DNA fragments. Within k changes lists every stored sequence that differs from a query by at most k changes, with no score or E-value cutoff. On November 15, 2026, in the test runs before its release in Sequences 0.95.0, it searched all 20 fragments of the 4 groups that held those misses: first counting substitutions only, then insertions and deletions too.

Fragments found in the 4 groups that held the misses
FragmentsLetters changedSmith-WatermanWithin k changes
21 bases, 90% kept24 of 55 of 5
21 bases, 80% kept41 of 55 of 5
30 bases, 95% kept24 of 55 of 5
50 bases, 95% kept34 of 55 of 5
The k each group's fragments needed to come back
FragmentsSubstitutions onlyInsertions and deletions too
21 bases, 90% kept22
21 bases, 80% kept43 to 4
30 bases, 95% kept22
50 bases, 95% kept33

No fragment needed a k larger than its changed letters, and k = 4 was the most any needed. Across the benchmark's queries with up to 5 letters changed, Within k changes found the stored sequence each was cut from at k equal to its changes: 186 of 186 protein queries and 117 of 117 DNA queries.

Evidence: 2026-11-15-within-k-changes-release, version 1.0.0; 2026-11-15-pilot-within-k-changes/results/golines.json, version 1.0.0; biosequence-benchmark-0.22.0.json, version 2.0.0.

Do I get the same answer twice?

Repeat runs give the same hits. Tested on Sequences 0.22.0, November 6, 2026, and 0.95.0, November 15, 2026.

Yes The same 1,173 Smith-Waterman and global searches, run three times, gave the same hits, scores and E-values each time. The benchmark also ran every query twice with each method, and each search found, or missed, its source sequence both times.

A search you rely on before the patent office or in court has to give the same result when someone runs it again.

How it ran, with every number

The benchmark of Sequences 0.22.0 ran every query twice. All 5,182 results, one for each query and method, were the same in both runs: whether the source sequence came back, every Exact text and Pattern count, and how many of the sequences GNU grep found each listed. But 265 of its 1,173 Smith-Waterman and global searches listed a different number of sequences, by up to 1,119, because the sample of scores behind their E-values could change from run to run.

Sequences 0.95.0 ships a build of FASTA36, the program behind those methods, that draws the same sample on every run. On November 15, 2026, that build ran the same 1,173 searches three times: runs A and B on 8 threads each, and run C on 12.

Searches that differed between two runs of the repeatable build: in their count of hits, in the sequences they listed, or in their rows, scores and E-values
RunsSearchesCountSequencesRows
A and B1,173000
A and C1,173000
B and C1,173000

Evidence: biosequence-benchmark-0.22.0.json, version 2.0.0; 2026-11-15-pilot-sw-repeatable, version 1.4.0.

Does the listing check catch ST.26 errors?

The ST.26 listing check. Tested on Sequences 0.35.0, November 7 to 10, 2026.

Yes The listing check flagged all 115 listings that ST.26 validation found errors in, and agreed with it on 182 of the 183 listings tested. They disagreed on one, whose first line, the XML declaration, does not state its character encoding: the check flags it, citing paragraph 39(a) of ST.26, and validation let it through.

The check runs before you file, so you can fix a listing before the patent office finds the problem.

How it ran, with every number

The listing check, on the Listings tab of Sequence tools, checks a WIPO ST.26 sequence listing before it is filed. From November 7 to 10, 2026, its results were compared with ST.26 validation results on 183 listings: a base listing with no errors, 20 listings with known problems, 161 that each change one thing in the base, and one real listing.

What ST.26 validation and the listing check found, of 183 listings
ResultListings
ST.26 validation found an error115
ST.26 validation found no error68
The listing check agreed: an error where validation found one, none where it found none182
The two differed1

They differed on one listing, whose XML declaration has no encoding: validation reported no error, and the listing check reports one, because paragraph 39(a) of ST.26 gives the declaration with its encoding.

Evidence: the listing check's record of November 8, 2026, version 1.1.1.

How long does a whole patent take?

A search plan for 1,034 SEQ ID NOs. Tested on Sequences 0.85.0 on the hosted service, November 14, 2026.

82.5 minutes for one patent's 1,034 claimed SEQ ID NOs, the 1,026 with a sequence in its listing, searched in Patent proteins and Swiss-Prot with Smith-Waterman. The plan expected 93 minutes.

A freedom-to-operate search may have to cover every SEQ ID NO a patent's claims recite. A search plan says how long that will take before it starts.

How it ran, with every number

A search plan turns the SEQ ID NOs a patent's claims recite into searches. On November 14, 2026, the hosted service, then running Sequences 0.85.0, ran a plan for US 12,780,932 B1, whose claims recite 1,034 SEQ ID NOs. Its sequence listing skips 8 of them, so the plan searched the other 1,026, all proteins, with Smith-Waterman on Patent proteins and Swiss-Prot: 2,052 queries of 152,040 letters in all, as 104 jobs, 2 at a time.

The run time expected when the plan was locked, and the time each run took
RunSearchedJobsExpectedTook
Run 1Patent proteins5265 minutes75.9 minutes
Run 2Swiss-Prot5228 minutes6.7 minutes
BothPatent proteins and Swiss-Prot10493 minutes82.5 minutes

Both is the time from the first job's start to the last job's end, and each time is rounded to a tenth of a minute.

All 104 jobs completed, in 82.5 minutes against the 93 the plan expected. The total came in under the estimate; the split between the two runs did not match it.

Evidence: 2026-11-14-query-groups-pilot, version 1.0.0.

Do more servers run more searches?

Searches an hour with more workers. Tested on Sequences 0.92.0, November 15, 2026.

Yes With 3 workers, a server ran 2.04 times as many searches an hour as it did alone: 741.5 against 363.6.

A team that runs many searches on its own server can add workers to clear a queue sooner.

Searches an hour, 20 searches queued at onceThe server alone ran 363.6 searches an hour, 2 workers 598.5 and 3 workers 741.5.20 searches queued at once020040060080020 searches queued at once, the server alone: 363.6363.6Server alone20 searches queued at once, 2 workers: 598.5598.52 workers20 searches queued at once, 3 workers: 741.5741.53 workersServers running searches
Table view
Searches an hour, with 20 and with 100 searches queued at once
Servers20 queued100 queued
The server alone363.6Ran beside other work
2 workers598.5552.1
3 workers741.5828.0
The chart gives the batches of 20. The table view adds the batches of 100.
How it ran, with every number

A Sequences server can hand searches to workers, other servers that take searches from its queue. On November 15, 2026, Sequences 0.92.0 ran batches of 20 and 100 searches, each batch queued at once, on snapshot 2026-11-13-5e447c75c43f: on a server alone, then on a server with 2 and with 3 workers. Half of each batch were proteins searched with Smith-Waterman and half DNA searched with BLAST. Each search ran on 6 threads. Each worker had 6 CPUs of its own; the server alone had 8 and ran one search at a time.

With 20 searches queued, 2 and 3 workers ran 1.65 and 2.04 times as many searches an hour as the server alone. With 100 queued, 3 workers ran 1.50 times as many as 2. The batches on one worker, and the server alone's batch of 100, ran beside other work on the same computer, so the record leaves them out of these comparisons.

Evidence: 2026-11-15-scaling-measured, version 1.2.0.

Terms on this page

Automatic
The first method on the search form. It picks the method by the query: Smith-Waterman for protein, BLAST for DNA, and for short DNA an exact scan as well, so its exact matches are complete.
BLAST
NCBI's program for finding similar sequences, and one of the methods Sequences runs. It starts from short stretches that match exactly, which makes it fast. Sequences keeps up to 5,000 sequences for each BLAST query.
E-value
About how many hits this good a search of this size would find by chance alone, so the smaller it is, the less likely the match is chance.
Exact text
Finds the query letter for letter in every stored sequence.
FASTA36
The program behind Smith-Waterman and the global alignment methods.
Freedom-to-operate search
A search for patents whose claims could cover a product or process you plan to make, use or sell.
Global alignment
Aligns the whole query with each stored sequence, rather than only its best-matching stretch.
GNU grep
A standard text-search program. The benchmark ran it on the same sequence files to count matches independently; it shares no code with Sequences.
Identity
The share of places where two aligned sequences have the same letter. A variant claim may cover sequences at least 90% identical to one it recites.
Pattern
Finds every stored sequence that fits a pattern, such as a primer with places that can hold any of several bases. It reads every stored sequence, so its counts are complete.
Peptide, residue and base
A residue is one amino acid of a protein, a base is one letter of DNA, and a peptide is a short protein.
Prior-art search
A search for earlier publications, patents among them, that may already disclose what a claim covers.
SEQ ID NO
The number a sequence listing gives each sequence. Claims cite sequences by it.
Smith-Waterman
Aligns the query with every stored sequence and finds the best-matching stretch of each. It takes longer than BLAST, and in these tests it found more changed sequences.
Snapshot
A read-only copy of public sequence files, built on a known date.
ST.26
WIPO ST.26, the standard for the sequence listing filed with a patent application, as an XML file.
Swiss-Prot
UniProtKB/Swiss-Prot, the UniProt Consortium's public set of reviewed protein sequences.
Within k changes
Lists every stored sequence that differs from the query by at most k changes, counting substitutions only or insertions and deletions too, with no score or E-value cutoff, so its counts are complete.
Worker
Another server that takes searches from a Sequences server's queue.