Roboflow

YOLO26 Overview

YOLO26 is a real-time object detection model developed by Ultralytics, released in October 2025. It introduces a native end-to-end, NMS-free architecture that eliminates the Non-Maximum Suppression post-processing step, reducing CPU latency by up to 43% for the Nano variant compared to NMS-dependent versions. The model incorporates the MuSGD optimizer and ProgLoss with STAL for improved training stability and small-object detection, and removes Distribution Focal Loss to ensure maximum compatibility with ONNX and TensorRT export targets.

YOLO26 supports object detection, instance segmentation, pose estimation, and oriented bounding box detection within a unified framework, with model sizes available from Nano to Extra Large. Its NMS-free design makes it particularly well suited for deployment scenarios where post-processing overhead is a bottleneck, such as embedded systems and real-time edge inference pipelines.

YOLO26 Interactive Demo

YOLO26 Details & Performance

Details

Resources

Vision Tasks

Instance SegmentationObject Detection

Features

Usage

Past 30 Days

Performance

Avg. Latency

Arena Rankings

Not yet ranked in arena

Alternatives to YOLO26

Other models worth comparing for similar use cases.

YOLO11
YOLO11 is an object detection and multi-task vision model developed by Ultralytics, released in September 2024 under the AGPL-3.0 license. It is the latest generation in the Ultralytics YOLO series and supports object detection, instance segmentation, image classification, pose estimation, and oriented bounding box detection within a single unified framework. YOLO11 introduces architectural refinements that improve accuracy while reducing parameter count compared to YOLOv8 at equivalent model sizes.YOLO11 is available in five model sizes from Nano to Extra Large and is deployable through the Ultralytics Python package, Roboflow Inference, and export formats including ONNX, TensorRT, and CoreML. It supports fine-tuning on custom datasets through the standard Ultralytics training API.
YOLOv12
YOLOv12 is an attention-centric real-time object detection model developed by researchers at Tsinghua University, with the arXiv paper published in February 2025 under the AGPL-3.0 license. It introduces an Area Attention module that partitions feature maps into regions and applies self-attention within each region, reducing the quadratic complexity of full self-attention while capturing long-range dependencies. It also incorporates R-ELAN for improved feature aggregation and scaled residual connections for training stability.YOLOv12-L achieves 54.0% AP on COCO, while the YOLOv12-N variant achieves 40.5% mAP at 1.62ms latency on an NVIDIA T4 GPU. The model is built on the Ultralytics codebase, supporting detection, segmentation, and other standard YOLO tasks at competitive real-time speeds.
RF-DETR
RF-DETR is a real-time transformer-based object detection model developed by Roboflow, with code and weights first released in March 2025 under the Apache 2.0 license. It is the first real-time model to exceed 60 AP on the Microsoft COCO benchmark, built on a DINOv2 vision transformer backbone with weight-sharing neural architecture search used to identify accuracy-latency trade-offs. The full family spans six sizes from Nano (30.5M parameters, 384×384 input) to 2XL (126.9M parameters, 880×880 input), with the accompanying research paper accepted to ICLR 2026.RF-DETR is designed for strong domain adaptability, achieving state-of-the-art performance on RF100-VL, a benchmark measuring generalization to real-world object detection tasks across diverse domains. It is deployable through Roboflow Inference and supports fine-tuning on custom datasets, making it well suited for domain-specific applications with limited training data.
RF-DETR Segmentation
RF-DETR Segmentation is a real-time instance segmentation model developed by Roboflow, with a preview base model released in October 2025 under the Apache 2.0 license and the full variant family — Nano through 2XL — released in January 2026. It extends the RF-DETR object detection architecture with a segmentation head inspired by MaskDINO, enabling pixel-level object delineation while maintaining the real-time performance characteristics of the base model. It is deployable through Roboflow Inference and the open-source rfdetr Python package.RF-DETR Segmentation supports fine-tuning on custom COCO- or YOLO-format instance segmentation datasets and is benchmarked on Microsoft COCO. It is suited for applications requiring both precise object masks and real-time inference, such as robotic manipulation, quality control, and augmented reality overlays.
D-FINE
D-FINE is a real-time object detection model introduced in October 2024 by researchers at the University of Science and Technology of China. It builds on the DETR family of transformer-based detectors by reformulating bounding box regression as a Fine-grained Distribution Refinement task. Rather than predicting box coordinates directly, D-FINE iteratively refines probability distributions over coordinate offsets across decoder layers, which provides finer localization granularity without adding inference cost. The architecture also replaces the encoder's CSP blocks with GELAN modules and inserts a Target Gating Layer after the decoder's cross-attention to reduce representational entanglement across queries. A second contribution, Global Optimal Localization Self-Distillation, transfers localization knowledge from refined deeper-layer predictions back to earlier decoder layers through internal self-distillation.D-FINE is released in five model sizes (Nano, Small, Medium, Large, and X), with D-FINE-L achieving 54.0% AP on the Microsoft COCO benchmark at 124 FPS on an NVIDIA T4 GPU, and D-FINE-X reaching 55.8% AP at 78 FPS. Pretraining on the Objects365 dataset further improves accuracy to 57.1% AP for the L variant and 59.3% AP for the X variant. The paper was accepted at ICLR 2025 as a Spotlight. Code and pretrained weights are released under the Apache 2.0 license, making the model suitable for commercial use.
YOLOv9
YOLOv9 is a real-time object detection model developed by Chien-Yao Wang and Hong-Yuan Mark Liao at Academia Sinica, released in February 2024 under the GPL-3.0 license. It introduces Programmable Gradient Information (PGI), a mechanism that preserves complete input information through auxiliary reversible branches during training to address information loss in deep network layers. It also introduces the Generalized Efficient Layer Aggregation Network (GELAN), which achieves better parameter utilization compared to prior CSP-based designs.YOLOv9-C achieves 53.0% AP on COCO with 42% fewer parameters and 21% less computation than YOLOv8-C at comparable accuracy. YOLOv9-E achieves 55.6% AP. The model is deployable through Roboflow Inference and supports fine-tuning via the standard training pipeline in the official repository.

