How to Make AI Models?

Should You Build or Buy? The Decision That Comes First

In 2025, the answer to "how do I make an AI model?" increasingly starts with a different question: should you build one at all? According to Menlo Ventures' annual enterprise AI survey, 76% of enterprise AI use cases are now purchased rather than built internally — a dramatic reversal from 2024, when organizations were split nearly evenly at 47% built versus 53% purchased.

The money behind this shift is enormous. Enterprise AI spend hit $37 billion in 2025, up from $11.5 billion the year before — a 3.2x jump in a single year. Organizations are voting with their budgets, and they're overwhelmingly choosing ready-made solutions that reach production faster.

The build-vs-buy decision matters because building is genuinely hard, and most projects that attempt it don't survive. A Gartner survey cited by IBM found that only about 48% of AI projects ever make it to production. Deployment is where the value finally emerges — but it's also where infrastructure costs, IT integration complexity, and scalability problems kill otherwise promising work.

That doesn't mean building is always wrong. It means building should be reserved for cases where a custom model genuinely differentiates your business. The era of flagship in-house builds like BloombergGPT for finance and Walmart's Wallaby for retail has largely passed, replaced by faster paths to value.

Before committing to a build, pressure-test your decision against these realities:

• Deep learning models often require thousands to millions of training examples, and obtaining high-quality data for your use case is far from trivial.
• Fine-tuning is compute-intensive, typically demanding multiple powerful GPUs running in tandem for hours or days.
• Even successfully built models face rapid obsolescence — IBM notes that vendors' periodic retrains make any LLM "near-instantly obsolete" the moment it's released.
• Deployed models require ongoing monitoring for drift, since continuously changing data can quietly erode relevance.

There's a middle path worth noting: most organizations that "build" today are really customizing existing foundation models through approaches like retrieval-augmented generation (RAG) or fine-tuning, rather than training from scratch. AWS recommends starting with RAG for question-answering over your own documents, adding fine-tuning only for additional tasks — a far lighter lift than full model development.

One practical way to reduce build burden further: even when you buy or customize, post-deployment workflows like monitoring, reporting, and data handling can be automated with agent skills. SkillzBench is building a free directory of vetted agent skills plus a free MCP connector, so you can equip your agents with tested capabilities rather than hand-coding every workflow. Join the waitlist to explore what's coming.

The Model-Building Lifecycle: Data, Training, and Customization

Building an AI model isn't one big leap — it's a sequence of well-defined steps that most teams underestimate, especially the data part. IBM describes the lifecycle as model selection, data collection and preparation, hyperparameter selection, training, loss calculation, parameter optimization, and evaluation, and calls training "the most critical step" in an AI model's lifecycle.

The hard truth comes early: data. Deep learning models often require many thousands, if not millions, of examples to train adequately, and as IBM notes, obtaining high-quality training data for your use case "is not trivial." Supervised learning — which underpins most state-of-the-art AI models today — requires labeling that consumes significant time and labor. Budget for this reality before you budget for anything else.

Once training begins, the mechanics follow a familiar loop: the model makes predictions, a loss function measures how wrong those predictions are, and optimization adjusts parameters to shrink that loss. For conversational LLMs, IBM notes this typically means self-supervised pretraining, followed by supervised fine-tuning and reinforcement learning from human feedback.

Most teams, however, shouldn't train from scratch — they should customize an existing model. That's where the central decision arrives: retrieval-augmented generation (RAG) or fine-tuning. AWS offers clear guidance: start with RAG if you're building question-answering over your own documents, since it grounds answers in retrieved sources, provides references, and reduces hallucination. Use fine-tuning when the model needs to perform additional tasks such as summarization — keeping in mind that fine-tuned models don't cite sources and carry increased hallucination risk. And when in doubt, combine both: AWS points to UC Berkeley's RAFT research showing the pairing delivers the best of both worlds.

The practical trade-offs are stark. RAG can incorporate the latest documents in minutes, while fine-tuning takes hours to days depending on model size — and full fine-tuning is compute-intensive, requiring multiple powerful GPUs running in tandem. IBM highlights parameter-efficient fine-tuning (PEFT) as the workaround, updating only the most relevant parameters so retraining runs on simpler hardware. RAG has its own demands, though: chunking, embeddings, vector databases, and serious data engineering with metadata and privacy protections.

