Build, Buy, or Integrate? A Developer's Honest Guide to AI Agents

Building an AI agent from scratch with LangChain costs $75K–$150K and takes 3–6 months. Buying a black-box solution like Intercom Fin costs $0.99 per resolution with limited customization. The third option — integrating a developer agent platform via API — gives you full control, your own knowledge base, and predictable pricing, deployable in days. Here's how to decide.

TL;DR: Building from scratch costs $237K–$486K/year. Buying a black box (Intercom Fin) costs $30K–$50K/year at 5K conversations. Integrating via a developer platform costs $5K–$6K/year with full control. Most product teams land on option three.

The Three Options (Not Two)

Most "build vs buy" articles present a false binary. In reality, there's a spectrum — and the middle is where most product teams land.

Build means you own every layer — model selection, orchestration, RAG pipeline, guardrails, hosting. Maximum control, maximum cost.

Buy means you plug into a vendor's widget. Minimal effort, but you're constrained to their UI, their pricing model, and their feature roadmap.

Integrate means you call an agent API from your own code. You control the user experience, pass your own data, and choose your model — but infrastructure is managed for you. (For a deeper comparison of platforms in each category, see our comparison of 9 AI agent platforms.)

When to Build from Scratch

Building your own agent infrastructure makes sense when AI is the product, not a feature. Here's the decision framework:

Build if:

• AI is core to your product's value proposition — your users are paying for the AI itself, not for a SaaS product that happens to have AI features
• You need custom model training or fine-tuning — off-the-shelf models don't cover your domain (medical, legal, proprietary data)
• You have dedicated AI/ML engineers — people who understand embeddings, eval pipelines, and prompt engineering at a deep level, not backend devs learning on the job
• You're willing to own infrastructure long-term — model updates, prompt regression testing, knowledge sync, vector DB ops, monitoring, and security

Key insight: The question isn't "can we build it?" — most engineering teams can. The question is "should our AI engineers spend 6 months on agent infrastructure instead of the features that differentiate our product?"

The real cost isn't the initial build. It's the ongoing maintenance. Model providers ship breaking changes. Your knowledge base drifts. Prompts that worked in March fail in June. Budget 1–2 FTE permanently for an in-house agent system. (We broke down the 12 infrastructure layers behind a single agent — it's more than most teams expect.)

When to Buy a Black-Box Solution

Let's be fair: platforms like Intercom Fin and Zendesk AI are genuinely good at what they do.

What they get right:

• Intercom Fin resolves 40–60% of conversations out of the box, depending on knowledge base quality — that's real, not marketing
• Anthropic themselves use Fin for their support. If the company behind Claude trusts it, the product works
• Setup is genuinely effortless — connect your help center and you're live in hours
• The end-user experience is polished, tested across millions of conversations

Buy if:

• You need AI support live tomorrow, not next quarter
• Your team is non-technical — no engineers available for API integration
• It's a standard support use case with no need for product embedding
• Your volume is low enough that per-resolution pricing makes sense

Where it breaks down:

Tip: If your support volume is under 500 conversations/month and you don't need API integration, Intercom Fin is probably the right choice. This post is for teams that need more.

When to Use a Developer Platform

This is the sweet spot for teams that write code but aren't building an AI company. You integrate via SDK — the same way you'd add Stripe for payments or Twilio for SMS.

Integrate if:

• You're adding AI as a feature to an existing product, not building an AI-first company
• Your team has engineers who write code but aren't AI/ML specialists
• You need runtime context injection — personalized responses based on the user's plan, order history, and account state
• You want predictable pricing you can model in a spreadsheet
• You need to ship in days and iterate for months

The workflow: create an agent, upload your knowledge base, define your context shape, call the API from your existing backend. Your auth, rate limiting, and database stay untouched. (For a deeper look at how this integration works, see our architecture guide.)

What makes it work: Context injection and structured data access are the differentiators. Instead of a generic chatbot that searches your docs, the agent knows this user is on the Pro plan, this user's last order was $49.99, and this user is eligible for a refund. The response is specific, not generic.

Total Cost of Ownership

Here's a realistic 12-month comparison for a SaaS handling 5,000 support conversations per month:

*Assumes ~50% resolution rate on 5K conversations = ~2,500 billed resolutions/month.

Key insight: The DIY option isn't expensive because of tokens — it's expensive because of engineers. The black-box option isn't expensive at low volume — it gets expensive as you scale. The developer platform stays flat because you pay for tokens, not resolutions.

At 500 conversations/month, Intercom Fin costs roughly $330/month — reasonable. At 25,000, it's $16,500/month. Developer platform pricing at the same scale: ~$2,000/month. The gap widens with volume. (For the full math on support cost savings, see our cost reduction guide.)

The Code Comparison

What does each approach actually look like in code? Here's a realistic minimum for each — not worst-case LangChain vs best-case SDK, but honest minimum viable setup for a support agent with RAG, context, and guardrails.

LangChain (Python) — minimum viable agent:

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 1. Load and index documents
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
docs = splitter.create_documents([open("help-docs.md").read()])
vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings())
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 2. Build the chain with context
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
prompt = ChatPromptTemplate.from_template(
    "You are a support agent. Use the context to answer.\n\n"
    "User context: {user_context}\n"
    "Relevant docs: {docs}\n"
    "Question: {question}"
)

