Build or buy your AI context layer? See what each really costs.

Every AI tool your company adopts needs connectors, permissions, ranking, governance, and cost control underneath it. See what each piece really costs, how building compares with buying, and how to evaluate solutions you can buy.

Build vs. buy estimate
9 parts to build, secure, and keep running, for every system and AI tool.
Component
Build it yourself
Engineer-weeks
Atolio
Context layer
  • Connectors
    Build it yourself
    10-20
    Atolio
    Included
  • Permission sync and identity
    Build it yourself
    4-8
    Atolio
    Included
  • Index and ranking
    Build it yourself
    12-18
    Atolio
    Included
  • Scoping
    Build it yourself
    2-4
    Atolio
    Included
  • Agent governance
    Build it yourself
    6-10
    Atolio
    Included
  • Cost tracking
    Build it yourself
    2-4
    Atolio
    Included
  • Security and deployment
    Build it yourself
    3-4
    Atolio
    Included
  • Model and tool connectivity
    Build it yourself
    2-4
    Atolio
    Included
  • People to run it
    Build it yourself
    0.5-1.0 FTE
    Atolio
    Maintained by Atolio
Total
Build it yourself
41-72
weeks to build
Atolio
Software license
plus your own cloud
Illustrative example with 10 systems

Trusted by teams across leading enterprises

  • X-Chem
  • StrongDM
  • U.S. Air Force
  • Cengage
  • PLI

Every new AI tool, model, and connection adds to your bill

And the costs compound: each new tool needs its own connections, permissions, and review, so cost and risk grow faster than adoption.

