This is a simplified guide to an AI model called Yolo26-Pose maintained by Ultralytics. If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter.
Overview
yolo26-pose is a human pose estimation model from ultralytics that detects and localizes keypoints on people in images. The model uses the YOLO26 architecture trained on the COCO-Pose dataset, which annotates 17 keypoints per person (head, shoulders, elbows, wrists, hips, knees, ankles). You can select from five model sizes—nano (n), small (s), medium (m), large (l), and extra-large (x)—trading off speed for accuracy. The critical thing to understand before using this model is that it outputs both annotated images with skeleton overlays and optionally JSON keypoint data, making it useful for both visualization and downstream pose analysis applications. Input images are processed at configurable resolution (default 640 pixels), and the model applies confidence thresholding and non-maximum suppression to filter detections.
Best use cases
Fitness and exercise form tracking. This model excels at capturing body joint positions in workout videos or image sequences, enabling analysis of squat depth, arm angles during weightlifting, or running gait mechanics. The 17-point keypoint system provides enough anatomical detail to compute joint angles and assess movement correctness without requiring specialized hardware like depth cameras or motion capture suits.
Pose-based sports analytics. Sports teams and broadcast organizations can use this model to automatically annotate player positions in tennis, basketball, or gymnastics footage, calculating metrics like jump height from keypoint trajectories or detecting certain pose states (e.g., defensive stance in boxing). The real-time capable nano and small variants enable processing live streams at acceptable latency.
Human-computer interaction and gesture recognition. The skeleton output feeds directly into gesture recognition systems that respond to specific body poses—raised hand detection for presentations, sit/stand classification for ergonomic monitoring, or dance move detection for interactive installations. The JSON output option makes integration into web or mobile applications straightforward.
Crowd analytics and safety monitoring. In crowded venues like airports or stadiums, pose detection provides non-invasive human presence and density mapping without identifying individuals. The model can detect people falling or lying down for emergency response, or assess crowd posture density to optimize space utilization and emergency evacuation routing.
AI animation and motion capture preprocessing. Game developers and animators can use single-image pose estimates to bootstrap character animation or create rough motion capture data from video without expensive mocap hardware. Stacking detections across frames produces motion sequences suitable for skeletal animation systems.
Limitations
The model fails on extreme poses, partial occlusion, and severe image quality degradation. When limbs extend far outside the training distribution or are hidden behind other people or objects, keypoint accuracy drops sharply. Images with extreme motion blur, very low resolution, or poor lighting produce unreliable detections.
The 17-point keypoint skeleton represents only major body joints and misses fine-grained hand finger positions and detailed facial landmarks. For applications requiring precise hand gesture recognition or facial expression analysis, specialized hand or face models are necessary.
Input resolution is limited to the image size parameter (default 640, configurable via imgsz). Very high-resolution images must be downsampled, losing detail; very low-resolution inputs cannot resolve small people. The model struggles with very small people at distances (crowds at stadium scale) or unusually large close-up shots.
The confidence threshold (conf default 0.25) and IoU threshold for non-maximum suppression (iou default 0.45) are tunable but their interaction can produce false negatives (missing people) if set too conservatively or false positives (phantom skeletons) if set too liberally. Finding the right threshold for your use case requires calibration.
Pose estimation accuracy is highest for front-facing or side-profile views and degrades significantly for severe angles or back views. The model was trained on COCO, which skews toward common poses in natural images and may underperform on niche postures specific to dance, martial arts, or unusual sports.
The model is not privacy-preserving—it retains enough spatial information from keypoints that re-identification may be possible in constrained settings (same person across frames, limited population). For sensitive deployments, consider whether pose skeletons introduce unacceptable privacy risk.
The JSON output format embeds detection confidence per keypoint but does not include uncertainty estimates or covariance matrices, limiting statistical downstream analysis. The license is proprietary (Ultralytics commercial license), so review terms for production use.
How it compares
yolo11n is a newer nano object detection model focused on bounding box detection of 80 COCO classes, whereas yolo26-pose specializes exclusively in human pose keypoint estimation. Pick yolo26-pose when you need joint positions for fitness, gesture, or animation; pick yolo11n if you only need to know where objects are without their internal structure. The tradeoff is specialization—yolo11n runs faster on non-human tasks, but yolo26-pose provides anatomical detail yolo11n cannot extract.
YOLO26 is the research baseline model available via Hugging Face, while this Replicate endpoint wraps it with pre-built inference including model selection (n/s/m/l/x variants), threshold tuning, and image annotation. Use the Replicate version if you want a managed API with immediate results; use the raw YOLO26 if you need to fine-tune the model on custom poses or integrate the weights directly into your pipeline.
YOLO11 is the latest general-purpose detection model, available for detection, segmentation, and classification but with limited pose support. Choose YOLO11 for multi-task detection pipelines; stick with yolo26-pose if pose estimation is your primary need and you want a stable, thoroughly validated model trained on the well-established COCO-Pose standard.
YOLOv8 is the prior major version of the YOLO family, still widely deployed in production. YOLO26 offers better speed and accuracy on modern hardware, but if you have existing YOLOv8 pose code or custom YOLOv8 weights, migration to YOLO26 is incremental—the API is nearly identical. Choose YOLO26 for new projects; stick with YOLOv8 if your infrastructure and models are already optimized around it.
Technical specifications
The model is a single-stage convolutional detector using the YOLO26 architecture, trained end-to-end on the COCO-Pose dataset with 17 keypoints per annotated person. Five size variants are available: nano (n), small (s), medium (m), large (l), and extra-large (x), scaling in parameter count and depth-width multipliers. The model accepts images in common formats (PNG, JPG) via URI string input. Inference runs on Replicate's GPU infrastructure, making it accessible via REST API without local hardware.
Input specification:
- Image size (
imgsz): Configurable, default 640 pixels (affects inference speed and small-object detection sensitivity). - Confidence threshold (
conf): Default 0.25, range [0, 1]. Lower values increase sensitivity but raise false positive rate. - IoU threshold (
iou): Default 0.45, range [0, 1]. Used for non-maximum suppression to filter overlapping detections. - Model size (
model_size): Enum {n, s, m, l, x}. Larger models are more accurate but slower. - Return format (
return_json): Boolean, default false. If true, returns keypoint detections as JSON; if false, returns annotated image only.
Output specification:
- Annotated image (URI): JPEG/PNG image with skeleton keypoints and confidence scores drawn as lines and circles.
- JSON (optional): String containing structured keypoint data for programmatic processing.
The model output includes per-keypoint coordinates (x, y in pixel space), per-keypoint confidence, and per-person detection confidence. Keypoint indices follow the COCO convention: 0=nose, 1-2=eyes, 3-4=ears, 5-6=shoulders, 7-8=elbows, 9-10=wrists, 11-12=hips, 13-14=knees, 15-16=ankles.
Inference latency varies by model size and image resolution. The nano variant runs in tens of milliseconds on GPU; the extra-large variant can reach several hundred milliseconds. CPU inference is not optimized on this endpoint.
The model is actively maintained by Ultralytics, with regular updates to the ultralytics package. The Replicate version is pinned to cog_version 0.9.8 and was last updated 2026-07-21. Commercial licensing is required; see the Ultralytics License page for enterprise options.
Model inputs and outputs
Inputs
- image (string, URI): Required. The input image as a URL. Supported formats: PNG, JPEG, and other common image formats accessible via HTTP(S).
- model_size (enum: "n", "s", "m", "l", "x"): Default "n". The model variant to use. Smaller variants (n, s) are faster; larger variants (l, x) are more accurate.
- conf (number, 0–1): Default 0.25. Confidence threshold for keypoint detection. Keypoints with confidence below this are filtered out.
- iou (number, 0–1): Default 0.45. Intersection-over-union threshold for non-maximum suppression, used to deduplicate overlapping person detections.
- imgsz (number): Default 640. Input image size for inference. Larger values improve small-object detection but increase latency.
- return_json (boolean): Default false. If true, output includes structured JSON keypoint data. If false, only the annotated image is returned.
Outputs
- image (string, URI): URL to the output image with drawn skeleton keypoints, person bounding regions, and confidence annotations.
-
json_str (string): Structured JSON containing per-person keypoint arrays with (x, y, confidence) tuples for each of the 17 joints, only if
return_json=true.
Getting started
import replicate
client = replicate.Replicate()
output = client.run(
"ultralytics/yolo26-pose:0cb97680a84ec9c0ede86d08c3d956d2416f93a97927825ebaee2006e305a5ff",
input={
"image": "https://example.com/people.jpg",
"model_size": "m",
"conf": 0.5,
"iou": 0.45,
"imgsz": 640,
"return_json": True
}
)
print("Annotated image:", output["image"])
print("Keypoint JSON:", output["json_str"])
This example sends an image URL, requests the medium model variant for better accuracy, increases the confidence threshold to 0.5 to reduce false positives, and requests structured JSON output for downstream processing. Adjust model_size to "n" or "s" for faster inference if real-time latency is critical, or "l"/"x" if maximum accuracy is needed.
Frequently asked questions
Q: What does the 17-point keypoint skeleton include?
A: The 17 points follow the COCO standard: nose, left/right eyes, left/right ears, left/right shoulders, left/right elbows, left/right wrists, left/right hips, left/right knees, and left/right ankles. No hand fingers, facial landmarks, or spine details are provided; use specialized models for those.
Q: Can I use this model commercially?
A: The model is governed by the Ultralytics License. Commercial use requires a paid license agreement. Visit the Ultralytics Licensing page to request an enterprise license or review the terms for your use case.
Q: What's the difference between the model sizes (n, s, m, l, x)?
A: The sizes trade accuracy for speed. Nano (n) is fastest but least accurate, suitable for real-time webcam applications. Small (s) and medium (m) balance speed and accuracy for most use cases. Large (l) and extra-large (x) are most accurate but require more compute and latency, better for batch processing or offline analysis.
Q: How accurate is the pose estimation?
A: Accuracy depends on image quality, pose complexity, occlusion, and the model size used. The large and extra-large variants achieve 80+ mAP on COCO-Pose validation; nano and small variants are 70–75 mAP. Real-world accuracy varies—well-lit, frontal poses in uncrowded images perform best; extreme angles, occlusion, or tiny people degrade performance significantly.
Q: What happens if I set the confidence threshold very low?
A: Setting conf close to 0 will detect many keypoints but produce false positives and phantom skeletons from noise. Setting it too high (e.g., 0.9) will miss real people with low-confidence detections. Start at the default 0.25, then adjust based on your dataset. Use validation data or a sample to tune.
Q: Does the model work on video?
A: The Replicate endpoint processes single images. To process video, extract frames, send each to the API, and reassemble the results. The Ultralytics library itself supports video frames directly; this Replicate wrapper is image-focused.
Q: Is the model actively maintained?
A: Yes, Ultralytics continues to update YOLO26 and the broader ultralytics package. The Replicate endpoint was updated in July 2026 and is regularly patched for stability and performance improvements.
Q: What's the expected inference time?
A: On GPU, nano models process a 640×640 image in ~20–30ms; medium models in ~50–80ms; large/extra-large in 150–300ms. This does not include network latency or image download time. CPU inference is significantly slower and is not optimized on this endpoint.
Top comments (0)