# Make or Buy for AI: Build, Buy or Have It Built?

> Buy where your process is generic, such as meeting notes, translation or email drafting. Build or commission where the process depends on your own knowledge and systems, such as quoting or field service. Build in-house only if you can run and maintain the agent for years.

Canonical URL: https://www.ruebstudio.de/en/guides/ai-strategy/build-vs-buy-ai  
Author: Dr.-Ing. Marcus Rüb, CEO  
Published: 2026-10-26

Once a company wants more from AI than a few chat licences, the same question comes up: buy a finished product, assemble something on a platform, build an agent from scratch, or pay someone to build it. The answer is rarely the same across the whole business. It depends on the individual process, the data involved and who will still be running the result two years from now. This guide sets out the options, the decision logic and the typical failure modes of each route.

## What does build vs buy mean for AI?

Build vs buy for AI is the decision whether a use case is delivered with off-the-shelf software, a configurable platform or a custom agent, and whether development happens in-house or with a partner. In practice that gives four routes, not two.

The four routes look like this:

- **Buy:** a finished application with AI features, such as a meeting assistant, a translation service or the AI add-on in your CRM. You configure it; you do not develop it.
- **Configure a platform:** a toolkit such as [Microsoft Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/fundamentals-what-is-copilot-studio), which Microsoft describes as a graphical, low-code studio for building and managing agents and workflows. You assemble agents from building blocks.
- **Build:** your own engineers develop an agent directly on a model API, with code, tests and your own infrastructure.
- **Commission:** an external partner develops an agent for your process, and you either run it yourself or have it run for you.

Hybrids are common. A typical one: a partner builds the core, then hands it over so that your team can run it and make small changes.

## Why is the question harder for AI than for ordinary software?

With ordinary software, build vs buy is mostly about cost and fit. AI adds three factors: output quality depends heavily on your own data, the underlying models change in months rather than years, and an agent takes actions in your systems instead of just displaying information. Risk and effort shift towards operations.

Three differences drive the decision:

1. **Value sits in the context.** Anyone can buy access to a language model. A quoting agent is only as good as its access to your price lists, bills of materials and past quotes. Packaged software does not know that data unless you connect it.
2. **The technology moves fast.** Anthropic's own article [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents), published in December 2024, now notes that much of the tooling landscape has changed since. If you build, you carry that churn.
3. **Agents act.** They send emails, open tickets and change records. Permissions, logging and approvals become part of the product, whether bought or built.

## Which route fits which use case?

The first question is whether a process is generic or differentiating. Generic processes such as minutes, translation or general research are best bought. Processes tied to your products, data and systems, such as quoting, field service or technical documentation, are candidates for a platform or a custom agent.

A rough mapping that works as a starting point:

| Use case | Usual route | Reason |
|---|---|---|
| Meeting notes, translation, drafting | Buy | Same process everywhere, mature products |
| Internal search across SharePoint or Teams | Platform | Data already lives in the platform, connectors exist |
| Quoting with bills of materials and pricing rules | Build or commission | Company-specific logic, several systems involved |
| Field service with equipment history | Build or commission | Knowledge spread across tickets, manuals and machine data |
| Sales research and call preparation | Platform or commission | Depends on how deeply the CRM must be connected |

