Roboflow FAQs

Roboflow helps you build applications that understand images and video, then use what they see to make decisions. That might mean checking an assembly for missing parts, counting pallets at a loading dock, or recording when a production process deviates from its standard operating procedure.

You can start by describing your application to Roboflow Agent, test models on your own images, and build the logic that turns predictions into useful actions. Roboflow brings data preparation, model training, evaluation, deployment, and production monitoring into the same platform. Your application can run in the cloud or on your hardware.

This guide answers common questions about getting started, choosing models, running vision applications in production, and meeting your team's pricing and security requirements.

Getting Started

What kinds of problems is Roboflow good for?

Roboflow helps automate decisions from images and video, including defect inspection, packaging verification, inventory counting, and process monitoring. It helps software interpret visual information and connect the results to business processes.

Common applications include inspecting products for defects, checking packaging and labels, tracking inventory, analyzing sports footage, and counting cells in microscope images. A manufacturing application might verify that every required component is present, display a pass or fail result, and save an image for later review. A warehouse application might count pallets crossing a loading zone and record each movement.

The best starting point is a specific decision you want to make from an image or video. Define what the system needs to see, what should happen next, and how you will measure whether it works. Explore Roboflow applications by industry for examples.

Do I need machine learning expertise to use Roboflow?

No. You can start using Roboflow with a description of your problem and a few representative images or videos. Roboflow Agent can help build and test an application, while Workflows provides a visual editor for connecting models, logic, and integrations.

Your knowledge of the task still matters. You decide what counts as a defect, which objects should be counted, and what errors are acceptable. Reviewing results against those requirements is part of building a useful system.

Developers and machine learning teams can also use Roboflow through APIs (opens in a new tab) and SDKs, bring supported custom model weights, or use individual platform components within an existing stack.

What does Roboflow Agent do?

Roboflow Agent helps turn a description of a vision problem into an application. It can select models, build Workflows, run tests, investigate errors, and help prepare a deployment. It can also work with projects and datasets, start model training, and compare Workflow results.

For example, you could ask it to find missing labels on bottles and return an image showing which bottles failed inspection. Give it examples from your camera, explain the expected result, and use those examples to test the application it creates.

You can inspect and edit the resulting Workflow. Before connecting it to a production process, test representative cases and confirm that the outputs and response time meet your requirements.

Can I use Roboflow from ChatGPT or a coding agent?

Yes. The Roboflow MCP server connects compatible assistants to Roboflow tools for finding datasets, labeling images, training models, running inference, and creating Workflows.

With the Roboflow plugin for ChatGPT, you can find datasets, label images, train models, review evaluation results, and build and save Workflows in a conversation. Install the plugin, connect your Roboflow account, and mention @Roboflow. Our ChatGPT walkthrough shows the process from setup to testing a model.

The Roboflow for Copilot plugin connects Microsoft Copilot Cowork to your workspace so you can inspect projects and datasets, explain training results, and review saved Workflows. Add it in Cowork and sign in with your Roboflow account. Access requires a Microsoft 365 Copilot license and may require your organization's admin approval.

Roboflow also connects to coding assistants such as Claude Code, Codex, and Cursor. Follow the MCP setup documentation (opens in a new tab) for your client; access follows the Roboflow permissions and scopes you authorize.

MCP also supports production analysis. With access to Vision Events (opens in a new tab) through the MCP server, you can ask questions about recorded events in natural language, such as which cameras recorded failed inspections during a shift. This gives operations teams another way to investigate results alongside the dashboards and event browser.

How quickly can I build a working vision AI application?

With Roboflow, you can often test an idea in one session using Agent, an existing model, and Workflows. A useful prototype shows whether the system can recognize the objects or conditions you care about on representative images.

Production readiness depends on the application. A camera-based counter and an inspection system that controls a reject mechanism have different validation and integration requirements. Allow time to test changing lighting, unusual parts, camera interruptions, and the consequences of incorrect predictions.

Start with one camera and one measurable outcome. Evaluate the system, integrate its outputs, and expand once the results justify it. Roboflow's production readiness checklist (opens in a new tab) covers operational concerns such as retries, timeouts, and capacity.

Models and Data

What models can I use with Roboflow?

You can use custom-trained models, pretrained foundation models, and third-party model APIs with Roboflow. Supported tasks include object detection, instance and semantic segmentation, classification, keypoint detection, action recognition, anomaly detection, OCR, and multimodal applications.

Examples include RF-DETR (opens in a new tab) for detection, segmentation, and keypoints, supported YOLO architectures, SAM 3 for promptable segmentation, PatchCore and FoundAD for anomaly detection, and V-JEPA 2.1 for action recognition. Vision-language options include Qwen3-VL and Cosmos 3 Edge, alongside integrations with providers such as OpenAI, Google, and Anthropic. Workflows also support Astra, Argon, Grok, Muse, and Mistral, and an OpenRouter integration adds access to dozens more.

Roboflow added YOLOLite, GLM-OCR, Gemma, Falcon Perception, and SAM 3 Video to the platform in 2026.

Support differs by architecture and task. A model available for inference may not support hosted training, weight export, or every deployment target. Use the supported models documentation (opens in a new tab) to check the combination you need.

RF-DETR Keypoint Preview supports custom landmarks and skeletons for tasks such as reading gauges or locating points for robot guidance. RF-DETR semantic segmentation supports Nano through 2XL models and Neural Architecture Search, giving teams options for classifying regions throughout an image. Choose the task that matches the output your application needs: individual objects, their boundaries, key locations, or classes assigned to pixels.