Click to jump to topic:

  • 10x

    more agents

    Effort
    Oversight

    Agent use at the world's largest companies is projected to grow tenfold by 2027, with token and API call loads rising a thousandfold.

    IDC, December 2025

  • 24x

    more tokens

    Cost

    Token consumption is projected to grow 24x by 2030 as agent adoption scales.

    Goldman Sachs Research, 2026

  • 10,000+

    more connections

    Risk
    Admin

    More than 10,000 MCP servers have been published, and each one opens another path from an AI tool to your data.

    Linux Foundation, December 2025

  • Every few months

    a new leading model

    Control
    Lock-in

    Frontier models have traded the lead multiple times since early 2025, and pricing and terms move with each release.

    Stanford AI Index, 2026

  • 40%+

    of agentic AI projects will be canceled

    Time
    Cost

    Gartner predicts over 40% of agentic AI projects will be canceled by the end of 2027, due to escalating costs, unclear business value, or inadequate risk controls.

    Gartner, June 2025

  • 76%

    buyers choosing to buy vs. build

    Buy

    Enterprises now buy 76% of their AI use cases rather than building them internally, up from 53% a year earlier.

    Menlo Ventures, December 2025

    6 costs that grow as AI adoption scales

    Where the money and time go as more of your company uses AI.

    • Tokens spent searching

      AI tools and agents query, read, and retry in every system, re-sending context on every turn.

      Grows with: Every system and AI tool
      With Atolio

      One retrieval from one index, using up to 80% fewer tokens.

    • Your team, as AI scales

      Access requests, connector upkeep, and a security review for every AI tool and every system.

      Grows with: AI tools × systems
      With Atolio

      Every AI tool inherits existing permissions, with one connection each.

    • Growing breach risk

      Broad standing access, copied content, and web search as an exit path.

      Grows with: Every connection
      With Atolio

      One governed path in your environment, with policy applied before any request completes.

    • AI nobody can account for

      Teams build the same AI tools twice, and spend shows up on the invoice.

      Grows with: Every team that builds
      With Atolio

      A live inventory of every AI tool and agent, its owner, and its cost.

    • Locked to one model

      Per-model wiring, plus one provider's pricing, outages, and roadmap.

      Grows with: Every model you add
      With Atolio

      Any model, no rebuild, with model routing coming.

    • Time to value

      Hand-built connectors and permission logic keep pilots from reaching production.

      Grows with: Every system you connect
      With Atolio

      Stood up in your cloud in hours, with each source indexed in about 1-2 weeks.

      9 components of a successful AI context layer

      Whether you build or buy, you need all 9. Click to see what each takes to build, and what changes with Atolio.

      Connectors

      Bring each system's content into one place, along with who can see it, and keep both in sync.

      Time to build
      1-2
      engineer-weeks per connector
      To build it

      One connector per system, each handling its API, rate limits, attachments, and deletions, then rework every time that API changes.

      With Atolio

      Native connectors for the systems you run, custom connectors built for you, and live fetch over MCP where data must be exact.

      Illustrative estimate. Adjust in the calculator below.

      Permission sync and identity

      Mirror who can see each item, resolve one person across every system, and pick up every change.

      Time to build
      4-8
      engineer-weeks
      To build it

      Map each system's access model, resolve groups and nested groups, link every account to one person, and keep up with change feeds.

      With Atolio

      Permissions sync continuously from your source systems and are checked on every query, with identity from your IdP.

      Illustrative estimate. Adjust in the calculator below.

      Index and ranking

      One searchable index across every system, ranked for the question and the person asking.

      Time to build
      8-12
      weeks platform
      4-6
      weeks retrieval
      To build it

      A platform architecture, a retrieval pipeline, embeddings, ranking across sources, and ongoing tuning and evaluation.

      With Atolio

      A hybrid index with lexical, semantic, and Collaboration Graph ranking in one pass, kept current in near real time.

      Illustrative estimate. Adjust in the calculator below.

      Scoping

      Limit each agent to the data its job needs, and keep sensitive data out until it's approved.

      Time to build
      2-4
      engineer-weeks
      To build it

      Per-agent source filters, a restricted-data list, an approval workflow, and testing for each new agent.

      With Atolio

      Knowledge scopes built by describing the job, with restricted data held back by default.

      Illustrative estimate. Adjust in the calculator below.

      Agent governance

      Know every agent, apply policy on every call, keep an audit trail, and be able to stop any agent.

      Time to build
      6-10
      engineer-weeks
      To build it

      A registry, a gateway in front of every agent, a policy engine, a logging pipeline, and a way to shut agents off.

      With Atolio

      One governed path: inventory, policy on every call, an activity timeline, and a kill switch.

      Illustrative estimate. Adjust in the calculator below.

      Cost tracking

      See what AI costs, by user, agent, model, and source, so you can plan from real numbers.

      Time to build
      2-4
      engineer-weeks
      To build it

      Telemetry on every call, attribution to people and agents, and dashboards finance can use.

      With Atolio

      A usage and cost dashboard, with spend broken down by user, agent, model, and day.

      Illustrative estimate. Adjust in the calculator below.

      Security and deployment

      Run it where your data lives, under your keys and sign-in, and get it through security review.

      Time to build
      3-4
      engineer-weeks of testing
      To build it

      Hardening, security, performance, and acceptance testing, plus a review for every tool and connection you add.

      With Atolio

      Deploys in your cloud or on-prem, including air-gapped, under your IAM, keys, and SSO.

      Illustrative estimate. Adjust in the calculator below.

      Model and tool connectivity

      Let every AI tool and agent reach the layer, and switch models without starting over.

      Time to build
      2-4
      engineer-weeks
      To build it

      An MCP server and API, authentication, per-model prompts and testing, and rework for each new tool.

      With Atolio

      One MCP and API endpoint for every AI tool, any model with your keys, and model routing coming.

      Illustrative estimate. Adjust in the calculator below.

      People to run it

      The engineers who keep everything above working, long after launch.

      Time to build
      0.5-1.0
      FTE for 10 systems, more as you add sources
      To build it

      A standing team for upkeep, incidents, new sources, and new agents, pulled from the work that sets you apart.

      With Atolio

      Atolio maintains the software, connectors, and updates. Your admins choose the sources, and agent authors register their agents.

      Illustrative estimate. Adjust in the calculator below.
      Total for 10 systems
      41-72 wks + 0.5-1.0 FTE

      5 ways teams approach the context layer

      Compare Atolio with
      Component
      Federated MCP
      Wire each tool to each system
      Build it yourself
      On Amazon Bedrock, Azure AI Search, or open source
      Point solutions
      Search, gateway, FinOps, agents
      Vendor-hosted platform
      Like Glean or Microsoft Copilot, in the vendor's cloud
      Atolio
      A context layer in your environment
      Connectors
      Permission sync and identity
      Index and ranking
      Scoping
      Agent governance
      Cost tracking
      Security and deployment
      Model and tool connectivity
      People to run it
      Watch for
      Tokens and connections climb with every system and AI tool
      A standing team, and upkeep that never ends
      A separate index, contract, and permission set per tool
      Your data in the vendor's cloud, and AI costs bundled into the price
      More setup than one MCP server, faster than wiring every system to every agent

      Build vs. buy, compared on total cost of ownership

      Building gives you control. Buying a vendor-hosted platform gives you speed. A context layer you run yourself gives you both.

      Atolio
      in your environment
      Build it yourself
      Buy vendor-hosted
      Atolio
      in your environment
      Time to production
      About 8 months from prototype to production, on average (Gartner)
      Faster to start, once your data can move to the vendor's cloud
      Live in weeks: stood up in hours, with each source indexed in about 1-2 weeks
      Upfront cost
      $750K-$1M for a custom generative AI application (Gartner)
      A per-seat annual license, often with a high minimum contract term or spend required
      A per-seat license, with infrastructure sized to your data before you commit
      Who runs it
      Your build team, then a standing team for connectors, permissions, and ranking
      The vendor, with your admins configuring it
      Atolio maintains the software and connectors. Your admins choose the sources.
      Where your data lives
      Your environment
      The vendor's cloud
      Your cloud or on-prem, including air-gapped
      What you pay for
      • Engineers to build and run it
      • Cloud and model costs
      • A security review for every new tool and connection
      • A per-seat license that grows significantly with headcount
      • Infrastructure and AI bundled in, or billed as usage credits
      • A software license
      • Your own cloud and model costs, with no markup and up to 80% fewer tokens
      • Connectors, permission sync, and updates, all included
      The hard parts
      The hard parts
      Permission sync
      Keeping access accurate as it changes in every source
      Ranking quality
      Tuning relevance across systems, and keeping it tuned
      Model flexibility
      Rework every time you add or switch a model
      The hard parts
      Permission sync
      Often rebuilt inside the platform, so it can drift from your sources
      Ranking quality
      Tuned to the vendor's own index
      Model flexibility
      Limited to the models the vendor chooses to offer
      The hard parts
      Permission sync
      Synced from every source and checked on every query
      Ranking quality
      Lexical, semantic, and Collaboration Graph ranking in one pass
      Model flexibility
      Any model, no rebuild, with model routing coming
      Watch for
      Watch for
      Upkeep that never ends, and pilots that stall before production
      Watch for
      Your data leaving your environment, and AI costs you can't see inside the bundle
      Watch for
      More setup than one MCP server, faster than wiring every system to every agent
      When building still makes sense:
      a narrow use case, 1-2 systems, and a team with real capacity to own it for years. For anything that spans the business, the upkeep usually outweighs the build.

      Run your own numbers

      Estimate the cost of building a context layer in-house to power your AI agents and tools, with the same components and your own systems, agents, and team. Every default is an illustrative estimate you can edit.

      Your setup
      What it takes to build what you'd otherwise buy
      Pieces you'd need to build
      Untick anything you already have
      8 of 8
      Your estimate
      Engineering effort to build
      41-72
      engineer-weeks
      Time to production with this team
      14-24
      weeks, before security review and rollout
      Engineers to run it, ongoing
      0.5-1.0
      full-time equivalents
      Three-year build-and-run cost
      $478K-$913K
      engineering time only; excludes product, site reliability, security review, cloud, and model costs
      With Atolio, these pieces come built and maintained. Your admins choose the sources, agent authors register their agents, and you pay a software license plus your own cloud and model costs.
      Defaults are illustrative estimates for a typical enterprise build. Adjust them to match your team. Ongoing staffing grows with the number of systems you connect. For context, Gartner puts the average generative AI prototype-to-production cycle at about 8 months (CIO Dive), and expects at least half of generative AI projects to overrun their budgets through 2028 (Campus Technology).
      Your setup
      What every new AI tool and system adds to your team's workload
      Your team's workload
      Point-to-point connections to secure and maintain
      80
      vs. 18 through Atolio
      Access requests when you add one system
      8
      one per AI tool, vs. 1 through Atolio
      Each new AI tool adds
      10 connections
      vs. 1 connection through Atolio

      FAQs

      Build vs. buy questions

      For most enterprises, buying an AI context layer costs less than building one, once you count upkeep.

      The build itself is only part of the bill. A do-it-yourself context layer needs a connector for every system, a permission sync that keeps up with every change, identity resolution across systems, ranking across all of them, and governance for every agent. Gartner puts the average generative AI prototype-to-production cycle at about 8 months, and expects at least half of generative AI projects to overrun their budgets through 2028. Connectors break when vendors change their application programming interfaces (APIs), permissions drift, and each new AI tool needs its own wiring and security review.

      Buying shifts that work to a vendor, but how you buy matters. A vendor-hosted platform copies your data into its cloud and usually bundles infrastructure and AI into one price, so you can't see what you spend on each (or if you're paying twice). A stack of point solutions adds a separate index, contract, and permission set for each tool.

      Atolio is a context layer you buy and run in your own environment. You pay a software license plus your own cloud and model costs, connectors and permission sync come built and maintained, and retrieving from one index uses up to 80% fewer tokens. Building still makes sense when the use case is narrow, covers 1-2 systems, and belongs to a team with spare capacity.

      Amazon Bedrock and Azure AI Search give you retrieval building blocks, not a finished context layer.

      Both are managed services for indexing and searching your content. Bedrock Knowledge Bases handles ingestion, embeddings, and retrieval for a set of supported data sources, and Azure AI Search offers hybrid and vector search with indexers for common sources. They're a sound foundation for a team that wants to own its stack.

      What remains yours is the work around them: a connector for every system they don't cover, permission sync that mirrors each source's access lists and keeps up with every change, identity resolution across systems, ranking across all of them, and governance and cost tracking for every AI tool and agent that uses the index. That work, and the team to maintain it, is where most of the cost of building sits.

      Atolio comes with that work done, and it runs in your own cloud account, including Amazon Web Services (AWS) or Microsoft Azure, or on-prem. You pay a software license plus your own cloud and model costs, and any assistant, including Microsoft Copilot, reaches it through the Model Context Protocol (MCP) or an application programming interface (API).

      Building connectors and permission sync in-house typically takes engineer-weeks per system, plus ongoing upkeep.

      Each connector has to handle the source's application programming interface (API), rate limits, attachments, and deletions, then be tested against real data volumes and edge cases. Permission sync is harder. It has to mirror who can see each item, resolve groups and nested groups, map one person across every system, and pick up every change without re-indexing everything. Getting it wrong is costly: in a 2024 Gartner survey of technology leaders, 40% said oversharing concerns delayed their Microsoft Copilot rollouts by 3 months or more.

      The larger cost comes after launch. Source systems change their APIs and rate limits, permission models drift, and every new source adds to the list, so connector upkeep becomes a standing job rather than a project. A missed permission change is also a security incident, so this work sits on the critical path of every security review.

      Atolio builds and maintains its connectors, including custom connectors for the systems clients need, and syncs permissions continuously from each source in near real time. Your engineers choose which sources, paths, and history to bring in, rather than writing and maintaining the plumbing.

      Estimate AI agent token costs from questions per day, tokens per question, and your model's price.

      Start with volume: how many people and agents ask questions, and how often. Agents ask far more often than people do, and International Data Corporation (IDC) projects enterprise agent usage to grow tenfold by 2027. Then estimate tokens per question, which depends heavily on how agents retrieve context. With federated Model Context Protocol (MCP) setups, an agent searches each system in turn and re-sends everything it has retrieved on every turn, so tokens per question climb with every system and every retry.

      Multiply volume by tokens per question and by your model's input and output prices, and remember that output tokens usually cost several times more than input tokens. Then plan for growth. Goldman Sachs Research projects token consumption could grow 24x by 2030 as agent adoption scales, so a number that works at pilot scale rarely holds in production.

      The most reliable way to get a real number is to measure it. In a pilot, Atolio measures your average cost per query on your own questions and systems. Its dashboard then attributes spend by user, agent, and model, and retrieving once from a single index uses up to 80% fewer tokens.

      Falling model prices won't make token costs a non-issue, because usage is growing faster than prices fall.

      The price of a given level of model capability keeps dropping, and that's real. But enterprises don't buy a fixed amount of capability. As prices fall, teams use more capable models, run more agents, and give each agent longer, multi-step tasks. Agentic work uses far more tokens than a person asking a question, because agents search, read, retry, and carry context forward on every step.

      Goldman Sachs Research projects token consumption could grow 24x by 2030, and International Data Corporation (IDC) projects a tenfold increase in enterprise agent usage by 2027. Volume like that outpaces per-token savings, which is why many teams see AI bills rise even as list prices fall. Pricing models are shifting too. Seat-based and credit-based plans are moving toward consumption at renewal, which puts the token bill in front of finance teams that didn't see it before.

      The durable fix is to use fewer tokens per answer. Atolio retrieves once from a single permission-aware index and sends the model only the context it needs, cutting token usage by up to 80%. Its cost dashboard shows spend by user, agent, and model, so you can see where tokens go and plan from real numbers.

      Yes, token costs matter even with Copilot credits, because credit and seat pricing are shifting toward consumption.

      Credits and per-seat plans hide the token bill today, but they don't remove it. As vendors move pricing toward consumption at renewal, and as teams add agents that run far more often than people ask questions, the cost underneath starts to show up. Goldman Sachs Research projects token consumption could grow 24x by 2030.

      Credits also cover one ecosystem. Most teams also run Claude, ChatGPT, Gemini, or agents built in code, each with its own usage and costs, and few can say what AI costs them today or which team drives it. It's worth getting that visibility before the bill arrives.

      Atolio works alongside Microsoft Copilot rather than replacing it. Copilot connects to Atolio through the Model Context Protocol (MCP) and draws grounded, permission-checked context from every system you run, not just Microsoft 365. Atolio's cost dashboard shows spend by user, agent, and model across every AI tool connected to it. And because Atolio retrieves once from one index and sends only the context each question needs, it uses up to 80% fewer tokens, which keeps costs predictable as usage grows.

      Atolio adds cloud infrastructure costs on your side, paid directly to your provider at your own rates.

      Atolio runs in your own cloud account or data center, so the compute, storage, and networking it uses appear on your existing cloud bill, under your existing discounts and commitments. There's no markup from Atolio on infrastructure, and none on the model calls you make through your own provider.

      What you need depends on how many people use it, which systems you connect, and how much content those systems hold. A deployment indexing a few sources for one team needs far less than one indexing years of history across the whole company. Because sizing drives cost, Atolio estimates it up front from your headcount, your sources, and your data volumes, before you commit.

      Frame total cost of ownership over three years: the software license, implementation, your cloud infrastructure, and the time your team spends running it. That view usually compares well against platforms that bundle infrastructure and AI costs into one price. If you already run Kubernetes, in the cloud or on-prem, Atolio fits alongside your existing clusters and the operations practices your team already follows.

      You measure cost per query before committing by running a pilot on your own questions and systems.

      A pilot runs in a dedicated account in your own cloud, with single sign-on (SSO) through your identity provider, so it typically needs no production access. You pick the use case and a few sources, Atolio connects and indexes them, and a group of real users works with it for a couple of weeks. Throughout, Atolio traces tokens per task and measures your average cost per query, broken down by user, agent, and model.

      Because it's your data and your questions, the result is a number you can plan from, not a vendor benchmark. You also see which sources actually get used, which helps you decide what to connect next and where existing tool spend could shrink.

      Rough timing: a day or two of preparation using the deployment checklist, about 1-2 weeks to connect and index each system, then about 2 weeks of user testing per team. Most teams send a security questionnaire early, since approval is usually the longest step. At the end, you have measured cost, answer quality from your own users, and an infrastructure estimate based on real data volumes, which together make the build vs. buy decision concrete.

      Atolio is priced as a software license, plus your own cloud and model costs.

      You pay Atolio for the software. You pay your cloud provider for the infrastructure Atolio runs on, and your model provider for the large language model (LLM) calls you make, directly and at your own rates. There's no markup on inference and no per-connector fee, so connecting another system doesn't change your Atolio bill.

      That's different from most enterprise AI platforms, which bundle infrastructure and model costs into one price. Bundling makes the bill simple to read, but it hides what you actually spend on compute and tokens. Unbundled pricing keeps each cost visible and lets you use the cloud commitments and model agreements you already have.

      Your total cost has four parts over three years: the license, implementation, your own infrastructure and model usage, and the time your team spends running it. Atolio sizes your data first, so the infrastructure estimate reflects your real sources and volumes rather than a guess. To get an estimate for your environment, book time with the team, and they'll walk through license options and expected infrastructure costs with you. Get your estimate.

      See what Atolio can save you