# 3. Run with retrieval
def ask(question: str, user_context: dict) -> str:
    retrieved = retriever.invoke(question)
    doc_text = "\n".join(d.page_content for d in retrieved)
    chain = prompt | llm | StrOutputParser()
    return chain.invoke({
        "question": question,
        "user_context": str(user_context),
        "docs": doc_text,
    })

# 4. Call it
response = ask(
    "Can I get a refund?",
    {"user": "Alex", "plan": "pro", "last_order": "ORD-7823"}
)

That's the minimum — and it doesn't include document ingestion, guardrails, streaming, error handling, tool calling, or deployment infrastructure.

AgentBackend SDK (Python):

from agentbackend import AgentBackend

ab = AgentBackend("ak_YOUR_API_KEY")
response = ab.agent("support").run(
    "Can I get a refund?",
    context={
        "user_name": "Alex",
        "plan": "pro",
        "last_order": {"id": "ORD-7823", "amount": 49.99}
    }
)

AgentBackend SDK (JavaScript):

import { AgentBackend } from "agentbackend";

const ab = new AgentBackend({ apiKey: "ak_YOUR_API_KEY" });
const response = await ab.agent("support").run("Can I get a refund?", {
  context: {
    userName: "Alex",
    plan: "pro",
    lastOrder: { id: "ORD-7823", amount: 49.99 },
  },
});

Tip: The AgentBackend code isn't shorter because it does less. It's shorter because infrastructure — vector store, retrieval, guardrails, streaming — is managed for you. The LangChain example still needs hosting, monitoring, and ongoing maintenance on top of the code above.

See the full SDK reference →

Frequently Asked Questions

Can I migrate from LangChain to a managed platform?

Yes. Your knowledge base (documents, FAQs) transfers directly — upload the same files. Custom tool definitions map to the platform's tool config. The main work is replacing the orchestration layer. Your business logic and backend integration stay the same.

What about vendor lock-in?

AgentBackend lets you export your knowledge base, conversation history, and agent configs. Your data stays yours. The SDK integration is 10–15 lines of code — switching platforms means changing one service call, not rewriting your application.

Compare platforms →

Is the "integrate" option just a compromised version of both?

No — it's a different trade-off. You get API-level control (like building) with managed infrastructure (like buying). The compromise is you don't own the orchestration layer. For most teams adding AI to an existing product, that's the right trade-off — the same way most teams use Stripe instead of building their own payment processor.

How do I evaluate if my team should build or buy?

Ask three questions: (1) Is AI your core product or a feature of your product? (2) Do you have dedicated AI/ML engineers? (3) Are you willing to maintain agent infrastructure for 3+ years? If all three are yes, build. If any is no, consider a platform.

How much does it cost to run an AI agent per month?

It depends on volume and approach. At 5,000 conversations/month: DIY costs $2K–$4K/month (infra + partial FTE), Intercom Fin costs $3K–$5K (per-resolution), and a developer platform costs $400–$500 (platform fee + tokens). See the TCO table above for the full 12-month breakdown.

View pricing →

Can I start with a platform and migrate to custom later?

Yes, and many teams do. Start with a developer platform to validate that AI adds value for your users. Once you've proven ROI and have the engineering resources, you can migrate to a fully custom setup — your knowledge base, conversation data, and tool definitions all transfer. This is lower risk than spending 6 months building before you know if users want it.

Start Building

See the difference in 5 minutes. Create an agent, upload your docs, and make your first API call — $3 free credit, no credit card required.

Get started free →