Can I start without training a model?

Yes. You can test pretrained models in Roboflow Playground (opens in a new tab), use foundation models in a Workflow, or find a community model on Roboflow Universe (opens in a new tab).

Playground lets you compare models on your own images before committing to an approach. Universe provides more than one million public datasets and 250,000 pretrained models that can help you find a starting point, expand a dataset, or pre-label images.

For a large product catalog, the Visual Search Classifier (opens in a new tab) offers another starting point. It classifies an image by finding similar examples in a labeled dataset, so you can test recognition of products or parts without first training a dedicated classifier.

How many images do I need to start using Roboflow?

You can start with a handful of images, or none of your own. Test pretrained and foundation models on a few representative images first. If one already meets your requirements, you may not need a custom dataset.

When you do train a model, the amount of data depends on how hard the task is and how much your scene varies:

A fixed camera looking at consistent parts needs less data than outdoor cameras or products with many variations. Variety matters more than volume: images from every shift, line, and lighting condition teach a model more than thousands of near-identical frames.

After deployment, production images become your best source of new training data. Active Learning and Vision Events automations can collect images for review, and you decide which examples to label and add before retraining. See the Roboflow Vision AI Trends Report (opens in a new tab) for dataset sizes across real projects.

No data yet? Clone a related dataset from Roboflow Universe to start, then add images from your own cameras.

How can we manage and search visual data across teams and projects?

Roboflow's Asset Library (opens in a new tab) gives your workspace one place to find and work with images across projects, including uploads from Agent and images that have not yet been assigned to a project. Search with natural language, visual similarity, or metadata, apply tags in bulk, and add selected images to a project. For an inspection program spanning several facilities, this helps teams find relevant examples without manually browsing each dataset.

Datasources (opens in a new tab) connects supported AWS S3 (opens in a new tab), S3-compatible, Google Cloud Storage (opens in a new tab), and Azure Blob Storage buckets to Roboflow. Scheduled imports keep new data moving into the platform. Datasources also supports importing MP4 and MOV videos up to 3 GB from connected cloud buckets.

You can run Workflows on Asset Library images to generate labels, tags, and metadata across a selection or search result. Supported datasource syncs can trigger a Workflow on newly imported images. For example, a Workflow could identify the product in each image, record whether a defect is present, and write those attributes back to the library for future searches. This automatic Workflow processing applies to supported image inputs; importing a video is a separate capability.

Organizing data this way makes it easier to reuse examples across teams, investigate recurring failures, and assemble the next training dataset from production observations.

How does Roboflow help with labeling?

Roboflow Auto Label can generate annotations using foundation models, models trained in Roboflow, or compatible saved Workflows. Available foundation models include SAM 3, Gemini 4 Argon, GPT models, and Claude, and frontier models such as Astra, Sol, and Carbon,with supported outputs varying by model and project type. Improvements in 2026 cut Auto Label's cost and increased its speed by more than 10x.

Interactive tools help annotators select objects and refine their boundaries. Existing models can provide a first pass of predictions for people to review.

Treat generated labels as predictions that need review. Check missed objects, incorrect classes, and inconsistent boundaries before training. The goal is a consistent dataset that represents your task accurately.

How does Roboflow support advanced QA and collaborative workflows for enterprises?

Roboflow supports labeling and review workflows so that images can be checked before entering a training dataset. Teams can assign work, review annotations, and return images for correction. Annotation Insights (opens in a new tab) helps managers understand labeling activity.

Set clear instructions for ambiguous cases, such as whether to label a partially visible object or how to distinguish cosmetic variation from a defect. Review a shared sample early so annotators apply those instructions consistently.

Access to reviewer roles, Review Mode, SSO, and other collaboration controls depends on your workspace's plan and add-ons. See the roles and permissions documentation (opens in a new tab) and discuss enterprise governance requirements with Roboflow.

Can Roboflow detect defects without examples of defective products?

Yes. Roboflow supports anomaly detection with PatchCore and FoundAD, which learn from normal images and flag visual differences without requiring examples of defective products. This is useful when you can collect normal examples but have few images of failures.

The model returns an anomaly score and can produce a heatmap showing unusual regions. Applications include surface inspection, packaging checks, and finding foreign objects on a conveyor.

An anomaly is a difference from the learned normal appearance. It may be a defect, or it may be an acceptable change in lighting or presentation. Evaluate examples of both, choose an appropriate threshold, and review flagged cases. Those observations can also help you build a dataset for a more specific defect detector.

Can Roboflow understand actions in video?

Yes. Roboflow supports training action recognition models including V-JEPA 2.1 and Cosmos 3 Edge, to identify activities across a sequence of video frames. These models return the start and end frames of detected actions, along with confidence scores.

Video is a first-class data type in Roboflow. Teams can upload, manage, and annotate video segments directly, without converting footage to individual frames first.

For an assembly process, you might identify when an operator inserts a component or performs an inspection. Application logic can compare those events with the expected procedure. Object detection can separately verify that the required part or tool is visible.

This makes action recognition useful for process analysis and SOP verification, where the order and duration of events matter. Collect training and test clips that reflect how the activity varies across stations and shifts.

Can I use or fine-tune a vision-language model?

Yes. Roboflow can run vision-language models and fine-tune selected architectures, including Qwen3-VL. Vision-language models combine an image with a text instruction to produce an answer, such as a description, extracted information, or a structured response. They are useful when the task requires context beyond a fixed set of detection classes.

