BUILD VS BUY YOUR AI AGENT PLATFORM: A DECISION FRAMEWORK THAT SURVIVES CONTACT WITH SECURITY REVIEW
Framework, orchestration, governance, and the agents themselves - which layers to build, which to buy, and the failure modes of each path. Answer-first: buy the control plane, build the agents that encode your edge.
The short answer: buy (or adopt) the control plane - identity, policy, audit, approvals, cost governance - and build the agents that encode your competitive edge on top of it. Building the governance layer yourself is quarters of undifferentiated platform work; outsourcing the agents that encode your process knowledge hands your edge to a vendor. Teams that invert this - hand-rolling audit logs while buying generic 'sales agents' - get the worst of both.
Separate the four layers before deciding anything
- →Model layer: the LLMs themselves. Nobody sane trains these for operations use; you rent frontier APIs or run open weights.
- →Framework layer: orchestration libraries (tool calling, planning loops). Commodity, mostly open-source; adopt, don't build.
- →Governance layer: identity, RBAC, policy engine, audit, approvals, kill-switch, cost. Buildable but undifferentiated - this is the classic buy.
- →Agent layer: the process logic - what to check, when to escalate, what good looks like in YOUR operation. This is where your differentiation lives; build it (or have it built to your spec, owned by you).
The DIY governance trap
The trajectory is predictable: the pilot works, security asks the seven questions (identity? scopes? policy? approvals? audit? kill? cost?), and the team starts building middleware. Six months later there's a bespoke, half-tested control plane maintained by the two people who understand it - and zero new agents shipped. The estimate that matters isn't the first build; it's the permanent platform team you've just implicitly founded.
The agent-outsourcing trap
The mirror failure: buying 'off-the-shelf agents' for processes that are actually your differentiation. A generic invoice agent encodes generic invoice handling; your three-way-match exceptions, your supplier quirks, your tolerance rules are precisely what it doesn't know. You'll spend integration months teaching a black box what a built agent would have encoded transparently - and the teaching leaves with the vendor.
A decision table that mostly survives reality
- →Governance/control plane → BUY (or adopt a platform). Undifferentiated, security-critical, expensive to get wrong.
- →Orchestration framework → ADOPT open source. Building your own agent loop is a hobby, not a strategy.
- →Agents for commodity processes (password resets, FAQ deflection) → BUY if quality satisfies; these encode no edge.
- →Agents for differentiating processes (your underwriting, your planning, your exceptions) → BUILD on the bought plane, owned in your repos.
- →Evaluation harnesses → BUILD the datasets (they're your process truth), reuse tooling.
Costs people forget to compare
DIY governance carries a permanent maintenance tax and an audit-defense tax (novel controls take longer to review than recognized ones). Bought platforms carry integration cost and the risk of roadmap capture - mitigate with exportable audit logs, standard auth, and portability of your agent definitions. On the agent side, the forgotten cost is evaluation: whoever builds, YOU own the definition of correct, which means test sets and regression suites in your repos either way.
What this looks like when it works
A registry with a handful of named agents, each with one-page scopes a business owner signed. Policies in version control. An approval queue someone actually reviews. Audit you can hand an auditor without preparation week. And a backlog of next agents measured in weeks each - because the platform question was settled once, by buying it. (Transparency: this is the architecture our Agent Cloud sells, so we hold this view for a living. We'd hold it anyway - we watched too many teams spend two quarters building audit middleware while their actual use case waited.)