For process-specific cases, see the overviews of AI agents for [quotation](https://www.ruebstudio.de/en/ai-agents/quotation), [technical service](https://www.ruebstudio.de/en/ai-agents/technical-service), [knowledge management](https://www.ruebstudio.de/en/ai-agents/knowledge-management) and [sales](https://www.ruebstudio.de/en/ai-agents/sales).

Two follow-up guides are planned: a decision tree that weighs an off-the-shelf tool, a platform and a custom agent step by step, and a guide to choosing agencies, consultants and integrators. This overview sets out the logic; those two go into the individual decision.

## What are the pros and cons of buying?

Buying is the fastest and lowest-risk route as long as the process fits the product. Maintenance, model upgrades and support come included. The downside is that you inherit the vendor's data model, pricing and roadmap, and packaged software rarely covers your edge cases.

In favour of buying:

- **Time to value:** set up rather than develop.
- **Operations included:** the vendor handles security patches and model changes.
- **Outside evidence:** according to [Fortune's coverage](https://fortune.com/2025/08/18/mit-report-95-percent-generative-ai-pilots-at-companies-failing-cfo/) of the MIT NANDA report "The GenAI Divide", buying from specialised vendors and building partnerships succeeds about 67% of the time, while internal builds succeed only about a third as often. Fortune reports the study draws on 150 interviews, a survey of 350 employees and an analysis of 300 public AI deployments.

Against buying:

- **Fit:** special cases, variant logic or legacy systems without standard interfaces are rarely covered.
- **Lock-in:** export formats, notice periods and rights to your configuration are often weaker than they seemed at signing.
- **Data flows:** a cloud vendor usually processes personal data on your behalf. Under [Article 28 GDPR](https://gdpr-info.eu/art-28-gdpr/) that requires a data processing agreement, and you may only use processors that give sufficient guarantees.

One caveat on the MIT figure: it does not separate buying software from building with a partner. Partnerships sit in the more successful group; purely internal builds are the ones that struggled.

## When does a platform make sense?

A platform fits when your data already lives in one ecosystem and the agent mainly finds, summarises and triggers simple actions. You move faster than with code and stay closer to your process than with packaged software. The limits show up with complex logic, systems outside the ecosystem and usage-based billing.

What to check:

- **Connectors:** are there ready-made connectors for your systems, or will you write your own? Microsoft lists both prebuilt and custom connectors for Copilot Studio.
- **Billing:** many platforms charge per message, call or credit. Model what happens to cost at ten times today's usage.
- **Testability:** can you check answers against fixed test cases before a change goes live? Microsoft, for example, describes evaluations with test sets in Copilot Studio.
- **Exit:** agents built in a low-code platform rarely move to another platform. What you can take with you are prompts, knowledge and test cases, provided you maintain them outside the platform.

## When is a custom agent worth it?

A custom agent pays off when the process differentiates you, several systems are involved and the agent should follow your rules for years rather than a vendor's. It costs more to build and run, but gives you control over logic, data, model choice and hosting.

Signals that point to a custom agent:

- The agent must combine data from ERP, PLM, CRM and file shares.
- Results must be traceable: which source, which rule, which approver.
- You want to switch models or run them on your own hardware, see [sovereign AI](https://www.ruebstudio.de/en/sovereign-ai).
- The process involves know-how that should not live inside someone else's cloud product.

Open standards reduce lock-in. The [Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro), for instance, is an open-source standard for connecting AI applications to external systems. Systems exposed through such interfaces can be used by different agents and models.

Anthropic's advice in [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents) is to find the simplest solution possible and only add complexity when it demonstrably improves outcomes. That applies to build vs buy as well: a custom agent is not a goal in itself.

## Build in-house or commission a partner?

Building in-house makes sense if you have engineers who can run, test and adapt the agent to new models over the long term. Commissioning makes sense if you lack that capacity or want a robust first version sooner. Either way, the deciding factor is who holds responsibility and rights after go-live.

When building in-house, companies often underestimate:

- **Operations:** monitoring, debugging, controlling model costs, keeping libraries up to date.
- **Quality assurance:** without a fixed set of test cases you will not notice when a model change makes answers worse.
- **Key-person risk:** an agent built and understood by one person is an operational risk.

When commissioning, settle these points in the contract:

- **Rights:** usage and modification rights to code, prompts, configuration, test cases and documentation.
- **Handover:** whether and how your team can take over the agent, including training.
- **Operations:** who responds to incidents, who pays for model usage, who holds the credentials.
- **Data:** a data processing agreement under Article 28 GDPR if the partner handles personal data.

How to recognise a suitable partner and what to ask in selection meetings is covered in the planned guide on choosing an AI partner.

## How does the EU AI Act affect the decision?

The AI Act distinguishes providers from deployers. If you buy and use a system, you are usually a deployer. If you develop a system, or have one developed, and put it into service under your own name, you may be a provider. How heavy the obligations are depends mainly on the risk category. What follows is orientation, not legal advice.

- **Provider:** under [Article 3(3)](https://artificialintelligenceact.eu/article/3/), this includes anyone who develops an AI system or has one developed and places it on the market or puts it into service under their own name or trademark. Commissioning does not automatically keep you out of the provider role.
- **Deployer:** under Article 3(4), anyone using an AI system under their own authority.
- **Role change:** under [Article 25](https://artificialintelligenceact.eu/article/25/), a deployer can become the provider of a high-risk system, for example by putting their name on it, making a substantial modification, or changing its intended purpose so that it becomes high-risk.
- **AI literacy:** [Article 4](https://artificialintelligenceact.eu/article/4/) applies to providers and deployers alike, so it concerns you even if you only buy.

Most agents for quoting, service or knowledge search are unlikely to fall into the high-risk categories. Still check each use case, especially anything touching HR or decisions about individuals.

## What do you need in place for each route?

Whatever the route, you need three things: accessible data, an owner in the business process and a clear measure of success. The closer you get to building, the more technical prerequisites are added.

| Prerequisite | Buy | Platform | Build / commission |
|---|---|---|---|
| Data digital and findable | low | medium | high |
| Interfaces to core systems | low | medium | high |
| Business owner for the process | yes | yes | yes |
| In-house technical operations | no | partly | yes, or covered by contract |
| Test cases with expected results | helpful | important | essential |

## How should you make the decision?

Start from the process, not the product. Describe the use case, first check whether packaged software covers it, then whether an existing platform is enough, and only then whether a custom agent is needed. That order stops you building things you could buy.

1. **Describe the process:** inputs, outputs, systems involved, who works on it today and for how long, where errors occur.
2. **Collect test cases:** 20 to 50 real examples with the result a good employee would produce. This is the benchmark for every option.
3. **Check the market:** does any product solve these test cases without rework? Try it on your examples, not on the vendor's demo.
4. **Check platforms:** can the case be covered with licences and connectors you already have?
5. **Assess custom options:** if neither works, compare effort, operations and rights for building and commissioning.
6. **Start small:** run a prototype against the test cases before committing to a route.
7. **Schedule a review:** after six to twelve months, check whether the market has caught up.

## What are the limits and risks?

Each route has a typical way of failing. Bought software goes unused because it does not fit the process. Platform agents multiply without control because every department builds its own. Custom agents stay prototypes because nobody owns operations. Knowing the pattern lets you counter it.

- **Buying without a process check:** licences for everyone, but no use case where value is measured.
- **Platforms without governance:** many agents with unclear permissions and no owners. Our overview of a lean [AI governance framework](https://www.ruebstudio.de/en/guides/ai-strategy/ai-governance-framework) shows what minimal rules look like.
- **Building without an operating plan:** the prototype works in the demo, but nobody handles errors, costs or model changes.
- **Commissioning without rights:** you pay for development but own neither the code nor the prompts.
- **One rule for the whole company:** "we build everything" or "we only buy" ignores that use cases differ.

The MIT figures are not an argument against custom solutions as such either. What they mainly show is that purely internal builds without experienced partners succeed less often.

## How do you get started?

Pick one process with noticeable effort and a clearly measurable outcome, collect test cases and work through the options in the order above. Decide per use case, write down the reasons and set a date to revisit the decision.

If the question is part of a wider plan, place it within your [AI strategy for mid-sized companies](https://www.ruebstudio.de/en/guides/ai-strategy/ai-strategy-for-mid-sized-companies): that is where the list of use cases comes from, each of which gets its own build vs buy decision.

A pragmatic first step:

- Use existing licences for generic tasks and train staff, which also supports the AI literacy duty under Article 4 of the AI Act.
- For one process-specific case, build or commission a prototype and test it against real cases.
- Put rights, operations and data flows in writing before the prototype becomes part of daily work.

The overview of [AI agents](https://www.ruebstudio.de/en/ai-agents) shows what custom agents for quoting, service, knowledge and sales look like in practice. If you first need a company-wide direction with clear ownership, a [fractional head of AI](https://www.ruebstudio.de/en/fractional-head-of-ai) is the next step; to get a team started together, see the [workshop](https://www.ruebstudio.de/en/workshop).

## Frequently asked questions

### Is build vs buy a one-off decision for AI?

No. Make it per use case and revisit it, because off-the-shelf products add features quickly. Something that needs custom work today may be a setting in a product you can buy next year.

### Do we own the code if a partner builds our AI agent?

Only if your contract says so. Spell out usage and modification rights for code, prompts, configuration and test data, otherwise switching partners later becomes very hard.

### Does commissioning an agent make us a provider under the EU AI Act?

It can. Article 3 of the AI Act counts as a provider anyone who has an AI system developed and puts it into service under their own name. What that means in practice depends on the risk category; treat this as orientation, not legal advice.

### Can a company without developers build agents at all?

Low-code platforms let non-developers assemble simple agents. Connecting ERP or CRM systems and running agents in production still needs someone who understands interfaces, testing and permissions, in-house or external.

## Sources

- [Fortune: MIT report – 95% of generative AI pilots at companies are failing (18 Aug 2025)](https://fortune.com/2025/08/18/mit-report-95-percent-generative-ai-pilots-at-companies-failing-cfo/)
- [Anthropic: Building effective agents (19 Dec 2024)](https://www.anthropic.com/engineering/building-effective-agents)
- [Microsoft Learn: Overview – Microsoft Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/fundamentals-what-is-copilot-studio)
- [Model Context Protocol: What is MCP?](https://modelcontextprotocol.io/docs/getting-started/intro)
- [EU AI Act, Article 3: Definitions](https://artificialintelligenceact.eu/article/3/)
- [EU AI Act, Article 4: AI literacy](https://artificialintelligenceact.eu/article/4/)
- [EU AI Act, Article 25: Responsibilities along the AI value chain](https://artificialintelligenceact.eu/article/25/)
- [GDPR Article 28: Processor](https://gdpr-info.eu/art-28-gdpr/)