Roboflow supports Qwen3-VL, including custom-trained checkpoints, and Cosmos 3 Edge for reasoning about physical scenes. Workflows also integrates third-party model APIs.

You can combine a fast detector with a vision-language model. For example, detect a shipping label, crop that region, and ask a second model to read or interpret it. Check training support, hardware requirements, latency, and data handling for the models you choose.

How do I compare models and check accuracy?

Roboflow provides Playground for testing pretrained models, Model Evaluation (opens in a new tab) for comparing trained models, and Workflow Evals for checking complete applications. Use the tool that matches the decision you are making:

Model Evaluation benchmarks trained models on test data using the Serverless API. Those latency results describe that environment; benchmark your target edge device separately when deploying locally.

Multiple Models Per Version lets you train different model architectures and sizes against the same dataset version, including parallel training jobs. Keeping the data version fixed makes it easier to understand whether a change in results comes from the model rather than a different training set. MCP tools can help launch and compare these experiments.

Neural Architecture Search (opens in a new tab) explores candidate architectures to find useful accuracy and speed tradeoffs for your deployment. Its Fast backbone targets CPU and edge workloads, while Plus targets cloud GPU workloads; Standard provides another option. Teams can use the search results to select a model for their latency and accuracy requirements, then validate that choice on the hardware and camera inputs they will use in production.

With Workflow Evals (opens in a new tab), create a reference dataset with expected answers, such as a count or pass/fail decision. Compare Workflow versions against those answers and inspect failures before publishing a change. Automated experiment tracking records every run, so teams can compare results across versions over time.

Building and Deploying Vision AI Applications

How does Roboflow Workflows differ from just running a model?

A model returns predictions. Roboflow Workflows connects those predictions to the steps your application needs.

An inspection Workflow could detect components, filter predictions by class and confidence, compare the result with an expected count, and return a pass/fail decision. It could also draw an annotated image and record a failure for review. A document application could detect regions, crop them, run OCR, and structure the extracted fields.

You build this logic in a visual editor or with Agent, then run the Workflow through a supported cloud or self-hosted deployment. This gives your application a reusable pipeline instead of requiring you to recreate the same sequence around every model call. The Workflow builder was redesigned in 2026 with a new drag-and-drop editor and more than 60 new blocks.

Nested Workflows lets one Workflow call another through defined inputs and outputs. A team can reuse a label-reading or inspection routine across several applications. Developers can also disable individual nodes while testing, debugging, or benchmarking a pipeline.

For inspection and measurement, Mask Area Measurement counts the pixels inside a segmentation mask, excluding holes, or measures bounding-box area for object detections. Converting image area into a reliable physical measurement requires calibration and attention to perspective. Depth Anything 3 adds relative depth estimates for scene analysis; those estimates do not directly establish physical distance.

Do I have to use the Roboflow Cloud?

No. Roboflow supports managed cloud deployment and self-hosted inference on compatible hardware. Choose a deployment based on your models, input, latency requirements, available hardware, and data policies.

The deployment guide explains the options. Model compatibility varies, and some workloads require a GPU. Also check every Workflow step: a local pipeline can still send data outside your network if it calls an external API.

For applications that need custom dependencies, Dedicated Deployment startup scripts run a Bash script before Inference starts each time the container launches. Teams can install packages or prepare required files and inspect the script logs as part of deployment troubleshooting.

Can I process live cameras without managing an inference server?

Yes. Roboflow Cloud Streaming runs Workflows on live cameras using Roboflow-managed compute. A Video Connector can connect local cameras to the service; other supported sources include direct RTMP publishing and temporary browser camera sessions. Connections over RTSP, RTMP, and WebRTC let teams use IP cameras, webcams, phones, drones, and GoPros.

Connect a source, preview the Workflow, and start a deployment when you are ready. Cloud Streaming provides video and prediction results while Roboflow runs the inference infrastructure.

Processing uses credits, including previews. A deployed job can continue after you close its video player, so stop processing explicitly when finished. Cloud Streaming is the recommended managed live-camera path; the older Serverless Video Streaming API is deprecated.

Can Roboflow run on the edge?

Yes. Roboflow Inference (opens in a new tab) supports deployment on servers, industrial PCs, NVIDIA Jetson devices (opens in a new tab), and Raspberry Pi. RoboflowOS Lite, a lightweight version of Roboflow's edge operating system, runs on Raspberry Pi. Native desktop apps are available for Windows and Apple Silicon Macs. Docker and Python deployment paths are also available, depending on your environment.

Hardware performance depends on the model, image resolution, number of streams, and application logic. Test the complete Workflow at the input rate you expect in production.

Inference 1.0 provides a modular execution engine with backends including PyTorch, ONNX Runtime, and TensorRT. Teams can install the dependencies required for their models and hardware, with improvements to model loading and resource use that matter when operating constrained edge devices or serving several models. 2026 releases brought 10x speedups for both image requests through the HTTP server and video streaming.

Mobile, browser, and camera-specific deployment options depend on the model and export format. Check the model export documentation (opens in a new tab) before choosing a device. Support for a model on a GPU server does not establish support on every phone or AI camera.

Can I run Roboflow without an internet connection?

Yes, for supported Enterprise deployments. Roboflow Offline Mode runs inference without an internet connection. It uses a Docker container and cached model weights to run inference in an isolated environment. Cached weights have a lease of up to 30 days, so the deployment needs an approved renewal process.