One more reality check: even Meta, Microsoft, and OpenAI periodically retrain their models, which makes any LLM near-instantly obsolete the moment it ships. Your customization work needs a maintenance plan, not just a launch plan.

That maintenance mindset extends beyond the model itself. Once your AI is deployed, the surrounding workflows — monitoring, retraining triggers, document pipelines — are exactly the kind of repetitive work agent skills can automate. SkillzBench is building a free directory of verified agent skills plus a free MCP tool to connect them to your agents; join the waitlist to be first in line when it launches.

Deployment: Where AI Value Is Won or Lost

Training a model is only half the battle — a model sitting on a laptop creates zero value. As IBM puts it, only when a trained model is deployed can its true value emerge, yet deployment is also where most AI projects quietly die.

The numbers tell a nuanced story. A Gartner survey cited by IBM's model deployment guide found that only about 48% of AI projects make it to production. Yet Menlo Ventures' 2025 enterprise AI report found that AI deals convert to production at nearly double the rate of traditional software — 47% versus 25% — suggesting purchased AI solutions move faster than conventional software rollouts, while internal builds often stall.

IBM outlines a six-step deployment process that treats deployment as engineering, not an afterthought:

• Planning — define requirements, infrastructure, and success criteria before anything ships.
• Setup — provision the serving environment and integrate with existing IT systems.
• Packaging — containerize the model so it runs consistently anywhere.
• Testing — validate behavior under realistic conditions.
• Monitoring and CI/CD — track performance and automate future updates.

You'll also need to pick the right deployment method. IBM identifies four: real-time inference for immediate responses, batch processing for large scheduled jobs, streaming for continuous data, and edge deployment for on-device processing — an approach growing in popularity for real-time, low-latency use cases. IBM warns that the main deployment challenges are cost (infrastructure and maintenance consume most of the budget), complexity, IT integration, and scalability.

Production discipline matters just as much as the initial launch. Because the data feeding ML models changes continuously, AWS's MLOps deployment best practices recommend verifying that a deployed model stays relevant to new data and updating it when it doesn't. Established guardrails include blue/green deployments (which avoid downtime during model updates), canary and linear traffic shifting, plus A/B testing when closed-loop feedback exists and shadow testing when it doesn't.

Once your model or agent is live, the surrounding workflow — monitoring, retraining triggers, reporting — is exactly where agent skills shine. SkillzBench is building a free directory of vetted agent skills and a free MCP tool to connect them to your agents, so post-deployment automation doesn't depend on unverified, potentially risky packages. Join the waitlist to be first in line when it launches.

Keep It Current: Monitoring, Drift, and Automating the Workflow

Shipping the model isn't the finish line — it's where the real work begins. A deployed model silently degrades as the world changes around it, and teams that skip monitoring pay for it in failed production outcomes.

According to AWS MLOps guidance, "the data is continuously changing," so you must verify that a deployed model remains relevant to new data — and update it when it doesn't. This is data drift in practice: your training distribution and your live distribution slowly diverge, and accuracy quietly erodes.

The problem is especially acute with large language models. As IBM notes, "Even the largest LLM vendors, such as Meta, Microsoft and OpenAI, periodically retrain their models—which makes any LLM near-instantly obsolete the moment it's released into the wild." Plan for obsolescence from day one.

A pragmatic monitoring routine covers three disciplines:

• Drift detection — compare live input distributions against training baselines and alert when they diverge.
• Safe update paths — use blue/green or canary deployments to ship new model versions without downtime, validated through A/B or shadow testing.
• Governance review — schedule periodic checks for bias, hallucination rates, and compliance as regulations tighten.

Governance deserves a seat at the table, not an afterthought. Industry analysis shows organizations are prioritizing responsible AI, bias mitigation, and model governance as governments introduce transparency and data-privacy frameworks. Building these reviews into your workflow now costs far less than retrofitting them later.

The good news: you don't have to run this discipline by hand. Agent skills — packaged instruction sets for coding agents and chat assistants — can automate monitoring checks, retraining triggers, and deployment workflow steps. SkillzBench is building a free, independent directory where you can browse, verify, and test agent skills, then connect them to your agent through a free MCP tool; it's currently pre-launch, and the waitlist is open. Given that published research found roughly 26% of skills carry at least one vulnerability, "verify before you deploy" applies to your automation layer just as much as to your model.

Treat monitoring as a product feature, not a chore. The teams that win with AI aren't the ones with the best launch-day model — they're the ones whose model is still accurate six months later.