The build-versus-buy debate for AI agents is dead. In 2026, enterprise AI deployment exists on a spectrum with five distinct tiers—from maximum control (vanilla code) to maximum convenience (embedded SaaS). Most production systems combine multiple tiers, not one.
The question is no longer "Do we build or buy?" It's "Which tier gives us the right trade-off between control and speed for this specific use case?"
For CTOs, VPs of Engineering, and AI platform leads, understanding this spectrum is the difference between a 6-month build that ships fast and a 2-year engineering saga that never reaches production.
The 5-Tier Build-to-Buy Spectrum
When you deploy AI agent capabilities—whether as a product, platform, or internal tool—you choose from five approaches. Each tier trades control for convenience in different proportions.
Tier 1: Vanilla Code & SDKs (Maximum Control)
What it is: Write agents from scratch using base SDKs from model providers (OpenAI SDK, Anthropic SDK, Google Gemini API). Full control over agent architecture, reasoning loops, tool integration, and deployment infrastructure.
Who uses it:
- AI-first startups building differentiated agent products
- Research teams experimenting with novel agent architectures
- Companies with proprietary reasoning requirements (e.g., financial modeling, complex compliance logic)
Strengths:
- Zero abstraction layers → You own every decision (state management, tool calling, error handling)
- No vendor framework lock-in → Swap models, change orchestration logic, refactor architecture anytime
- Maximum customization → Build agent workflows that match your exact business process
Weaknesses:
- Slowest time to production → 6-12 months from prototype to production-ready agent
- Highest engineering cost → Requires senior AI engineers to build orchestration, memory, and governance layers from scratch
- No built-in guardrails → Security, compliance, observability = your problem
Cost profile:
- Initial build: $150K-$500K (engineering salaries for 3-6 engineers for 6-12 months)
- Ongoing maintenance: $100K-$300K/year (model updates, infrastructure, monitoring)
Real-world example:
- OpenAI's internal Codex deployment (2023-2025): Built vanilla agent orchestration before releasing productized APIs. Took 18 months to production, required 15+ ML engineers, but delivered proprietary agent architecture no off-the-shelf framework could match.
🔍 When Vanilla Code Makes Sense
Deploy Tier 1 if:
- Your agent reasoning is a competitive moat (e.g., proprietary decision logic)
- You have 5+ senior AI engineers who can maintain custom orchestration
- Your use case can't be solved with existing frameworks (highly specialized domain)
- You need zero vendor framework lock-in (must swap models/tools without refactoring)
Skip Tier 1 if: You need to ship in <6 months, or you're deploying common use cases (customer support, data analysis) that frameworks already solve.
Tier 2: Agent Frameworks (Control with Structure)
What it is: Use open-source or commercial frameworks (LangGraph, CrewAI, AutoGen, Microsoft Semantic Kernel) that provide pre-built orchestration, memory management, and tool integration—but still require code.
Who uses it:
- Engineering teams building custom agents faster than vanilla code
- Organizations standardizing multi-agent workflows across departments
- AI platform teams providing internal agent infrastructure to product teams
Strengths:
- Faster than vanilla code → 2-4 months to production (frameworks handle orchestration boilerplate)
- Architectural flexibility → Define custom agent roles, workflows, and tool connections
- Open-source governance → LangGraph (LangChain), AutoGen (Microsoft), CrewAI (community) have transparent roadmaps
Weaknesses:
- Framework lock-in → Migration from LangGraph to AutoGen = significant refactoring
- Still requires code → Not accessible to non-engineers (product managers, analysts)
- Maintenance burden → Framework updates may break your agent workflows
Cost profile:
- Initial build: $50K-$200K (3-6 engineers for 2-4 months)
- Ongoing maintenance: $40K-$120K/year (framework upgrades, agent tuning)
Real-world example:
- Morgan Stanley with CrewAI (2025): Built multi-agent financial research system using CrewAI framework. Shipped in 3 months vs. 12-month vanilla code estimate. 5-agent team (analyst, data retriever, compliance checker, summarizer, validator) processes 10K+ research queries/month.
Framework comparison:
| Framework | Best For | Licensing | Enterprise Adoption |
|---|---|---|---|
| LangGraph | Complex multi-agent workflows | MIT (open-source) | High (LangChain ecosystem) |
| CrewAI | Role-based agent teams | MIT (open-source) | Medium (startup-friendly) |
| AutoGen | Research-heavy, iterative agent loops | MIT (open-source) | High (Microsoft backing) |
| Semantic Kernel | .NET/Azure integration, enterprise infra | MIT (open-source) | Medium (Microsoft shops) |
Tier 3: Managed / Infra Platforms (Orchestration + Operations)
What it is: Platforms that provide agent orchestration, deployment infrastructure, monitoring, and governance—but still require configuration and code for custom logic. Examples: Databricks AI Agent Builder, AWS Bedrock Agents, Google Vertex AI Agents.
Who uses it:
- Enterprises already standardized on a cloud provider (AWS, Azure, GCP, Databricks)
- Teams needing built-in governance, observability, and security compliance
- Organizations deploying agents at scale across multiple departments
Strengths:
- Integrated infrastructure → Observability, secrets management, compliance logs included
- Faster deployment → Pre-configured integrations with cloud services (S3, BigQuery, etc.)
- Enterprise governance → Built-in audit trails, access controls, RBAC
Weaknesses:
- Cloud vendor lock-in → AWS Bedrock Agents tie you to AWS infrastructure
- Limited customization → Orchestration logic constrained by platform capabilities
- Pricing opacity → Cloud platform pricing can spike unpredictably at scale
Cost profile:
- Initial build: $30K-$100K (2-4 engineers for 1-2 months)
- Ongoing costs: Platform fees ($5K-$50K/month depending on usage) + maintenance ($30K-$80K/year)
Real-world example:
- Palo Alto Networks with AWS Bedrock Agents (2026): Deployed security automation agents using Bedrock's managed infrastructure. Time to production: 6 weeks. Cost: $15K/month platform fees + $60K engineering. Alternative (vanilla code): 6 months + $200K.
⚠️ The Lock-In Tax
Managed platforms create multi-layer lock-in:
- Cloud infrastructure: AWS Bedrock = AWS-only deployment
- Orchestration patterns: Agent workflows tied to platform-specific APIs
- Data gravity: Once agents run in GCP, moving them to Azure = data migration nightmare
Cost to migrate away: $100K-$500K (refactoring agent logic, re-architecting data pipelines)
Strategic question: Are you comfortable committing to this cloud vendor for 3-5 years?
Tier 4: No-Code Agent Builders (Accessibility over Code)
What it is: Visual workflow builders where non-engineers can create agents via drag-and-drop interfaces. Examples: Lindy, Gumloop, Relevance AI, Zapier Central (agent mode).
Who uses it:
- Product managers building internal automation agents
- Operations teams deploying customer support bots
- Marketing teams creating lead qualification agents
Strengths:
- Fastest time to deployment → Hours to days (not weeks)
- No engineering required → Business users can build and iterate
- Template libraries → Pre-built agents for common use cases (customer support, data analysis)
Weaknesses:
- Limited complexity → Can't handle sophisticated multi-agent orchestration or custom reasoning
- Vendor platform lock-in → Workflows tied to Lindy/Gumloop/Zapier proprietary platform
- Hidden costs → "Free tier" limits explode at scale (10K+ agent runs/month)
Cost profile:
- Initial build: $0-$10K (mostly configuration, minimal engineering)
- Platform fees: $50-$5,000/month (scales with usage)
Real-world example:
- Atlassian (internal ops) with Lindy (2025): Built IT ticket triage agent in 48 hours using no-code builder. Handles 80% of L1 support tickets. Cost: $800/month platform fees. Alternative (Tier 2 framework): 2 months + $80K engineering.
Tier 5: Embedded-SaaS Agents (Maximum Convenience)
What it is: Pre-built agents embedded directly into SaaS products you already use. Examples: Salesforce Agentforce (sales/service agents), Microsoft 365 Copilot (productivity agents), ServiceNow Agentic AI (IT automation).
Who uses it:
- Enterprises already standardized on SaaS platforms (Salesforce, Microsoft, ServiceNow)
- Teams needing instant deployment without any build/config work
- Organizations prioritizing vendor support and SLAs over customization
Strengths:
- Zero implementation time → Agents are already in your CRM, ERP, or productivity suite
- Pre-configured for common workflows → Customer support, lead scoring, IT ticket resolution
- Vendor accountability → SLAs, support contracts, guaranteed uptime
Weaknesses:
- Deepest lock-in → Embedded agents tie you to the SaaS platform permanently
- Least customizable → Limited ability to modify agent reasoning or workflows
- Pricing bundled with SaaS → Agent costs often opaque (hidden in seat fees or usage tiers)
Cost profile:
- Initial build: $0 (agents included in SaaS subscription)
- SaaS platform fees: $30-$150/user/month (varies by vendor)
Real-world example:
- Salesforce Agentforce for customer service (2026): Embedded service agent resolves 84% of customer inquiries autonomously. No build time, no engineering. Cost: Included in Service Cloud subscription ($150/user/month). Alternative (Tier 2 framework): 4 months + $150K engineering.
The Build-to-Buy Decision Framework
How to choose the right tier:
| If your organization... | Start with Tier... | Why |
|---|---|---|
| Has 5+ senior AI engineers + unique agent architecture needs | Tier 1 (Vanilla) | Control matters more than speed |
| Needs custom multi-agent workflows but wants structure | Tier 2 (Frameworks) | Balance of flexibility + speed |
| Already standardized on AWS/Azure/GCP/Databricks | Tier 3 (Managed) | Leverage existing cloud infrastructure |
| Has non-technical teams building agents (ops, marketing, PM) | Tier 4 (No-Code) | Accessibility > customization |
| Wants agents embedded in existing SaaS (Salesforce, ServiceNow) | Tier 5 (Embedded) | Fastest path to production, no build required |
Most production systems use multiple tiers:
- Tier 2 frameworks for core differentiated agents (customer-facing product features)
- Tier 4 no-code for internal automation (ops workflows, lead scoring)
- Tier 5 embedded SaaS for common use cases already solved by vendors (IT ticketing)
The Lock-In Ladder: How Switching Costs Compound
Tier 1 to Tier 5 = increasing vendor lock-in.
Migration cost estimates (if you change your mind):
| From Tier... | To Different Vendor/Tier | Migration Cost | Time to Migrate |
|---|---|---|---|
| Tier 1 (Vanilla Code) | Any tier | $20K-$80K | 1-2 months |
| Tier 2 (Framework) | Different framework | $50K-$150K | 2-4 months |
| Tier 3 (Managed Platform) | Different cloud vendor | $100K-$300K | 3-6 months |
| Tier 4 (No-Code) | Different no-code platform | $30K-$100K | 1-3 months |
| Tier 5 (Embedded SaaS) | Different SaaS platform | $200K-$1M+ | 6-12 months |
Why Tier 5 migration is most expensive:
- Agent workflows are embedded in CRM/ERP data models
- Business processes have evolved around agent capabilities
- Training, integrations, and institutional knowledge are platform-specific
💡 The Orchestration Escape Hatch
Why some enterprises add an orchestration layer across all tiers:
Companies like JPMorgan, Goldman Sachs, and Morgan Stanley deploy agent orchestration platforms (Tier 3) that sit *above* individual agents—whether those agents are built in Tier 1, Tier 2, or purchased as Tier 5 SaaS.
The orchestration layer provides:
- Unified governance: Apply compliance rules across all agents (regardless of vendor)
- Vendor flexibility: Swap out individual agents without disrupting the broader system
- Shared context: Agents from different tiers share knowledge via the orchestration platform
Cost: $500K-$2M initial build + $200K-$800K/year maintenance. Worth it for enterprises deploying 50+ agents across departments.
What CTOs and VPs Engineering Should Do Now
Immediate Actions (Next 30 Days)
-
Audit your current AI agent deployments
- Which tier is each agent in?
- What's the total cost (build + platform fees + maintenance)?
- What lock-in risks exist?
-
Map planned agents to the spectrum
- For each new agent use case, run this decision tree:
- Unique competitive moat? → Tier 1 or Tier 2
- Common workflow (support, ops)? → Tier 4 or Tier 5
- Already on AWS/Azure/GCP? → Tier 3 (managed platform)
- For each new agent use case, run this decision tree:
-
Evaluate orchestration layer
- Do you have 10+ agents deployed or planned?
- Are they from different vendors/tiers?
- Would unified governance save compliance headaches?
- If yes, pilot an orchestration platform (e.g., Databricks AI Agent Builder, internal LangGraph layer)
Strategic Questions for Leadership
Before committing to a tier:
For VPs of Engineering:
- What's our default tier for new agents? (Most should have a "when in doubt" tier)
- Do we have the engineering talent to maintain Tier 1/Tier 2 agents long-term?
- How many vendors can we realistically manage across tiers?
For CTOs:
- What's our tolerance for vendor lock-in? (Some lock-in is inevitable—which tiers are acceptable?)
- Do we need an orchestration layer to coordinate cross-vendor agents?
- What's our 3-year agent deployment roadmap? (Planning for 50+ agents = different architecture than 5 agents)
For CFOs:
- What's the total cost of ownership across all tiers?
- Tier 1: High upfront, lower ongoing
- Tier 5: Low upfront, high ongoing (SaaS fees compound)
- What's the migration budget if a vendor/platform fails?
The Bottom Line
The build-versus-buy debate is incomplete. In 2026, enterprise AI agent deployment exists on a 5-tier spectrum from maximum control (vanilla code) to maximum convenience (embedded SaaS).
Most production systems use multiple tiers:
- Tier 1-2 for differentiated, competitive-moat agents
- Tier 3 for cloud-native infrastructure and governance
- Tier 4-5 for common workflows where speed > customization
Key takeaways:
- No single tier is "best" → The right tier depends on use case, engineering talent, and lock-in tolerance
- Lock-in compounds from Tier 1 → Tier 5 → Migration costs range from $20K (vanilla code) to $1M+ (embedded SaaS)
- Orchestration platforms → For 50+ agents, an orchestration layer (Tier 3) that sits above individual agents reduces vendor risk
Next step: Audit your current agents, map them to the spectrum, and decide which tier makes sense for each new deployment. The framework works best when you're intentional about trade-offs—not when you default to one tier for everything.
The spectrum isn't a ranking. It's a decision tool. Use it.
Continue Reading
Sources
- Metafore: Build vs. buy vs. orchestrate: the enterprise AI decision framework (April 14, 2026)
- Kai Waehner: Enterprise Agentic AI Landscape 2026: Trust, Flexibility, and Vendor Lock-in (April 6, 2026)
- Gumloop: 6 best AI agent frameworks (and how I picked one) in 2026 (March 2026)
- Lindy: Top 11 AI Agent Frameworks (2026): Expert-Tested & Reviewed (March 2026)
- Elementum AI: Best AI Orchestration Tools in 2026: Enterprise Guide (March 2026)