Ordinary self-hosted inference and fully air-gapped operation have different requirements. A connected local server may still retrieve model metadata or validate licensing, and any external API block needs its own connectivity.

For isolated facilities, plan model transfer, cache renewal, updates, and event handling with your IT team. Secure Gateway can centralize controlled access and cache deployment resources. See the model weight security guide for deployment patterns and validation steps.

Can Roboflow connect to PLCs and factory systems?

Yes. Roboflow can connect vision outputs to industrial systems through supported deployment services and integrations. The right connection depends on your controller, protocol, and required response time.

Enterprise edge services include an OPC UA Server for publishing values to PLCs and SCADA systems, and PLC Relay for reading and writing tags through Allen-Bradley, Modbus TCP, or Siemens S7. Connectors support EtherNet/IP, Modbus, OPC UA, and MQTT. See Deployment Manager services (opens in a new tab) for the available options.

Results can also flow to the data platforms your business already uses. Workflows can send results to Kafka, Postgres, Databricks, and Salesforce.

For example, an inspection application can return a part status, save a failure image, and update an operator display. Test the complete path from camera capture to controller response, including what happens when a frame or prediction is unavailable. Roboflow's FTP camera and PLC tutorial shows one implementation.

Trigger-based inference in Deployment Manager supports running an inspection in response to an event or manual trigger. This is useful when a station needs to inspect a part at a specific point in the process instead of continuously processing the camera stream.

How do I review production results and manage multiple sites?

Use Roboflow Vision Events to review production results and Deployment Manager to manage supported edge devices across sites. Vision Events records observations from deployed applications. Events can include images, video clips, predictions, source information, and custom fields such as production line, shift, or part number.

Dashboards turn those records into operational views, such as pass/fail trends, average inventory counts, or safety violations by location. Operators can mark detections as correct, incorrect, or inconclusive, and engineers can filter that feedback to investigate failures. Summary reports can deliver daily, weekly, or monthly charts and results to selected recipients, grouped by fields such as device, stream, or outcome.

Vision Events has separate role permissions, so an operator can review results without being granted control of the deployment. Teams can also use MCP to query event records in natural language.

For edge fleets, Deployment Manager (opens in a new tab) provides Enterprise tools to provision devices, configure streams, deploy Workflows, and monitor logs and telemetry. It also addresses practical setup and maintenance tasks:

• GigE camera discovery finds compatible network cameras and helps connect them to streams.
• Remote network configuration lets teams set static IP addresses per interface for factory networks with specific subnet requirements or no DHCP service. Custom SSL certificates support connections that rely on an organization's internal certificate authority.
• Stream sharpness monitoring helps identify camera focus or image-quality problems with scores and threshold alerts. Historical FPS telemetry compares camera and inference frame rates over time, helping teams distinguish capture issues from processing bottlenecks.
• The per-device Activity tab records configuration changes, who made them, and when, alongside errors and exceptions. Teams can restore a previously working configuration when troubleshooting a change.

Remote management requires connectivity and supported hardware. Roboflow-provided Enterprise devices have the documented support path; other Linux and NVIDIA hardware may receive best-effort support. Deployment Manager support is separate from the Windows and macOS Inference desktop apps. Validate a deployment on one representative site before expanding it across cameras and facilities.

How do I improve a model after deployment?

Use production failures to guide retraining and evaluation in Roboflow. Roboflow's Active Learning (opens in a new tab) feature can sample production images using rules you configure, such as confidence thresholds or classes of interest, and queue them for review. Active Learning also ties into Auto Label, so edge cases and out-of-distribution examples can be collected and labeled automatically before review.

Review and correct the labels, add useful examples to your dataset, then retrain and evaluate the new model before replacing the deployed version. Collecting data alone does not update a model.

The documented Active Learning feature requires a cloud deployment and access to Annotation Review. For other deployment patterns, Vision Events and Workflow integrations can help collect examples for a controlled improvement process.

Vision Events automations can act when a new event matches configured filters, including adding event images to a project for training. Automations can use context from multiple sources to determine which observations to collect. Combined with operator feedback, this helps teams build batches of useful examples from production and keep human review in the improvement process.

Pricing and Ownership

How much does Roboflow cost?

Roboflow's $0 Free Tier includes 10 credits each month, private projects, unlimited admin seats, and downloads for supported model weights. You can add prepaid credits or a recurring credit pack when you need more usage.

Monthly Core credit packs start at $39 for 20 total monthly credits, including the 10 free credits. Enterprise offers custom pricing for production requirements, support, governance, and deployment add-ons.

Running supported models and Workflows locally with Roboflow Inference does not consume inference credits. Cloud services and external model calls can still incur charges, and some model licenses require a commercial self-hosting add-on. Check current pricing and licensing for your application.

How does Roboflow's credit system work?

Roboflow uses a usage-based credit system. Instead of charging a flat fee for every feature, you pay for the resources your project consumes: storage, AI labeling, training, and cloud deployment.

Credits come in three types:

1. Included credits: Every plan, including the Free Tier, comes with credits that reset every month.
2. Prepaid credits: You can buy additional credits in bulk at a discount if you have a high-volume month of training or labeling ahead.
3. Flex credits: If you use up your included and prepaid credits, Flex credits keep production systems running. You are billed for the extra usage at the end of the month.

Here is what a credit typically buys:

