The pressure is on, and the assignment is clear: Build with AI, and do it faster than your competitors. 

But before you can build anything, you need to answer a fundamental question: Which AI models should power your applications? This is where most enterprises hit their first roadblock.

Public repositories have more than 2 million models to choose from, each with different capabilities and resource requirements. And while commercial models sidestep the selection issue—you simply license GPT or Claude rather than choosing from millions—they also bring new challenges, such as vendor lock-in, unpredictable pricing, and data sovereignty concerns.

As a result, enterprises end up spinning their tires. Nearly two-thirds of organizations’ AI initiatives are stuck in experimentation or piloting stages, McKinsey research shows. And even when organizations do move fast, they often take on serious risks: 47% operate without AI-specific security controls, and 58% worry their unstructured data will be exposed.

So, how can enterprises escape this trap? The answer isn’t bigger repositories or faster vetting. It’s model curation—a systematic approach to evaluating models against security, performance, and licensing criteria, and providing access only to those that meet enterprise requirements.

What is Model Curation?

Model curation is the process of selecting, validating, and documenting AI models to help organizations evaluate their suitability for enterprise deployment.

Think of it like buying a car. You wouldn’t just pick one at random from every vehicle ever made. You’d start by asking yourself the basics: What’s in my price range? What’s available nearby? Then, you’d narrow further based on your needs: Does it have enough space for my family? What’s the safety rating? Do I need four-wheel drive? A responsible dealer provides verified data to answer these questions—plus crash test ratings, EPA estimates, and warranty terms—so you can make an informed decision.

Model curation works in the same way. It answers enterprises’ questions about AI models so they can choose one or more that make sense for them. These questions may include: 

    • Can we use this in a commercial application? 

    • What data was it trained on? 

    • Does it contain security vulnerabilities or safety risks? 

    • How much memory does it need? 

    • How fast will it process requests? 

    • What happens to performance if we optimize it for our infrastructure constraints? 

    • What licensing attribution do we need to provide?

    • How much will it cost to run at scale?

Without curation, organizations have to build this knowledge from scratch for every model they consider. 

The Limits of Alternative Approaches

As enterprises recognize the model selection challenge, two alternative approaches have emerged. Both offer partial solutions, but neither addresses the core problem.

The DIY Research Approach

This approach treats model selection as a research project. It expects organizations to define their constraints, create evaluation datasets, manually test candidate models, and calculate total cost of ownership before making decisions.

On paper, this makes sense. Thorough evaluation should lead to better decisions. Plus, organizations that do the work themselves should gain a deep understanding of their chosen models.

But this puts the burden entirely on enterprises to become model experts. For teams already stretched thin, spending weeks or months on model evaluation isn’t viable, especially when they need to repeat the process for every use case. And with 75% of companies racing to adopt AI, organizations that need to deploy quickly can’t afford to turn model selection into a never-ending research project.

The Artifact Management Approach

This approach treats AI models as software artifacts. It expects organizations to apply their existing scanning, versioning, and governance tools—the same ones they’re using for code dependencies and container images—to AI models.

The artifact management approach certainly provides value: centralized storage, access controls, basic security scanning, and integration with existing DevOps workflows. And for organizations already invested in artifact management platforms, it offers a familiar mental model.

But AI models aren’t software packages. A Python library either works or it doesn’t. An AI model exists on a spectrum of performance, accuracy, cost, and risk—and that spectrum changes based on how you deploy it. 

Artifact management answers the question, “Is this model available and scanned?” Yet the questions enterprises actually need answered are fundamentally different: “Which model best fits our use case and constraints?” and “What are the real-world implications of deploying this?”

Anaconda’s Approach to Model Curation

Effective model curation boils down to three things: secure infrastructure you can verify, performance data that reflects real-world deployment, and the flexibility to run models where you actually need them. 

Here’s how Anaconda approaches each:

Selective Curation From Millions of Models

We start by filtering the over 2 million AI models available in public repositories. From that universe, we select only those that meet strict enterprise requirements.

