Build or buy a company brain: the real cost of building it in-house
A company brain prototype is ready in a weekend. The real cost is in what comes after: connectors, permissions and maintenance, which never end. For most companies it is cheaper to buy the platform and build only what is specific to the business.

Short answer: building a company brain in-house makes sense when it is the product you sell or when you have a requirement no platform meets. For most companies, buying the platform and building only what is specific to the business is cheaper, because the cost of building is not in the prototype. It is in three lines that never show up in the demo: connectors, permissions and maintenance.
The story usually starts the same way. Someone on the data team spends a weekend building an assistant that answers questions about the sales database and a folder of policies. The demo impresses the leadership team. The conclusion seems obvious: "if that took two days, we do not need to buy anything".
Six months later, the assistant is still used by the person who built it and by nobody else. This post is about what happens in those six months.
If the term is still new to you, start with what a company brain is.
Why is the prototype misleading?
The prototype is misleading because it solves the cheapest part of the problem. Wiring a model to a database and a few documents now takes a few lines of code and a good framework.
What the prototype leaves out is everything that separates a demo from a system the whole company can use:
- It runs on the credentials of whoever built it, so it sees everything that person sees.
- It knows two sources. The company has dozens.
- Nobody records who asked what.
- It lives in a notebook or on a screen only the technical team opens.
- Nobody knows what each answer costs or whether it is right.
- It only answers. It does not schedule, trigger or execute.
Each item on that list is a project. Together, they are the actual company brain.
What does it cost to build a company brain in-house?
The cost of building splits into eight lines, and only the first one shows up in the prototype.
| Cost line | What it includes | Type |
|---|---|---|
| Connectors | Databases, documents, internal tools, third-party APIs | Upfront and recurring |
| Permissions | Role-based access enforced on every source and every answer | Upfront and recurring |
| Audit and traceability | A record of every query and action, a cited source on every answer | Upfront |
| Channels | WhatsApp, Slack, Teams, web chat, each with its own API and rules | Upfront and recurring |
| Orchestration | Schedules, event triggers, retries, queues, alerts | Upfront |
| Quality | Evaluation sets, regression tests whenever the model or the prompt changes | Recurring |
| Model cost | Tokens, plus the instrumentation to know who spent what | Recurring |
| Maintenance | All of the above, forever | Recurring |
Three of those lines account for most of the surprises.
Connectors: the first is easy, the tenth is a product
A connector is not a connection. It is the connection, plus understanding the schema, plus handling limits and errors, plus keeping up when the source changes.
SQL databases are the simple case. Then come the ERP with a poorly documented API, the shared drive full of scanned PDFs, the legacy system that only exports files and the SaaS tool that changes its API twice a year. Every new source has its own way to authenticate, paginate and fail.
The math almost nobody does at the start: the number of connectors grows with the success of the project. The more useful the brain is, the more teams ask to plug in their own sources.
Permissions: the part that is not in the demo
Permissions are the most underestimated item because the demo works without them. In production, they decide whether the project survives.
The requirement sounds simple: each person only gets answers built from data they are allowed to see. In practice that means:
- Mapping the company's roles to the roles of each connected system.
- Applying the filter at the source, not after the model has already read the data.
- Handling documents, which rarely have access control as fine-grained as a database.
- Reflecting a role change or a departure on the same day.
- Proving all of it to an auditor, with a record.
One answer that shows payroll data to the wrong person is enough for the company to switch the project off. And when the official channel is switched off, people go back to pasting data into personal tools, which is the scenario we describe in Shadow AI.
Maintenance: the cost that never ends
A company brain is never finished. It depends on things that change all the time, all of them outside your control:
- The models. Versions are deprecated, prices change, behavior shifts between versions. Every switch calls for a new round of evaluation.
- The sources. A renamed field in the ERP breaks the queries that depended on it.
- The channels. Messaging APIs change their rules and limits.
- The company. New teams, new roles, new policies.
- The people. If the two engineers who built the platform leave, the knowledge about the company's brain leaves with them. It is the most expensive irony of the project.
Then there is model cost. A single agent task can trigger 5 to 30 model calls, and without per-task attribution the spend only shows up on the invoice. Building that instrumentation is one more project, which we cover in when the agent costs more than the developer.
How much does building cost in practice?
There is no single number, but there is an honest way to estimate one: add up the effort per line, in engineering weeks, and multiply by the real cost of your team.
The table below is an estimation model for a first governed version, with one database, one document repository and one channel. The ranges are our own assumptions, based on what we see in projects of this kind, not a market survey. Replace them with your numbers.
| Item | Estimated effort (engineering weeks) |
|---|---|
| Initial connectors (one SQL database and documents) | 3 to 6 |
| Role-based permissions enforced at the source | 4 to 8 |
| Audit and source citation | 2 to 4 |
| One channel (WhatsApp, Slack or Teams) | 2 to 4 |
| Workflow orchestration (scheduling, events, retries) | 4 to 8 |
| Quality evaluation and cost control | 3 to 6 |
| Total to a first governed version | 18 to 36 |
With two dedicated people, that is two to four calendar months before the first real use, not counting what they stopped doing during that time. After that, the platform needs a fixed share of the team just to stay up, and that share grows with every new source and channel.
To compare the two options over the same horizon, use three years:
- Build = (build weeks × fully loaded weekly cost of the team) + (annual maintenance × 3) + model cost + the opportunity cost of what the team did not ship.
- Buy = (license × 36 months) + rollout + internal hours to connect the sources + model cost.
Two cautions when you fill this in. Model cost exists in both scenarios, so it rarely decides the comparison. And opportunity cost is the heaviest and least visible item: the same engineers could be working on the product the company actually sells.
Build or buy: how do the two options compare?
| Criterion | Build in-house | Buy a platform |
|---|---|---|
| Time to first real use | Months | Weeks |
| Upfront cost | High, in engineering hours | Low, in license and rollout |
| Recurring cost | A fixed share of the team, growing | License, predictable |
| Control over how it works | Full | Limited to what the platform lets you extend |
| Governance (roles, audit) | You design and maintain it | Built in, you configure it |
| Main risk | Dependence on a few internal people | Dependence on the vendor |
| When the model changes | Your team re-evaluates and adjusts | The vendor adjusts |
Neither column is free. The question is which dependency your company would rather manage.
When does building in-house make sense?
Building makes sense in four situations:
- The brain is your product. If you sell the knowledge and agent layer to your own customers, it is your differentiator and it should be yours.
- You have a requirement no platform meets. A very specific regulatory or environment constraint that you have already confirmed with the vendors.
- You already have an AI platform team. With dedicated people, a recurring budget and a mandate to maintain what it builds.
- The scope is small and stable. One source, one team, no sensitive data. In that case the prototype may already be enough, and there is nothing wrong with that.
If none of the four describes your company, building tends to be the most expensive option dressed up as the cheapest.
When does buying make sense?
Buying makes sense when the company brain is a means and not the end: the company wants the answers and the workflows, not to own an AI platform.
The most common signs:
- The engineering team is small or already committed to the core product.
- There is sensitive data, and governance has to exist on day one.
- Several teams will use it, each with different sources and permissions.
- Leadership expects results this quarter, not next year.
Is there a middle path?
There is, and it is the one we recommend most often: buy the foundation and build what is yours.
The foundation is what every company needs in the same form: common connectors, permissions, audit, channels, orchestration, cost control. Rebuilding it creates no advantage.
What is yours is what no vendor knows: the business rules, the workflows, the specialized agents and the connectors to internal tools only your company has. That is where your engineers' time is worth the most.
Before you sign with any vendor, us included, ask these questions:
- Are sources connected where they live, or copied into the platform?
- Can I build my own connectors and tools?
- Are permissions enforced by role on every source?
- Is there an audit log I can show a regulator?
- Can I see the cost per workflow, per agent and per team?
- Can I choose and switch models?
- If I leave, what do I take with me?
Where Orkindo fits
Orkindo is the foundation, ready to use. It connects to databases, documents, internal tools and channels such as WhatsApp and Google Chat, with role-based access on every source, a full audit log and token usage tracking. Sources are connected where they already live.
Your team keeps what is specific: which questions matter, which workflows to automate, which rules apply. The first agent is usually in production within two weeks, which lets you test the decision to buy before committing a build budget.
If you want to run the numbers for your company, book a call.
Frequently asked questions
How long does it take to build a company brain in-house?
The prototype takes days. A first governed version, with role-based permissions, audit, one channel and workflow orchestration, takes 18 to 36 engineering weeks in our estimation model, which is two to four calendar months with two dedicated people.
What is the most underestimated cost of building a company brain?
Maintenance. Models are deprecated, sources change their schemas, channel APIs change their rules and the company creates new roles. All of that needs a fixed share of the team forever, and that share grows with every connected source.
Can we start by building and move to a platform later?
Yes, and the prototype is not wasted: it shows which questions matter and which sources answer them. What usually gets thrown away in the move is the surrounding infrastructure, such as permissions, audit and channels, which is exactly the most expensive part to build.
Does buying a platform create vendor lock-in?
It does, just as building creates dependence on the few internal people who know the system. To reduce the risk, prefer platforms that connect sources where they live instead of copying the data, and that let you choose the model and build your own connectors.
Is model cost lower when a company builds its own solution?
Not necessarily. Tokens are paid for in both scenarios. What changes the amount is control: routing between models, caching and cost measured per task. A company that builds in-house has to build that instrumentation too.