Because self-hosted inference with Roboflow Inference isn't metered on any plan, a camera running a model 24/7 on your own hardware adds no inference charges, however many frames it processes. Your costs for that workload are the hardware, any cloud services or external model calls in the Workflow, and any license add-on the model requires.

Use the credits page for a complete estimate.

Credit usage tracking by folder helps organizations attribute usage to departments, teams, or groups of projects. This gives administrators a clearer view of where spending occurs as more teams adopt the platform. Folder-level reporting provides cost visibility; it does not by itself enforce a separate budget for each folder.

Is my data locked into Roboflow?

No. You can export datasets and annotations from Roboflow and download weights for supported models to use outside the platform. This lets you use your own training or inference infrastructure when your project requires it.

Export formats vary by architecture and include options such as ONNX, PyTorch, and CoreML. Some models do not support weight downloads, including SAM 3 and RF-DETR NAS; classification downloads have additional access requirements.

Keep three questions separate: whether you can export a file, whether your target runtime can execute it, and whether its license permits your intended use. Download access does not change the model license.

For teams working directly with the open-source RF-DETR library, RF-DETR 1.11 adds export paths for OpenVINO IR, LiteRT, and Apple Core AI, along with TensorRT dynamic-batch options. Recent RF-DETR releases also added quantization support, and a rebuild on PyTorch Lightning made training more than twice as fast. These library capabilities are separate from the formats offered in Roboflow's hosted model-download interface. Check the export path for your exact architecture and target runtime.

Can I use Roboflow models commercially?

Yes. You can use Roboflow models commercially, subject to the model's license and your deployment method. Roboflow Cloud includes commercial licensing for covered models on every plan. Commercial self-hosting of restricted model families requires the applicable Enterprise license add-on.

RF-DETR licensing varies by variant:

Apache 2.0 variants can be used commercially, including on your hardware, under that license's terms. YOLO families have differing licenses; Roboflow cannot provide commercial licenses for every version. Check the licensing guide and RF-DETR license details for your exact model and deployment.

Privacy and Enterprise Readiness

Is my data secure and private on Roboflow?

Yes. Roboflow protects your visual data and models with certified security controls, encryption, access management, and deployment options that keep data inside your network. Teams in regulated sectors such as healthcare, defense, and aerospace use these controls today.

• Data ownership: You retain ownership of your images, annotations, and trained model weights.
• Compliance: Roboflow is SOC 2 Type II certified. For medical and life sciences teams, Roboflow offers HIPAA-related infrastructure and Business Associate Agreements through enterprise contracting.
• Encryption: Data is encrypted with AES-256 at rest and protected by TLS 1.2 or higher in transit. FIPS 140-2 compliant encryption is available for organizations with federal or high-security requirements.
• Deployment inside your perimeter: Self-hosted Inference runs models on your own servers and edge devices, so images and video stay on your network unless a Workflow step calls an external service. Enterprise Offline Mode runs inference with no internet connection using cached weights with a lease of up to 30 days. Enterprise customers can also use single-tenant environments or a Virtual Private Cloud, or deploy the entire Roboflow platform on-premises on an NVIDIA DGX Station or in their own AWS, Azure, or Google Cloud account.
• Data residency: A self-contained EU tenant is available for teams that need their data to stay in the EU.
• Access control: Role-Based Access Control, scoped API keys, and SSO (SAML and OIDC) limit who can view or change datasets, models, and deployments.

Enterprise workspace data is excluded from the data licensing and product-improvement use described on the pricing page. Review the plan and data settings and current pricing terms when choosing a workspace for sensitive information.

What happens to data I send to Roboflow Agent?

Roboflow Agent works with your workspace data and calls external model providers to carry out tasks. Roboflow's Agent data-handling policy states that its agreements prohibit those providers from training on submitted customer data and require zero data retention for Agent's model-provider calls.

Provider retention is separate from storage inside Roboflow. Agent conversations, replies, and plans are saved in your workspace so you can continue working, and you can delete them. The policy also documents quality-monitoring and documentation-search services that receive Agent data.

Agent inherits the signed-in user's permissions. These Agent-specific provider protections do not replace the dataset policies described above. For a security review, use the published data-flow explanation and subprocessor list in How Roboflow Agent Keeps Your Data Inside the Lines to assess the configuration your organization will use.

Can my team use its own model-provider keys?

Yes. Roboflow's Workspace LLM Keys lets supported AI features run through your organization's provider accounts. Agent supports OpenAI or Azure OpenAI keys; supported Workflow and Auto Label options can use your OpenAI or Gemini keys.

When enforcement is enabled, supported requests use your keys without falling back to Roboflow's. Features that cannot use those keys are disabled. The Agent security post also explains how this changes quality-monitoring traces and model billing.

Your provider bills model usage directly. Other Roboflow services can still consume credits. Confirm provider access, workspace enablement, and regional availability before rollout; the compliance and readiness guide currently notes that enforcement is unavailable in the EU region.

How can IT control what Agent can access and change?

IT can control Roboflow Agent through user permissions, scoped credentials, protected Workflows, and enterprise block governance. Agent follows the permissions of the user or credentials making the request. MCP clients connect through scoped authorization, and appropriately scoped API keys can limit integrations to specific actions and resources.

For production Workflows, use Protected mode so Agent edits remain drafts until published. Approval behavior depends on the operation: Agent requests confirmation for paid Workflow Evals runs and agrees on details before copying Universe data. Workflows created through the Agent API can be live immediately. Agent's Deployment Manager access is read-only for fleet information, telemetry, logs, and streams.

