For object detection in business projects, teams usually choose between Ultralytics YOLO and transformer-based models RT-DETR, D-FINE, and RF-DETR. Based on published measurements on the COCO dataset, they are close in accuracy and speed. The main practical difference is licensing: the Ultralytics package is distributed under AGPL-3.0 or a paid enterprise license, RT-DETR and D-FINE are under Apache-2.0, and for RF-DETR the Nano–Large model sizes are open under Apache-2.0, while the smallest and largest models are covered by a separate PML 1.0 license. The final choice is made based on testing on your own images.
Prepared by AIrassvet October 24, 2026 for manufacturing, warehouse, and IT leaders who are launching a computer vision project or accepting one from a contractor. The figures are taken from repositories and model cards; licenses were verified through the GitHub and PyPI APIs on October 24, 2026. We did not run our own measurements, and this article is not legal advice.
Contents
- At a Glance
- Which Models We Compare and Why
- How We Compared Them
- Comparison by Criteria
- Accuracy and Speed in One Measurement
- License: the Main Non-Technical Criterion
- When to Choose Which
- How to Compare Models on Your Own Data
- Frequently Asked Questions
- Primary Sources
At a Glance
- YOLO26 (Ultralytics) — the most mature ecosystem: training, export, and deployment in just a few commands. AGPL-3.0 license; for a closed-source product, Ultralytics offers a paid Enterprise License.
- RF-DETR (Roboflow) — a transformer model with a fine-tuning package. Nano, Small, Medium, and Large are Apache-2.0; Atto, Femto, Pico, XLarge, and 2XLarge are PML 1.0.
- D-FINE — a research model with open code under Apache-2.0 and high COCO accuracy in measurements by the authors and Roboflow.
- RT-DETR — the first widely known real-time transformer model (CVPR 2024), Apache-2.0, available in the Hugging Face Transformers library.
- No public benchmark can replace testing on your own images: shooting conditions, classes, and object sizes in production differ from COCO.
Which Models We Compare and Why
Object detection is a task where a model finds objects in an image and draws a rectangular box around each one with a class label: a defective part, a box on a pallet, a person without a hard hat. Most industrial computer vision projects are built on this task. We covered how to choose the right task type — classification, detection, or segmentation — in the article “Computer Vision for Quality Control in Manufacturing”.
The comparison includes four families that, as of October 24, 2026, are actively being developed and have model weights published. We are not comparing segmentation, classification, or text-based object retrieval models: those are different tasks with different metrics.
| Model | Developer | Architecture | Latest repository activity |
|---|---|---|---|
| YOLO26 | Ultralytics | Convolutional, YOLO family | Release v8.4.185 dated 10/24/2026 |
| RF-DETR | Roboflow | Transformer based on DINOv2 | Release 1.11.2 dated 10/04/2026 |
| D-FINE | Article authors arXiv 2410.13842 | Transformer (DETR) | Changes dated 10/05/2026 |
| RT-DETR | Article authors arXiv 2304.08069 | Transformer (DETR) | Changes dated 10/09/2026 |
Transformer-based DETR-family detectors output the final set of boxes without a separate non-maximum suppression (NMS) step, which simplifies deployment. For YOLO26, Ultralytics publishes a separate accuracy column in no-NMS (end-to-end) mode.
How We Compared Them
- Accuracy — AP50:95 metric (also called mAP50-95) on the validation split of COCO val2017, which has 5,000 images: mean accuracy across box overlap thresholds from 0.5 to 0.95. Higher is better.
- Speed — latency per image on an NVIDIA T4 GPU with TensorRT, as published by the developers.
- Transfer to Other Tasks — metric on the RF100-VL dataset (100 heterogeneous datasets), which Roboflow includes in its table.
- License — based on GitHub API, PyPI, and README data as of October 24, 2026.
- Ease of Implementation — based on the documentation: whether there is a package, training commands, and export commands.
Important note: the only table where all four families are measured under the same conditions was published by Roboflow, the developer of RF-DETR. The methodology is open (SAB repository), but this is a measurement by an interested party. That is why we also include the models’ own authors’ figures alongside it.
Comparison by Criteria
| Criterion | YOLO26 | RF-DETR | D-FINE | RT-DETR |
|---|---|---|---|---|
| Code and weights license | AGPL-3.0 or paid Enterprise License | Apache-2.0 (N, S, M, L); PML 1.0 (A, F, P, XL, 2XL) | Apache-2.0 | Apache-2.0 |
| COCO accuracy, medium size, Roboflow benchmark | 52.5 (M) | 54.7 (M) | 55.0 (M) | Not in the table |
| T4 latency, medium size, Roboflow benchmark | 4.4 ms | 4.4 ms | 5.4 ms | Not in the table |
| Transfer to RF100-VL, AP50:95, medium size | 58.7 | 61.2 | 60.6 | Not in the table |
| Lightest model (parameters) | YOLO26n — 2.4M | RF-DETR Nano — 30.5M (Apache-2.0) | D-FINE-N — 3.8M | RT-DETR-R18 — 20M |
| Duplicate suppression (NMS) | NMS-free mode available | Not needed | Not needed | Not needed |
| Ease of deployment | Package, CLI, export to ONNX and TensorRT, detailed documentation | Package rfdetr, fine-tuning examples |
Research repository with configurations | Research repository; available in Hugging Face Transformers |
The number of parameters for RF-DETR and D-FINE is taken from the Roboflow table, for YOLO26 from the Ultralytics README, and for RT-DETR from the authors' README.
Accuracy and speed in one benchmark
Below is an excerpt from the RF-DETR README: AP50:95 accuracy on COCO val2017 and latency on T4 (TensorRT, FP16, single-image batch). According to Roboflow, all rows were measured in the same setup and are therefore directly comparable.
| Size | YOLO26 | RF-DETR | D-FINE |
|---|---|---|---|
| Nano | 40.3 / 1.7 ms | 48.4 / 2.3 ms | 42.7 / 2.1 ms |
| Small | 47.7 / 2.6 ms | 53.0 / 3.5 ms | 50.6 / 3.5 ms |
| Medium | 52.5 / 4.4 ms | 54.7 / 4.4 ms | 55.0 / 5.4 ms |
| Large | 54.1 / 5.7 ms | 56.5 / 6.8 ms | 57.2 / 7.5 ms |
| XLarge | 56.9 / 9.6 ms | 58.6 / 11.5 ms (PML 1.0) | 59.3 / 11.5 ms |
Note the resolution: YOLO26 and D-FINE in this benchmark run at 640×640 pixels, while RF-DETR uses different resolutions, from 384×384 for Nano to 704×704 for Large. For small objects in a large frame, that matters a lot.
What the authors themselves publish. Ultralytics lists YOLO26 on COCO val2017 with accuracy of 40.9 (n), 48.6 (s), 53.1 (m), 55.0 (l), and 57.5 (x), with T4 latency from 1.7 to 11.8 ms. The D-FINE authors, for models pretrained on Objects365, report 50.7 (S), 55.1 (M), 57.3 (L), and 59.3 (X). The RT-DETR authors report 46.5 for R18, 53.1 for R50, and 54.3 for R101 on COCO. The differences from the Roboflow table by a few tenths of a point are a normal result of different test setups.
What the numbers tell us. At the medium-model level, the difference in COCO accuracy is 2–3 points, and latency for all of them stays within a few milliseconds on a server GPU. For most production tasks, that difference is smaller than the impact of lighting, camera angle, and annotation quality. Licensing, meanwhile, can change the project budget immediately.
Licensing: the main non-technical criterion
AGPL-3.0 (Ultralytics). According to the Ultralytics README, the open-source AGPL-3.0 license is intended for students, researchers, and enthusiasts, while for use in business products, internal tools, and production, the company offers a paid Enterprise License. The key AGPL requirement is Section 13: if you modified the program, users who interact with it over the network must be given the source code of your version. For a closed-source product or cloud service, that is a serious limitation. How AGPL applies to your architecture is for a lawyer to decide: we are only describing the terms published by the rights holder.
This also applies to other models if you run them through the ultralytics package: the package license, not the original article, determines the terms. Two other popular YOLO-family repositories also use copyleft licenses: YOLOv9 — GPL-3.0, YOLOv10 — AGPL-3.0.
Apache-2.0 (RT-DETR, D-FINE, RF-DETR N–L). Permissive license: the code and weights can be used in a closed-source commercial product, provided the notice and license text requirements are met.
PML 1.0 (RF-DETR Atto, Femto, Pico, XL, 2XL). These models are included in a separate package rfdetr-plus; on PyPI it is marked as LicenseRef-PML-1.0. We could not find the public license text in the package repository as of October 24, 2026. Before building these models into your project, request the terms from Roboflow.
A similar framework for checking what rights the weights and code grant, and what changes when you embed them in a product, is described in the article “Licenses for Open LLMs: Questions and Answers”.
When to choose what
- You need a fast prototype, and you have the budget for a license or the code will be open-sourced. YOLO26: the shortest path from a labeled dataset to a working model and deployment to a device.
- A closed-source commercial product or cloud service without purchasing a license. RF-DETR in Nano–Large sizes, D-FINE, or RT-DETR under Apache-2.0.
- Few labeled images and unusual objects. Start with models that transfer better to new domains on RF100-VL (in Roboflow’s benchmark, that is RF-DETR and D-FINE), but verify it with your own test.
- Maximum accuracy on a server GPU. D-FINE-X (Apache-2.0) or RF-DETR XL/2XL (PML 1.0, terms need to be clarified).
- A weak device without a GPU. Compare only the lightest models and measure latency on the target hardware: for example, Ultralytics reports YOLO26n ONNX CPU latency of about 39 ms, but it will be different on your device.
- Your team already works with Hugging Face Transformers. RT-DETR and RT-DETRv2 are available there directly.
How to compare models on your own data
- Build a test set from real-world conditions. Images from the same camera, lighting, and angle where the system will run, including hard cases. How to label them correctly is described in the guide “Data Labeling for Computer Vision”.
- Separate test data from training data. Images from the same batch or shift should not be used in both training and validation.
- Fine-tune 2–3 candidates the same way. Same data, input resolution, and number of epochs; record package versions.
- Compare business metrics, not just AP. How many defects were missed and how many false alarms per shift—what production actually sees.
- Measure latency on the target hardware. With the same export format (ONNX, TensorRT) you will use in production.
- Check the license for the selected stack. The training code, weights, and runtime library may each have their own license.
A similar approach to a warehouse pilot is discussed in the article “Video Analytics for Warehouses”.
Frequently asked questions
Can YOLO be used in a commercial project for free?
The Ultralytics package with YOLO26 is distributed under AGPL-3.0. This license allows commercial use, but requires you to disclose the source code of the modified version, including to users accessing it over the network. For closed-source products and internal systems, Ultralytics offers a paid Enterprise License. Check with your lawyer for how this applies to your project.
Which is more accurate: YOLO or RT-DETR?
It depends on the version and size. In the authors’ benchmarks, RT-DETR-R50 delivers 53.1 AP on COCO, and YOLO26m, according to Ultralytics, also scores 53.1, so it’s a tie. Newer transformer models D-FINE and RF-DETR are slightly more accurate than YOLO26 of the same size in Roboflow’s benchmark. On your data, the difference may be different.
How is RF-DETR different from D-FINE?
Both are real-time transformer detectors. RF-DETR uses a DINOv2 backbone and is distributed as the rfdetr package with fine-tuning tools and different input resolutions for different sizes. D-FINE is a research repository with training configurations; all models are under Apache-2.0. RF-DETR has some sizes released under a separate PML 1.0 license.
Which model is best for edge devices?
The one that delivers acceptable accuracy at the required latency on the specific device. By parameter count, the lightest are YOLO26n (2.4 million) and D-FINE-N (3.8 million). But latency depends on the processor, accelerator, and export format, so candidates should be measured on the target hardware, not just compared by tables.
Can you switch models after the project launches?
Yes, if the annotations are stored in a standard format, such as COCO, and the application code is not tied to a single library. Then switching models comes down to fine-tuning and re-validating on the test set. It’s worth building this into the contractor requirements from the start.
Primary sources
- Ultralytics on GitHub — AGPL-3.0 license, Enterprise License terms, YOLO26 table.
- RF-DETR on GitHub — COCO and RF100-VL comparison table, Apache-2.0 and PML 1.0 licenses; rfdetr-plus package on PyPI.
- D-FINE on GitHub and arXiv paper 2410.13842.
- RT-DETR on GitHub and arXiv paper 2304.08069.
- AGPL-3.0 license text on the Open Source Initiative website.
- YOLOv9 and YOLOv10 — licenses according to GitHub.
All data was checked on October 24, 2026. The accuracy and speed figures belong to the model developers and Roboflow; we did not reproduce them.
How AIrassvet helps you choose a computer vision model
Choosing a model is part of a computer vision project, and it is decided using images from the specific production line or warehouse. Among the directions listed on the AIrassvet websitethere are options that can handle this work:
- computer vision solutions for documents and industrial processes: defining the detection task and selecting candidates with licensing in mind;
- data preparation: a test set from real-world capture conditions and labeling guidelines;
- testing and deployment: comparing 2–3 models on your images by false negatives and false positives, and integrating the selected model.
The first step is to choose one area where detection is needed and document the current result, data sources, constraints, and acceptance criteria.
Bottom line: license and testing first, accuracy percentages second
YOLO26, RF-DETR, D-FINE, and RT-DETR are close in accuracy and speed on COCO: the difference between average models is just a few AP points and a few milliseconds. Licenses differ much more: AGPL-3.0 or a paid license from Ultralytics, Apache-2.0 for RT-DETR, D-FINE, and the main RF-DETR line, and PML 1.0 for some RF-DETR models.
So the selection order is this: determine whether a copyleft license is acceptable for your product, shortlist 2–3 candidates, and compare them on real-world images by misses, false positives, and latency on your target hardware.
