Overview

YOLO26 is an object detection model from ultralytics that detects objects across 80 COCO classes. The model comes in five size variants—nano (n), small (s), medium (m), large (l), and extra-large (x)—allowing you to trade inference speed for detection accuracy. You select the size at inference time, making it flexible for different deployment constraints. The model uses anchor-free detection architecture and is trained on the COCO dataset, providing broad coverage of everyday objects, animals, vehicles, and scenes. Before choosing this model, understand that it requires adjusting confidence and IoU thresholds for your specific use case, and output quality depends heavily on image quality and object visibility.

Best use cases

Real-time surveillance and security monitoring. YOLO26 small and nano variants run fast enough on edge devices to monitor live video feeds for intrusions, unusual activity, or specific objects. The model detects people, vehicles, backpacks, and other relevant security objects with sufficient speed for frame-by-frame processing on modest hardware.

Automated content moderation and filtering. Content platforms use object detection to flag inappropriate items or unsafe scenes in user uploads. The 80 COCO classes cover most common objects that policies restrict, and the confidence threshold lets you tune the sensitivity to reduce false positives on marginal cases.

Robotics and autonomous systems. Robots navigating physical spaces need to recognize obstacles, grasp targets, and plan paths around detected objects. The nano and small variants fit on robot compute boards, and the model's speed allows real-time obstacle avoidance in dynamic environments.

Inventory and asset tracking. Warehouses and retail environments use YOLO26 to count stock, locate misplaced items, or verify shelf arrangement. The model detects boxes, bottles, and other packaged goods reliably, and running the medium variant on central servers processes camera feeds from dozens of locations.

Agricultural and environmental monitoring. The model detects crops, weeds, animals, and equipment in farm imagery. Nano or small variants deployed on drones provide real-time feedback for precision spraying or harvest planning, while the medium variant processes high-resolution satellite or aerial imagery for regional analysis.

Limitations

The model detects only objects within its 80 COCO classes. If your domain requires detecting custom objects—rare animals, industrial equipment, or specialized products—you must fine-tune on your own labeled data. The base model fails silently on custom classes by not detecting them.

Detection quality drops significantly on very small objects, blurry images, or extreme occlusion. If your images contain objects smaller than ~20 pixels or heavily obscured targets, expect missed detections. The model also struggles with unusual viewpoints or objects in cluttered scenes where many overlapping detections compete.

Confidence and IoU thresholds default to 0.25 and 0.45 respectively. Lowering confidence increases false positives; raising it misses valid objects. You must empirically tune these for your use case. No built-in validation on parameter choices means invalid thresholds produce silently degraded results.

The nano and small variants, while fast, sacrifice accuracy compared to large and extra-large variants. If processing latency allows, larger models consistently achieve higher mAP scores. The tradeoff is not linear—moving from nano to small gains more accuracy than small to medium.

Input images are resized to the specified imgsz (default 640 pixels). Very large or very small source images lose detail or introduce artifacts during resizing. The model returns bounding boxes and class labels only; it does not provide instance segmentation, keypoints, or semantic masks.

Licensing requires checking the Ultralytics terms for commercial use. The model is provided under the Ultralytics license, and commercial deployment may require licensing agreements.

How it compares

yolo11n by ultralytics is the successor architecture focusing on speed and efficiency. Choose YOLO26 if you have existing workflows or models trained on YOLO26 weights; choose YOLO11n if you are starting fresh and prioritize inference speed, as YOLO11 consistently delivers faster inference across all size variants. YOLO11 also includes additional task support like OBB (oriented bounding box) detection.

yolo26-pose by ultralytics extends the same architecture to estimate human poses alongside detection. Use YOLO26 if you only need object bounding boxes; use YOLO26-pose if you also need joint keypoints for human figures, such as for fitness tracking or activity recognition.

YOLO11 by Ultralytics represents the current generation of YOLO models with architectural refinements and better accuracy-speed tradeoffs. Choose YOLO26 if you require stability with an older, widely-tested architecture or have production systems relying on YOLO26 weights; choose YOLO11 for new projects because it achieves better mAP scores and faster inference on the same hardware.

YOLOv8 by Ultralytics is an earlier generation that established the modern YOLO architecture. YOLO26 builds on YOLOv8's foundation with performance improvements and refined training procedures. Choose YOLO26 over YOLOv8 because it provides better accuracy and speed; YOLOv8 exists primarily for legacy system compatibility.

yoloe-11s by ultralytics is an open-vocabulary variant supporting text prompts for dynamic class specification. Use YOLO26 for fixed COCO detection; use YOLOE-11s if you need to detect arbitrary objects specified at inference time without retraining.

Technical specifications

YOLO26 implements anchor-free object detection using a convolutional neural network backbone trained on the COCO dataset containing ~330,000 images across 80 object classes. The model supports five size variants with parameter counts ranging from the nano variant at approximately 3M parameters to the extra-large variant. The architecture uses a decoupled head design separating classification and localization branches, enabling faster convergence and better accuracy compared to anchor-based designs.