Enterprise Workflow Block Governance controls which blocks users can add, including external model integrations. See the compliance and readiness guide for the controls and their scope.

Is Roboflow Enterprise ready?

Yes. More than half of the Fortune 100 build with Roboflow, including USG and BNSF Railway. Roboflow Enterprise adds controls for identity, access, and review, including SSO, custom roles, folder permissions, and audit logging. Availability depends on your plan and enabled add-ons.

Enterprise SSO supports self-service configuration once enabled for the workspace. Active Directory group sync can use group attributes from SAML or OIDC to map workspace access and roles. Eligible users can join the appropriate workspace when they next sign in, helping IT manage access through its existing identity provider as adoption grows. Teams can also use “Sign in with Roboflow,” an OAuth sign-in option.

Audit Logs record significant actions by users, API keys, and systems, including changes to permissions, Workflows, and exports. Supported Enterprise configurations can stream those events to a security information and event management system through OpenTelemetry.

Advanced API Keys adds scoped permissions, folder keys, ownership metadata, and rotation reminders. Use credentials limited to each integration's needs, and protect production keys against unintended changes.

Workspace Trash provides a 30-day recovery window for deleted projects, dataset versions, and Workflows. Authorized users can restore items through the interface or supported REST API, SDK, and CLI operations. This helps teams recover from accidental deletion; items can still be permanently deleted, so Trash should not be treated as a complete backup strategy.

Start a security review at the Roboflow Trust Center (opens in a new tab), where your team can request the SOC 2 Type II report and supporting materials. Review deployment architecture, contracts, and data handling alongside the platform controls.

Why is Roboflow the platform of choice for medical data?

Roboflow combines tools for medical computer vision with deployment and access controls for sensitive data. Applications include microscopy analysis, medical-image research, and visual checks in healthcare operations.

Roboflow offers HIPAA-related infrastructure and Business Associate Agreements through its enterprise contracting options. Coordinate those requirements before uploading protected health information. The Trust Center (opens in a new tab) and enterprise team can provide the relevant documentation.

Platform security controls do not establish that a particular model is clinically validated or that an application has regulatory authorization. Evaluate the intended use, data, model performance, human review, and deployment process as part of the application's own validation.

Who can help us put an application into production?

Roboflow's enterprise team and forward-deployed engineers can help with solution design, model evaluation, hardware selection, on-site deployment, and integration with operational systems. The support and services included depend on your agreement.

Bring a representative image or video, the decision you want to automate, and the constraints the system must meet. Useful details include camera locations, required response time, network restrictions, expected volume, and the systems that will consume results.

For a first test, open Roboflow Agent and describe what your application should see and do. To plan a production deployment, talk with the Roboflow team about your use case, acceptance criteria, and security requirements.

Additional Common Questions

How is Roboflow different from building this myself in-house?

Roboflow provides the infrastructure around a computer vision application so your team can spend more time solving the problem it was built for.

An internal system needs more than a model. Someone has to organize images, manage annotations, reproduce training experiments, serve predictions, connect those predictions to business logic, and maintain the deployment. Roboflow brings those steps into one platform:

For example, a packaging inspection system needs to identify products, check whether labels are present, return a pass/fail result, and record failures. With Roboflow Workflows, your team can connect those steps in a visual editor and run the application in the cloud or on supported local hardware. Roboflow Agent can help build and test the Workflow from a description of the task.

You can also use Roboflow for selected parts of an existing system. Train a model on your own infrastructure and upload supported weights, or use Roboflow's managed training and integrate predictions into your application through an API. Your team retains control over the application while reducing the infrastructure it needs to maintain.

Why not use AWS Rekognition or Google Cloud Vision instead of Roboflow?

AWS Rekognition and Google Cloud Vision work well when a general pretrained API covers your need, such as common object labels, text, or faces, and when you have a dedicated ML team set up to continue building it to adapt to your distinct organizational needs. Roboflow is built for teams that need a specialized vision application: custom models, application logic, and deployment on cameras and edge hardware, easily managed in one place.

The practical differences:

• One workflow from data to deployment: Roboflow keeps labeling, dataset versions, training, evaluation, Workflows, and deployment in the same workspace. On a general cloud platform, teams usually connect several services and write the glue code themselves.
• Vision-specific models: Roboflow supports RF-DETR, YOLO models, SAM 3, anomaly detection, action recognition, and fine-tuned vision-language models such as Qwen3-VL, and lets you compare them on your own images.
• Deployment where the cameras are: Roboflow Inference runs on NVIDIA Jetson, industrial PCs, servers, and Raspberry Pi, and self-hosted inference doesn't consume credits on any plan. Enterprise teams can run offline and connect results to PLCs through OPC UA or PLC Relay.
• Production operations: Vision Events, Deployment Manager, and Active Learning cover monitoring, device fleets, and retraining, which teams otherwise build themselves.

Roboflow also works alongside your existing cloud. Datasources imports images and video from AWS S3, Google Cloud Storage, and Azure Blob Storage, and Dedicated Deployments and Batch Processing run without you managing GPU infrastructure. See the detailed comparisons with Amazon Rekognition, Google Vision AI, and Azure Computer Vision.

How is Roboflow different from labeling tools like Labelbox, V7, or Encord?

Roboflow connects labeling directly to the model and application your team wants to put into production.

When evaluating Labelbox, V7, Encord, and Roboflow, consider what your team needs after the annotations are complete. With Roboflow, you can use the same platform to prepare data, train a specialized model, build application logic, and deploy the result. Your dataset becomes part of a system that can inspect products, count inventory, read labels, or respond to events.

