The AI Builder Stack, Translated: LangChain, LangGraph, CrewAI, n8n

There's a proposal open on your screen. Somewhere in the second paragraph: a multi-agent CrewAI system on LangChain, orchestrated with LangGraph, MCP integrations, a vector database, and a Streamlit dashboard.

Seven names, and a number at the bottom. You're supposed to say yes or no to all of it.

I run nine AI agents that operate my company. A few of these tools are in that stack, and one got thrown out of it in July.

I translated six of the words in the buzzwords guide: agentic, RAG, context window, embeddings, MCP, hallucination. The seven names below are the software. Every one of them needs an owner after the install.

For each: what it is, who picks it, when it's overkill, and the question I'd put to whoever wrote the proposal.

The short answer. LangChain wires an AI app to models and data. LangGraph adds retries and approval pauses to a process. CrewAI runs several agents handing work down a line. n8n automates steps without code. MCP is one standard plug for the systems you own. Streamlit puts a screen on a script. A vector database searches by meaning.

Pick one tool per job. A proposal naming five of them is describing five jobs, and you can ask which of those five you have.

LangChain vs LangGraph vs CrewAI vs n8n: the cheatsheet

Tool	Translation	Built for	Overkill when	One question to ask a vendor
LangChain	A parts box for wiring an AI app to everything else	Apps juggling several models and data sources	One prompt, one model, one answer	What does this do that the model's SDK doesn't?
LangGraph	Your process as a map, with retries and approval pauses	Steps that need sign-off, or fail and retry	A script on a timer with no branches	Where does it pause, and where is that stored?
CrewAI	A described team of agents handing work down a line	Seeing a multi-agent demo run this week	The "team" is one job with three titles	Can I read the transcript between agents?
n8n / Zapier / Make	Drag boxes, draw arrows, connect apps without code	Ops people who will edit the flow themselves	One coder maintains it and nothing branches	Who opens this in six months? Name them.
MCP	One standard plug instead of custom integration per tool	Connecting an AI to systems you own	Your whole AI use is one chat tab	Which connections read, and which can write?
Streamlit / Gradio	A screen on a script: inputs, buttons, charts	Anything you need to see before trusting it	The output is one number a week	What stops a stranger opening the URL?
Vector database	Search by meaning instead of by keyword	Answers grounded in your own documents	You already run Postgres, at small volume	Why not pgvector on the database we have?

The designed one-page version of this is a separate job, the same as the buzzwords cheat sheet. Until it exists, copy the table above into wherever you keep notes.

1. LangChain

Translation: a parts box for wiring an AI app to everything around it: models, documents, tools, memory. Nobody writes each connection from scratch.

The older cousin is jQuery. Everybody pulled it into every page because browsers disagreed about everything, and it saved real work. Then browsers caught up, and a lot of projects were carrying a library to do what the platform did on its own.

Who it's for. Teams whose app has to talk to several model providers and several kinds of document store. They get the plumbing pre-written and a shared vocabulary, so a new engineer can read the code on day two.

Overkill when the job is one prompt to one model. That's a short script against the provider's SDK, and the framework becomes a dependency somebody maintains for years. My own agents call the SDK directly for exactly that reason.

Ask this. What does LangChain do here that the model's own SDK doesn't?

"It's what my team knows" is a fine answer. That's a staffing reason, so price it like one.

LangChain and LangGraph come from the same company, which is why the two names travel together on a proposal. You can run either without the other, so ask why both.

2. LangGraph

Translation: your process drawn as a map of steps, where the system remembers where it is, retries a step that failed, and can stop and wait for a person to say yes.

The older cousin is the approval queue in expense software. The request sits in somebody's list until they click approve, and nothing downstream moves until they do.

It's the orchestrator for my nine agents. The feature I care about is called interrupt(). It halts a run mid-workflow and waits for my ruling. I chose it on June 22 and wrote the reason into a dated decision file the same day.

Where the pause lives. Mine writes its state to Postgres, so a paused run survives my Mac restarting and picks up at the same step. Memory-only state does not survive a reboot.

Who it's for. Any process with a step you have to sign off on, or steps that fail and need retrying. Money moving. An email going to a customer. The system holds the step until you answer, so nothing depends on a person remembering to check.

Overkill when nothing branches and nobody signs anything. Then a script on a timer is the whole build.