Input images are resized to a configurable size (imgsz, default 640 pixels) before inference. The model outputs detection results as bounding boxes with class labels and confidence scores. You control detection sensitivity through two thresholds:

  • Confidence threshold(default 0.25): Filters detections by the model's classification confidence. Lower values produce more detections including false positives; higher values reduce false positives but miss weak detections.

  • IoU threshold(default 0.45): Controls non-maximum suppression (NMS) for overlapping detections. Lower values suppress more overlapping boxes; higher values keep more overlaps.

The model supports ONNX export and deployment across CPU, GPU, and specialized accelerators. On CPU using ONNX, the small variant processes an image in approximately 100-200ms depending on hardware. GPU inference with TensorRT is substantially faster, processing 640px images in 5-15ms on modern GPUs.

The five size variants trade computational cost for accuracy:

  • Nano (n): Smallest parameter count, fastest inference, lowest accuracy. Suitable for embedded devices.

  • Small (s): 2-3x more parameters than nano, ~2x slower, meaningfully higher accuracy.

  • Medium (m): Balanced variant, common baseline for production systems.

  • Large (l): Higher accuracy, 4-5x slower inference than nano.

  • Extra-large (x): Maximum accuracy, suitable only when latency is unconstrained.

Model inputs and outputs

Inputs

  • image(string, URI format, required): URL or path to the input image for object detection

  • model_size(enum: "n", "s", "m", "l", "x", default: "n"): Size variant of the model to use, controlling speed and accuracy tradeoff

  • conf(number, 0 to 1, default: 0.25): Confidence threshold for filtering detections; only detections with confidence above this value are returned

  • iou(number, 0 to 1, default: 0.45): Intersection-over-union threshold for non-maximum suppression, controlling overlap suppression among overlapping bounding boxes

  • imgsz(number, default: 640): Input image size in pixels; the model resizes input images to this dimension

  • return_json(boolean, default: false): If true, returns detection results as JSON; if false, returns annotated image

Outputs

  • image(string, URI format): URL to the output image with bounding boxes and labels drawn (when- return_jsonis false)

  • json_str(string): JSON string containing detection results including bounding box coordinates, class labels, and confidence scores (when- return_jsonis true)

Getting started

import replicate client = replicate.Replicate() output = client.run( "ultralytics/yolo26:951e668282072c15663289e144f29a910ae4bffd68fb4af47762b434497c6f54", input={ "image": "https://ultralytics.com/images/bus.jpg", "model_size": "s", "conf": 0.25, "iou": 0.45, "imgsz": 640, "return_json": False } ) print(output)
This runs the small variant on a sample bus image with default confidence and IoU thresholds, returning an annotated image showing detected vehicles and people.

Frequently asked questions

Q: What confidence threshold should I use?

A: Start with the default 0.25 for development, then adjust based on your false positive and false negative tolerance. Lower confidence (0.15-0.20) detects more objects including weak positives; raise it (0.40-0.60) if you have too many false positives and can tolerate missing some real objects. The optimal threshold depends entirely on your use case and is best determined through validation on your actual data.

Q: Can I detect custom objects not in the COCO dataset?

A: No, YOLO26 detects only the 80 predefined COCO classes. To detect custom objects, you must fine-tune the model on a dataset of labeled examples containing your target classes. Ultralytics provides training scripts in their GitHub repository for this purpose.

Q: What image size should I use?

A: The default 640 pixels works well for most use cases. Larger sizes (832, 1024) improve detection of small objects but slow inference; smaller sizes (416, 512) speed up processing but lose fine detail. Choose based on your object sizes and latency budget—very small objects require larger input sizes.

Q: How much faster is the nano variant compared to extra-large?

A: The nano variant is roughly 10-15x faster on CPU and 5-8x faster on GPU, but with notably lower accuracy (typically 3-5% lower mAP). The small variant offers a better tradeoff for many deployments, providing 2-3x speedup over medium with only ~1% accuracy loss.

Q: Can I use YOLO26 commercially?

A: Usage depends on the Ultralytics license terms. Check the license agreement at the Ultralytics website for your specific deployment scenario—some open-source uses are permitted while commercial deployments may require a license agreement.

Q: What happens if I set very high or very low thresholds?

A: A very high confidence threshold (>0.8) produces very few detections and may miss most objects. A very low threshold (<0.1) produces thousands of overlapping detections, many of which are false positives. The IoU threshold controls how aggressively overlapping boxes are suppressed—too high and you keep redundant detections; too low and you eliminate legitimate overlaps.

Q: Is YOLO26 still maintained and supported?

A: Yes, as part of the Ultralytics YOLO family, YOLO26 receives maintenance updates. However, newer YOLO11 variants are the current recommended architecture for new projects. YOLO26 remains stable and suitable for production, but Ultralytics focuses development effort on newer generations.

Q: What is the difference between returning JSON versus an annotated image?

A: Set return_json to true if you need programmatic access to exact bounding box coordinates, class names, and confidence scores for downstream processing. Set it to false if you want a visual representation for human review or debugging. The annotated image is useful for quick validation; JSON output is necessary for automated systems that need precise coordinates.