For example, a defect inspection project can start with AI-assisted labeling, continue with training an RF-DETR model, and become a Workflow that filters predictions, makes a pass/fail decision, and saves failed inspections. Agent can help build that application, while engineers can inspect and modify its logic.

Deployment flexibility is another consideration. Roboflow supports managed cloud inference and self-hosted inference on compatible hardware. Teams can export datasets and supported model weights, subject to the model's license and export capabilities.

You can also bring existing annotation work into Roboflow. Import images and labels in a supported format, then use Roboflow for training and deployment. See the detailed comparisons with Labelbox, V7, and Encord to evaluate the fit for your workflow.

How does Roboflow provide pre-trained APIs (no training required)?

Roboflow lets you call existing models through APIs, so you can start making predictions before collecting or labeling a training dataset.

There are two main starting points:

• Foundation and pretrained models: Use an existing model for tasks such as object detection, segmentation, OCR, or visual question answering. Some models accept text prompts describing what to find or what question to answer.
• Community models on Roboflow Universe: Find a project with a trained model relevant to your application, such as detecting pallets, reading license plates, or identifying cells. Check that the project includes a usable model and review its license.

Supported pretrained models include options such as YOLO26 and Qwen3-VL, with deployment availability varying by model.

To use a model, select its model ID or documented alias, then send an image through the Inference SDK or REST API. For models supported on the Serverless Cloud API, Roboflow manages the inference infrastructure. Other models may require a Dedicated Deployment or self-hosted Inference.

You can also combine pretrained models in a Workflow and call the complete application through an API. For example, detect a shipping label, crop it, and extract its text in one pipeline.

"No training required" means you can start immediately. Test the model on your actual images to establish whether its accuracy, speed, and cost meet your requirements.

How does Roboflow provide advanced annotation for complex workflows?

Roboflow Annotate combines manual annotation, AI assistance, team review, and dataset analysis. You can choose the approach that fits your data and review the results before training.

For generating annotations, Roboflow provides several options:

• Auto Label: Use supported foundation models, a model trained on your dataset, or a compatible saved Workflow to label images in batches. Available options include SAM 3 and models from OpenAI, Google, and Anthropic.
• Label Assist: Use an existing trained model to suggest annotations for people to check and correct.
• Smart Select: Use SAM-powered interactive segmentation to create and refine polygons around objects. You can preview a mask and adjust its boundaries before accepting it.

The available tools and output formats depend on the project type and selected model. For example, keypoint Auto Label uses a trained keypoint model and a defined skeleton.

For collaborative work, teams can assign annotation jobs, review results, return images for correction, and inspect annotation history. Reviewer roles and other collaboration features depend on the workspace's plan and add-ons.

Dataset Health Check (opens in a new tab) adds another layer of inspection. It shows class distributions, missing and null annotations, image dimensions, object counts, and annotation-location heatmaps. These views help identify gaps, such as a defect class with few examples or objects that appear in only one part of the image. They complement expert review of whether each label is correct.

Can I train and deploy the latest YOLO models (like YOLO11 or YOLO26) on Roboflow?

Yes. Roboflow supports training and deployment for supported YOLO architectures, including YOLO11 and YOLO26. YOLO26 removes the need for Non-Maximum Suppression (NMS), which simplifies post-processing and helps on edge devices.

Licensing is the part to check before you ship. Ultralytics YOLO models are released under AGPL-3.0, which generally requires you to release the source of an application that uses them unless you have a commercial license. How you are covered depends on where the model runs:

• Roboflow Cloud: Commercial use of covered models through Roboflow's hosted deployment is included on every plan.
• Self-hosted: Commercial self-hosting of restricted model families, including YOLO, requires the applicable Enterprise license add-on.

Confirm your exact model in the licensing guide. If you want a permissive license from the start, RF-DETR Detection Nano, Small, Medium, and Large and all RF-DETR Seg sizes are released under Apache 2.0.

How is Roboflow ideal for multimodal data?

Roboflow supports applications that combine visual information with language, from preparing image-text datasets to running vision-language models and integrating their outputs into an application.

For example, a system might inspect a control panel and answer a question about its state, extract fields from a shipping document, or describe an unusual condition for an operator.

In a Multimodal project, you can define prompts or task prefixes and annotate the corresponding responses for each image. This supports datasets for tasks such as captioning, visual question answering, and structured extraction. A receipt project, for example, could contain separate questions for the total, tax, and merchant name.

Roboflow also supports fine-tuning and deployment for selected vision-language models. You can train a custom Qwen3-VL checkpoint and call it through its model ID. Supported deployment paths include the Serverless Cloud API, Dedicated Deployments, and self-hosted Inference, depending on the model and configuration.

With Workflows, a VLM can become one stage of a larger application. A detector could locate a nameplate, a crop step could isolate it, and a VLM could extract the fields your application expects.

Start by testing a pretrained model on your own images. Fine-tune when evaluation shows a consistent gap that representative training examples can address. Check the chosen model's training support, hardware requirements, output reliability, and data-handling configuration before deployment.

How is Roboflow optimized for video-heavy pipelines?

Roboflow provides different processing paths for live cameras, recorded footage, and applications running on your own hardware.