Deploy YOLO26 with an API

YOLO26 runs as a hosted REST endpoint through Roboflow Workflows. Pick a task, then hand the prompt to your coding agent or copy the code. Deploying the workflow into a free Roboflow workspace replaces the your-workspace and YOUR_API_KEY placeholders with your own.

Connect your agent to Roboflow (once)

Add the Roboflow MCP server

claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp

Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.

Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).

Deploy this workflow to your Roboflow workspace to use it.

Integrate the Roboflow "YOLO26" workflow into my app.

- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/yolo26-object-detection-coco-medium
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value } } }.

With the Roboflow MCP connected, call `workflows_get` on "yolo26-object-detection-coco-medium" to read the exact input schema (the source of truth), then `workflows_run` on a sample image to confirm the output shape before writing code (the MCP is authenticated, so this needs no key). Without the MCP, use the contract above.

Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.

Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.
Installpip install inference-sdk

Deploy this workflow to your Roboflow workspace to use it.

# 1. Import the library
from inference_sdk import InferenceHTTPClient

# 2. Connect to your workflow
client = InferenceHTTPClient(
  api_url="https://serverless.roboflow.com",
  api_key="YOUR_API_KEY"
)

# 3. Run your workflow on an image
result = client.run_workflow(
  workspace_name="your-workspace",
  workflow_id="yolo26-object-detection-coco-medium",
  images={
    "image": "YOUR_IMAGE.jpg"  # Path to your image file
  },
  use_cache=True  # cache workflow definition for 15 minutes
)

# 4. Get your results
print(result)

Deploy this workflow to your Roboflow workspace to use it.

const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/yolo26-object-detection-coco-medium', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    inputs: {
      "image": {"type": "url", "value": "IMAGE_URL"}
    }
  })
});

const result = await response.json();
console.log(result);

Deploy this workflow to your Roboflow workspace to use it.

curl --location 'https://serverless.roboflow.com/your-workspace/workflows/yolo26-object-detection-coco-medium' \
--header 'Content-Type: application/json' \
--data '{
  "api_key": "YOUR_API_KEY",
  "inputs": {
    "image": {"type": "url", "value": "IMAGE_URL"}
  }
}'

YOLO26 License

AGPL-3.0 · Restrictive license

YOLO26 is released under AGPL-3.0, the most restrictive of the common model licenses. AGPL-3.0 requires the user to open-source any code changes they make, including the code of any other projects that connect directly to the model, so the YOLO26 license usually means a separate commercial license for business use.

Commercial use
Permitted only if you are willing and able to open-source related code. Otherwise YOLO26 requires a separate commercial license — the usual path for businesses.
Modification
Permitted. Modified versions must be offered under AGPL-3.0, including to users who only ever reach the model over a network.
Redistribution
Permitted with the complete corresponding source, under the same license.

Serving YOLO26 behind an API or inside a hosted product counts: AGPL-3.0 reaches the code of other projects that connect directly to the model, which is what catches most commercial deployments by surprise.

Read the full AGPL-3.0 license ↗

Do I need a commercial license for YOLO26?

A commercial license is a separate license which gives you the right to use YOLO26 without an obligation to open-source related code changes. Roboflow plans include commercial licenses for the supported models listed on the licensing page, scoped by deployment method: Roboflow Managed Cloud on Public plans, a Self-Hosted Inference Server on Core, and deployment outside the Roboflow ecosystem on Enterprise.

Do not hesitate to reach out with questions for your commercial project — our team will help you start solving business problems on the first call. See Roboflow commercial licensing for the models included in each plan.

Talk to sales

This model is released under the GNU Affero General Public License v3.0 (AGPL-3.0), a strong copyleft license. Like GPL-3.0, derivative works must be released under the same license, and AGPL-3.0 extends this requirement to network deployment.

Commercial use is permitted under AGPL-3.0, but if you offer this model as part of a network service (such as a public API or web app), you must make the complete source code of your modified version available to all users of that service. Many commercial users prefer to acquire a separate license from the model authors to avoid this requirement.

AGPL-3.0 closes the "SaaS loophole" in GPL-3.0: even hosting the model behind an API counts as distribution and triggers the source-disclosure requirement.

To use YOLO26 in a commercial project without the AGPL-3.0 conditions, you need a commercial license. As a paid Roboflow customer, you're automatically granted commercial-use rights for YOLO26 models trained on or uploaded to our platform. See the Roboflow Licensing guide for the deployment-method by plan matrix.

If you're a free Roboflow customer, you can use YOLO26 through our serverless hosted API at no cost. Self-hosted commercial use requires a paid plan.

License information is provided as a guide and is not legal advice.

Frequently Asked Questions About YOLO26

YOLO26 is a pretrained computer vision model for object detection and instance segmentation. Unlike a general vision language model, it returns structured predictions for its task rather than free text.

YOLO26 comes in 6 sizes: Nano (640×640), Small (640×640), Medium (640×640), Large (640×640), XL (640×640), Extra Large (640×640). Smaller variants run faster on constrained hardware; larger ones trade speed for accuracy. You can switch sizes in the demo to compare them on the same image.

Yes. The demo on this page runs YOLO26 in the free Roboflow Playground: upload an image and see results in seconds. A free account unlocks unlimited runs.