Ask this. Where does it pause, and where is that pause stored?

"Human in the loop" covers two very different things: a real stop, and a notification the system sends on its way past you. Ask what happens if you don't answer for three days. If it continues, you don't have an approval gate.

3. CrewAI

Translation: you describe a small team: a researcher, a writer, an editor. Give each one a role and a goal, and they pass work down the line.

The older cousin is handing a brief to three contractors who only talk to each other. The brief is everything, and nobody reads the middle of the chain before it lands on your desk.

Who it's for. Somebody who wants to see a multi-agent system running on their own laptop this week. If a person on your team is trying to show you what "agents handing work to each other" looks like before you spend anything, this is the fastest route to it.

Overkill when the crew is one job wearing three titles. A researcher, a writer and an editor for one weekly post is three chances for the brief to drift, and one prompt with a checklist often lands closer.

Ask this. Can I read the transcript between the agents?

Multi-agent demos look impressive from the outside. The transcript is where you see whether agent two read agent one's output or restated the brief in different words.

4. n8n, Zapier and Make

Translation: a screen where you drag boxes and draw arrows between your apps: a trigger, a few steps, an AI box in the middle, instead of writing the script.

The older cousin is the mail rule that files messages into folders. Same idea with more boxes, and the same failure: it runs for months doing something slightly wrong and nobody opens it to look.

They come as a family:

• Zapier: hosted, the biggest connector library, nothing for you to run.
• Make: the same job on a more visual canvas.
• n8n: the one you can run on your own machine.

I ran n8n myself, self-hosted, in a container sitting next to my database, for about a month. On July 27 I shut it off and moved the same jobs onto launchd, the scheduler already built into macOS.

The reason: every workflow I needed was "run this script at 7:30 in the morning." Nothing branched and nobody approved anything. The visual editor was one more container to keep alive around a timer.

A visual tool pays when somebody who doesn't write code is going to open it and change something. Nobody but me was ever going to open mine.

Who it's for. Teams where the person who owns the process isn't the person who writes code. If your ops manager will edit the flow herself the week the discount rule changes, the boxes are the entire point.

Overkill when one developer maintains every flow and none of them branch. Then you're paying for a picture of a script.

Self-hosting also puts the API keys on your machine instead of a vendor's. The uptime is yours too.

Ask this. Who opens this in six months, and what will they change?

Write the name down. If the name is your developer's, the drawing was made for them, and you're buying a server to keep it alive.

5. MCP

Translation: one standard plug so an AI can reach your tools, instead of a custom build per tool. The buzzwords guide has the longer version, including how the permissions work.

The builder-side angle. MCP is the line item that should be shrinking. Connecting an agent to Notion or Gmail used to be an integration somebody wrote and then owned forever. Now the connector already exists and the agent picks it up.

One bridge connects my own agents to Notion, Gmail, Google Drive and Calendar, Postgres, and my code repositories, most of those connections read-only.

Overkill when your whole use of AI is one chat tab and copy-paste. There's nothing to connect.

Ask this. Which of these connections is an existing MCP server, and which are you building for me?

An existing server is a config file. Ask how many of the connections on your list are being custom-built, because that code needs somebody maintaining it long after the invoice clears.

Then ask which agent can write and which can only read. Get that answer in writing before anything touches your email.

6. Streamlit and Gradio

Translation: a way to put a screen on a script: a box to type in, a button, a chart, without building a website.

The older cousin is the Access database somebody in accounting built years ago. An internal tool, right up until the day the whole department depends on it and the person who made it has left.

How they split:

• Streamlit: the dashboard flavor. Charts, filters, tables, numbers you scan.
• Gradio: the demo flavor. An input box, an output box, a link you can send someone.
• LangServe: the sibling with no screen at all. It put the thing behind a URL for another program to call. LangChain deprecated it in late 2024 and points new builds at LangGraph Platform instead, so a proposal naming it now is worth a question on its own.

My World Cup prediction model ships a Streamlit dashboard, and I opened it before kickoff to read win, draw and loss percentages for a match. The model's public scorecard is at daisyguti.ai/wc26, and how it scored against the bookmakers is its own guide. Gradio and LangServe I've never used.

Who it's for. Any build where somebody needs to see the thing and click it before trusting it.

