.png?width=1000&height=556&name=12.2_blog_hero%20-%20Version%20A%20(1).png)
This blog post focuses on new features and improvements. For a comprehensive list, including bug fixes, please see the release notes.
Getting models from development to production typically involves multiple tools, configuration files, and deployment steps. You scaffold a model locally, test it in isolation, configure infrastructure, write deployment scripts, and then push to production. Each step requires context switching and manual coordination.
With Clarifai 12.2, we've streamlined this into a 3-command workflow: model init, model serve, and model deploy. These commands handle scaffolding, local testing, and production deployment with automatic infrastructure provisioning, GPU selection, and health checks built in.
This isn't just faster. It removes the friction between building a model and running it at scale. The CLI handles dependency management, runtime configuration, and deployment orchestration, so you can focus on model logic instead of infrastructure setup.
This release also introduces Training on Pipelines, allowing you to train models directly within pipeline workflows using dedicated compute resources. We've added Video Intelligence support through the UI, improved artifact lifecycle management, and expanded deployment capabilities with dynamic nodepool routing and new cloud provider support.
Let's walk through what's new and how to get started.
The typical model deployment workflow involves multiple steps: scaffold a project structure, install dependencies, write configuration files, test locally, containerize, provision infrastructure, and deploy. Each step requires switching contexts and managing configuration across different tools.
Clarifai's CLI consolidates this into three commands that handle the entire lifecycle from scaffolding to production deployment.
1. Initialize a model project
clarifai model init --toolkit vllm --model-name Qwen/Qwen3-0.6B This scaffolds a complete model directory with the structure Clarifai expects: config.yaml, requirements.txt, and model.py. You can use built-in toolkits (HuggingFace, vLLM, LMStudio, Ollama) or start from scratch with a base template.
The generated config.yaml includes smart defaults for runtime settings, compute requirements, and deployment configuration. You can modify these or leave them as-is for basic deployments.
2. Test locally
clarifai model serve This starts a local inference server that behaves exactly like the production deployment. You can test your model with real requests, verify behavior, and iterate quickly without deploying to the cloud.
The serve command supports multiple modes:
3. Deploy to production
clarifai model deploy This command handles everything: validates your config, builds the container, provisions infrastructure (cluster, nodepool, deployment), and monitors until the model is ready.
The CLI shows structured deployment phases with progress indicators, so you know exactly what's happening at each step. Once deployed, you get a public API endpoint that's ready to handle inference requests.
The CLI now handles GPU selection automatically during model initialization. GPU auto-selection analyzes your model's memory requirements and toolkit specifications, then selects appropriate GPU instances.
Multi-cloud instance discovery works across cloud providers. You can use GPU shorthands like h100 or legacy instance names, and the CLI normalizes them across AWS, Azure, DigitalOcean, and other supported providers.
Custom Docker base images let you optimize build times. If you have a pre-built image with common dependencies, the CLI can use it as a base layer for faster toolkit builds.
Once deployed, you need visibility into how models are running and the ability to control them. The CLI provides commands for the full deployment lifecycle:
Check deployment status:
clarifai model status --deployment <deployment-id> View logs:
clarifai model logs --deployment <deployment-id> Undeploy:
clarifai model undeploy --deployment <deployment-id> The CLI also supports managing deployments directly by ID, which is useful for scripting or CI/CD pipelines.
Local testing is critical for fast iteration, but it often diverges from production behavior. The CLI bridges this gap with local runners that mirror production environments.
The model serve command now supports:
--health-check-port, --disable-health-check, and --auto-find-health-check-portLocal runners also support the same inference modes as production (streaming, batch, multi-input), so you can test complex workflows locally before deploying.
Model configuration used to require manually editing YAML files with exact field names and nested structures. The CLI now handles normalization automatically.
When you initialize a model, config.yaml includes only the fields you need to customize. Smart defaults fill in the rest. If you add fields with slightly incorrect names or formats, the CLI normalizes them during deployment.
This reduces configuration errors and makes it easier to migrate existing models to Clarifai.
The 3-command workflow removes friction from model deployment. You go from idea to production API in minutes instead of hours or days. The CLI handles infrastructure complexity, so you don't need to be an expert in Kubernetes, Docker, or cloud compute to deploy models at scale.
This also standardizes deployment across teams. Everyone uses the same commands, the same configuration format, and the same testing workflow. This makes it easier to share models, reproduce deployments, and onboard new team members.
For a complete guide on the new CLI workflow, including examples and advanced configuration options, see the Deploy Your First Model via CLI documentation.
Clarifai Pipelines, introduced in 12.0, allow you to define and execute long-running, multi-step AI workflows. With 12.2, you can now train models directly within pipeline workflows using dedicated compute resources.
Training on Pipelines integrates model training into the same orchestration layer as inference and data processing. This means training jobs run on the same infrastructure as your other workloads, with the same autoscaling, monitoring, and cost controls.
You can initialize training pipelines using templates via the CLI. This creates a pipeline structure with pre-configured training steps. You specify your dataset, model architecture, and training parameters in the pipeline configuration, then run it like any other pipeline.
This creates a pipeline structure with pre-configured training steps. You specify your dataset, model architecture, and training parameters in the pipeline configuration, then run it like any other pipeline.
The platform handles:
Once training completes, the resulting model is automatically compatible with Clarifai's Compute Orchestration platform, so you can deploy it using the same model deploy workflow. Read more about Pipelines here.
We've also launched a new UI for training models within pipelines. You can configure training parameters, select datasets, and monitor progress directly from the platform without writing code or managing infrastructure.
This makes it easier for teams without deep ML engineering expertise to train custom models and integrate them into production workflows.
Training on Pipelines is available in Public Preview. For more details, see the Pipelines documentation.
With 12.2, we've improved how Artifacts handle expiration and versioning.
Artifacts no longer expire automatically by default. Previously, artifacts had a default retention policy that would delete them after a certain period. Now, artifacts persist indefinitely unless you explicitly set an expires_at value during upload.
This gives you full control over artifact lifecycle management. You can set expiration dates for temporary outputs (like intermediate checkpoints during experimentation) while keeping production artifacts indefinitely.
The CLI now displays latest-version-id alongside artifact visibility, making it easier to reference the most recent version without listing all versions first.
These changes make Artifacts more predictable and easier to manage for long-term storage of pipeline outputs.
Clarifai now supports video intelligence through the UI. You can connect video streams to your application and apply AI analysis to detect objects, track movement, and generate insights in real time.
This expands Clarifai's capabilities beyond image and text processing to handle live video feeds, enabling use cases like security monitoring, retail analytics, and automated content moderation for video platforms.
Video Intelligence is available now.
We've made several improvements to how deployments work across compute infrastructure.
Dynamic nodepool routing allows you to attach multiple nodepools to a single deployment with configurable scheduling strategies. This gives you more control over how traffic is distributed across different compute resources, which is useful for handling spillover traffic or routing to specific hardware based on request type.
Deployment visibility has been improved with status chips and enhanced list views across Deployments, Nodepools, and Clusters. You can see at a glance which deployments are healthy, which are scaling, and which need attention.
New cloud provider support: We've added DigitalOcean and Azure as supported instance providers, giving you more flexibility in where you deploy models.
Start and stop deployments explicitly: You can now pause deployments without deleting them. This preserves configuration while freeing up compute resources, which is useful for dev/test environments or models with intermittent traffic.
Redesigned Deployment details page provides expanded status visibility, including replica counts, nodepool health, and request metrics, all in one view.
We've launched several UI improvements to make the platform easier to navigate and use:
The Playground now includes major upgrades to the Universal Search experience, with multi-panel (compare mode) support, improved workspace handling, and smarter model auto-selection. Model selections are panel-aware to prevent cross-panel conflicts, and the UI can display simplified model names for a cleaner experience.
You can now set pipeline steps to be publicly visible during initialization through both the CLI and builder APIs. By default, pipelines and pipeline step templates are created with PRIVATE visibility, but you can override this when sharing workflows across teams or with the community.
Support for Modules has been fully dropped. Modules previously extended Clarifai's UIs and enabled customized backend processing, but they've been replaced by more flexible alternatives like Artifacts and Pipelines.
We've made several improvements to the Python SDK, including:
For a complete list of SDK updates, see the Python SDK changelog.
You can start using the new 3-command deployment workflow today. Initialize a model with clarifai model init, test it locally with clarifai model serve, and deploy to production with clarifai model deploy.
For teams running long-running training jobs, Training on Pipelines provides a way to integrate model training into the same orchestration layer as your inference workloads, with dedicated compute and automatic checkpoint management.
Video Intelligence support adds real-time video stream processing to the platform, and deployment improvements give you more control over how models run across different compute environments.
The new CLI workflow is available now. Check out the Deploy Your First Model via CLI guide to get started, or explore the full 12.2 release notes for complete details.
Sign up here to get started with Clarifai, or check out the documentation for more information.
If you have questions or need help while building, join us on Discord. Our community and team are there to help.