• Cloud Streaming: Run Workflows on live cameras using Roboflow-managed compute. A Video Connector can connect cameras on your network to the service, while supported sources also include direct RTMP streams.
• Batch Processing: Run a Workflow over stored videos and images. Roboflow provisions the compute and produces structured results, making this useful for reviewing historical footage or processing large media collections.
• Self-hosted Inference: Process video near the camera or within your infrastructure. Developers can use InferencePipeline for direct access to frames, custom processing, Workflows, and output handling.

InferencePipeline handles video sources and frame delivery. For recorded files, it processes every frame by default. For live streams, it can favor recent frames over older buffered frames, helping avoid a growing delay when inference cannot keep up. It also supports reconnection when a stream loses connectivity.

The right configuration depends on the event you need to detect. A slow inventory check may tolerate sparse frame sampling; a fast-moving part or brief action may require a higher processing rate. Test sampling, resolution, model size, and camera count against representative footage.

Workflows can then turn predictions into useful outputs such as counts, tracked objects, alerts, or recorded events. Measure both processing speed and whether the application captures the events that matter.

For applications where movement determines when to act, the Motion Detection block uses background subtraction to identify motion. For tracked objects, Track Class Lock uses class voting across frames to reduce label flicker and supports reassociation after occlusion. These tools help stabilize application logic when individual frame predictions vary.

Roboflow's open source Trackers library includes OC-SORT, ByteTrack, BoT-SORT, and McByte, plus an evaluation suite that tunes tracker parameters automatically. Roboflow also released Re-ID, an open source project for re-identification.

Teams building their own operator interfaces can use supervision-js to render detection overlays at high frame rates in browser and React Native applications.

What kind of hardware do I need to run Roboflow?

You can start using Roboflow's web tools with a standard computer and a browser. Local inference requires compatible hardware sized for your model and workload. The hardware you need depends on whether you are preparing data, training a model, or running predictions.

Roboflow Inference supports deployment paths for Linux, Windows, macOS, NVIDIA Jetson, and Raspberry Pi. Native desktop apps are available for Windows and Apple Silicon Macs, and Docker provides another installation option.

For an integrated industrial option, Roboflow AI1 (opens in a new tab) combines an 8 MP camera, NVIDIA Jetson Orin NX compute, and lighting in an IP54 enclosure. It runs supported Workflows on the device, connects to Deployment Manager for provisioning and updates, and records predictions and metadata as Vision Events. Operators can use a browser-based interface on the factory network to view streams and inspection results. This gives an inspection station camera capture, inference, and operational outputs in one device.

AI1 is part of a line of Roboflow hardware that also includes headless NVIDIA edge devices at every size, including Thor. RoboflowOS, Roboflow's edge operating system with full support for NVIDIA JetPack 7.2, powers these devices with over-the-air updates, fleet management, and remote management through Deployment Manager.

For production, size the hardware around the complete application. Model size, image resolution, camera count, frame rate, and additional Workflow steps all affect performance. A CPU may be sufficient for occasional image checks, while larger models or multiple live streams may need a GPU.

You can often use an existing compatible IP camera or USB camera. Verify the connection method, image quality, lighting, and required processing rate before buying hardware. Mobile and embedded deployment options also depend on the model and supported export format.

How long does it take to go from idea to production with Roboflow?

You can often build and test a Roboflow prototype in one session. Moving from a prototype to production takes additional validation and integration; the timeline depends on your accuracy requirements, operating conditions, deployment environment, and security review.

An existing model from Roboflow Universe can shorten initial setup when it fits your application. Test it on representative images before deciding whether you need additional data or custom training.

The work typically falls into three stages:

1. Prototyping: Use Roboflow Agent to select models, build a Workflow, and test sample images. Pretrained or foundation models can help you evaluate an idea before collecting and labeling a custom dataset. Read the Roboflow Agent announcement for an overview of this approach.
2. Custom training: If existing models do not meet your requirements, prepare representative images, review annotations, train a model, and evaluate it on held-out examples. The time required depends on data preparation, model choice, and the training job.
3. Production deployment: Validate the full application on your target hardware and camera feeds, connect its outputs to operational systems, and complete any security or compliance reviews. Test failures and recovery before expanding across production lines or sites.

What happens if I outgrow Roboflow?

Roboflow scales from your first ten images to deployments across thousands of devices. Because it uses open formats, you can also move any part of your stack elsewhere when your requirements change.

More than two million engineers use Roboflow, including teams at more than half of the Fortune 100 and companies such as Rivian, BNSF Railway, and USG. Roboflow processes more than 1 billion inferences a week.

As your requirements grow, you can scale Roboflow deployments, change which platform components you use, or move supported datasets and model weights into your own infrastructure.

For cloud workloads, the Serverless Cloud API provides autoscaling inference, while Dedicated Deployments let you provision compute for workloads that need more predictable capacity. Batch Processing handles large collections of stored images and videos. Your application can move to the deployment option that fits its volume and response-time requirements.

For deployments across facilities, Deployment Manager gives Enterprise teams tools to provision supported devices, configure camera streams, deploy Workflows, and monitor logs and telemetry. Roboflow's forward-deployed engineers can also help with architecture, hardware selection, and rollout planning.

You can change the division of work over time. A team might start with managed training and cloud inference, then move inference onto local hardware as camera volume increases. Another might keep its datasets in Roboflow while training models on an internal cluster.

You can export datasets in more than 40 formats, including COCO and YOLO, and download supported model weights. Export formats and weight availability vary by architecture, and model licenses still apply. That gives you options as your needs evolve, without requiring every stage of development and deployment to stay in the same environment.