Ask for the screen early. If the only way to see it is your developer's terminal, you can't check it yourself.

Overkill when the output is one number a week. Email it.

Ask this. What stops a stranger from opening that URL?

These frameworks were made for internal tools, so the login is something you add on purpose.

7. Vector Databases

Translation: search by meaning instead of by keyword.

The mechanism is in the guide on making AI answer from your own documents: embeddings, pgvector, and why the column size has to match the model. Mine is an extension on the Postgres I already had. A separate vector database is another bill and another thing to back up. Ask why the proposal needs one.

What I'd Ask Before Signing That Proposal

Picture a shop that quotes custom work, invented here for the shape of it. Cabinets, signage, anything priced one job at a time. The proposal comes back: a multi-agent CrewAI system on LangChain with a vector database, to handle follow-ups.

Now count the work. A quote goes out. Two days later, if the customer hasn't replied, somebody sends a note. Twice a week, that's the volume.

Two questions shrink that proposal.

Which steps run on a clock, and which need judgment? Ask for the split in writing, step by step.

• Clock: two days pass, no reply, send the note.
• Judgment: this customer gets a different note because of how the last job went.

Everything on the clock side is a scheduler and a template. The judgment side is short, often one step, sometimes none. That short list is where an AI buys you anything at all.

What fails without saying so, and who finds out? That job fails in ordinary ways:

• The note that never sent.
• The note that sent twice.
• The note quoting last month's total.

So ask what the system does when it can't read your quote list. You want to hear that it stops and tells someone.

Mine didn't. My duplicate check read "I couldn't reach the queue" as a green light for two runs, and I deleted six copies by hand afterward.

One more habit, and it's free: ask for the decision in writing, dated, with the option that got rejected named.

I keep mine as files in the repo, eighty-odd of them now. A year later nobody remembers why a choice got made, and you need that reason the day you want to change it.

That split is roughly what my own system came down to. Jobs on a timer, plus a small number of places where the work stops and waits for me.

When the Answer Is None of Them

A tool from this page starts paying for itself when one of these is true:

• The job repeats on a clock and everybody forgets it. You need a scheduler.
• A person has to approve something in the middle. That's the LangGraph pause.
• You need an agent to reach a system you own. That's MCP.
• Somebody who doesn't code has to see it or change it. That's n8n, or a Streamlit screen.

If none of those is true, the answer is a chat window and a checklist.

Open Claude or ChatGPT. Paste the thing in. Keep the checklist in a document you'll find again, so you ask the same questions every time and the answers stay comparable week to week. That handles more small-business AI work than any of the seven names above.

Run it that way for a month before you buy anything. A month by hand shows you where the repetition is, and that list becomes the specification for the build.

Quick Recap

• LangChain is a parts box for LLM apps. Ask what it does that the model's own SDK doesn't.
• LangGraph holds a workflow's place, retries steps, and pauses for approval. It orchestrates my nine agents. Ask where the pause is stored.
• CrewAI is the fastest way to watch agents hand work to each other. Ask to read the transcript.
• n8n, Zapier and Make draw the automation as boxes. I shut mine off on July 27 for the scheduler already in macOS. Ask who opens it in six months.
• MCP is one plug instead of an integration per tool. Ask which connections can write and which only read.
• Streamlit and Gradio put a clickable screen on a script. Ask what stops a stranger from opening the URL.
• Vector databases search by meaning. If you already run Postgres, pgvector is an extension rather than a new bill.
• None of them beats a chat window and a checklist until the same job comes back every week.

Start Here

You can name every tool on that proposal and still not know which part of your business to hand off first.

At daisyguti.ai/work-with-me there's a short intake: about nine questions, a few minutes. Daisy reads every submission herself, assesses whether a build like this is a fit for your business, and replies with what to hand off first.

Sources

1. LangChain, official site - https://www.langchain.com
2. LangGraph, official documentation - https://langchain-ai.github.io/langgraph/
3. CrewAI, official site - https://www.crewai.com
4. n8n, official site - https://n8n.io
5. Model Context Protocol, official documentation - https://modelcontextprotocol.io
6. Streamlit, official site - https://streamlit.io
7. Gradio, official site - https://www.gradio.app
8. pgvector, open-source vector search for Postgres - https://github.com/pgvector/pgvector

Next week in this series: How My AI Office Is Built, a nine-agent system.