Our filtering prioritizes commercial-friendly licensing—we avoid models with non-commercial restrictions that could block enterprise deployment. We favor models from established publishers like Meta, Google, and Mistral, though we remain open to emerging sources that meet our validation standards. 

We look for strong community adoption as proof of real-world reliability, and we verify that models can actually run on standard enterprise infrastructure. We also continuously monitor the ecosystem as new models are released, and we update our catalog to feature the latest high-performing options while maintaining archived versions for stability.

This upfront filtering means organizations can evaluate a curated set of validated models, rather than painstakingly sifting through millions of unsuitable options.

Controlled Security Pipeline

Most model repositories provide pre-compiled binaries and scan them for known vulnerabilities. But supply chain attacks targeting AI components are rising: Attackers can compromise models and binaries in public repositories, and organizations downloading them may not realize they’ve been tampered with.

At Anaconda, we safeguard against these risks by building our inference infrastructure from source using our trusted package ecosystem—the same one 95% of Fortune 500 companies already use.

This means we compile llama.cpp (the runtime engine that executes models) from verified packages, rather than downloading pre-built binaries of unknown origin. And when we quantize models to optimize their size and performance, we use that same controlled toolchain. The result is a trusted processing environment from start to finish.

Optimization and Benchmarking

Every model undergoes quantization—a compression process that reduces model size by 0.5x to 5x with documented performance trade-offs, which allows for more cost-effective deployment. We then benchmark each quantized version using industry-standard tests.

For each model and quantization level, we document three metrics: performance benchmarks showing accuracy and quality for specific use cases (text generation, embeddings, code), resource requirements detailing memory and compute needs, and processing speed showing response times under realistic conditions.

This data helps organizations make decisions based on their actual requirements and constraints, rather than benchmark scores from model cards. It also enables significant cost savings: Teams can deploy optimized models on less expensive infrastructure while maintaining the performance their use case requires.

Flexible Deployment Infrastructure

The same quantized model can run on a developer’s laptop for prototyping, in a private cloud for production, or on CPUs when GPU resources aren’t needed.

This flexibility matches how organizations actually work. Developers prototype locally before committing to cloud infrastructure. Regulated industries need models running entirely within their private environments. And with enterprise AI spending averaging over $85,000 monthly, cost-conscious teams need alternatives to expensive GPU deployments.

Enterprise Version Management

We maintain both current and previous versions of each model family. When newer versions are released, we archive older models rather than removing them, which means existing workflows can continue uninterrupted while new deployments use the latest versions. This stability is especially critical for production systems, where model updates can break deployed applications if dependencies and versions aren’t carefully managed.

Documentation That Enables Deployment Decisions

Most models come with basic model cards—high-level descriptions of what the model does and how it was trained. But research analyzing over 32,000 model cards found uneven informativeness, with sections addressing limitations and evaluation showing the lowest completion rates.

Anaconda’s AI Bill of Materials (AIBOM) addresses this gap. The AIBOM is a comprehensive document we create for every model in our catalog, and it provides transparency about each model, including: 

    • Performance data: Benchmarks, resource requirements, and processing speeds for each quantization level

    • License documentation: Clear summaries of usage restrictions, attribution requirements, and commercial permissions

    • Security processing details: Documentation of our controlled build and quantization process

The AIBOM also categorizes risks across three dimensions: technical risks (memory requirements, performance trade-offs at different quantization levels), legal risks (license restrictions, usage limitations), and operational risks (version stability, integration complexity).

What This Means For You

Organizations can’t afford to spend months (or longer) vetting AI models. Competitors are moving faster, business leaders expect results, and development teams need the autonomy and tools to build high-quality applications at scale.

Model curation is the solution. It gives your team access to pre-validated models with verified security, documented performance, and clear licensing so they can deploy with confidence. And by shortening your deployment timeline, you’ll be shipping AI capabilities while your competitors are still vetting models.

Learn how AI Catalyst, Anaconda’s AI development suite, can help you select and deploy models faster—without sacrificing security or governance.