Contents
- Fast answer
- Quick facts
- What this covers
- Why it matters
- Where to go next
- Outcomes
- Step by step
- The methodology: the exact rules behind the recommendation
- How to read the recommendation and when to override it
- A worked example: a property management maintenance workflow
- The limits: what the stack picker does not consider
- How to read the stack recommendation
- The code frameworks, compared honestly
- Stack viability and the lock-in question in 2026
- What changed in 2025 and 2026
- At a glance
- Mistakes to avoid
- FAQ
Fast answer
An AI agent stack picker helps choose between no-code tools, OpenAI AgentKit, Agents SDK, LangGraph, CrewAI, MCP, and custom builds based on workflow complexity and ownership. The wrong stack makes a simple workflow expensive or a complex workflow fragile, so stack choice should follow the process, not platform hype. Start by defining the workflow, clarifying trigger, inputs, actions, review steps, integrations, and the maintenance owner. Choose no-code or code by using no-code for fast pilots and custom code for security, scale, persistence, evaluations, or complex permissions. Check approval needs, since workflows with risky actions may require human-in-the-loop systems such as LangGraph or carefully designed approval flows. Then pick the tutorial path, routing to n8n, AgentKit, LangGraph, or MCP content based on the result. There is no universal best stack, because the right choice depends on workflow complexity, data sensitivity, approvals, and team skill. Use custom code when no-code cannot handle permissions, scale, evaluations, custom logic, or production reliability, and avoid tools nobody will maintain.
Facts last verified 2026-07
Quick facts
- LangChain scale
- $125M Series B at $1.25B valuation; ~90M monthly downloads; 35% of Fortune 500 (Oct 2025)
- LangGraph 1.0
- GA October 2025; durable state and human-in-the-loop APIs; used by Uber, LinkedIn, Klarna
- OpenAI agent stack
- Agents SDK March 2025; AgentKit visual builder October 2025
- CrewAI
- $18M raised; 55,000+ GitHub stars; multi-agent crews
- n8n
- ~196,000 GitHub stars; $2.5B valuation; per-execution pricing
- MCP ecosystem
- 10,000+ public servers; governed by the Linux Foundation since Dec 2025
On this page
What this page covers
A tool visitor should leave with a decision, not just a number: build now, prepare first, choose another workflow, or follow a course path.
- 01Workflow needs
- 02No-code vs code
- 03Approvals
- 04Integrations
- 05Recommendation
- 06Next course
Why does this matter now?
The wrong stack makes a simple workflow expensive or a complex workflow fragile. Stack choice should follow the process, not platform hype.
Internal path
Where to go next from this page
These links are part of the A8gent learning and conversion path. Use them to move from concept, to diagnosis, to workflow build, to course.
What you should be able to do after this
- Compare stack options
- Match tools to workflow
- Avoid overbuilding
- Choose a tutorial path
How do you do it, step by step?
1. Define the workflow
Clarify trigger, inputs, actions, review steps, integrations, and maintenance owner.
2. Choose no-code or code
Use no-code for fast pilots and custom code for security, scale, persistence, evals, or complex permissions.
3. Check approval needs
Workflows with risky actions may need human-in-the-loop systems such as LangGraph or carefully designed approval flows.
4. Pick the tutorial path
Route to n8n, AgentKit, LangGraph, or MCP content based on the stack result.
The methodology: the exact rules behind the recommendation
This is a rule set, not a score, and there are only three inputs: whether you are building with code or without it, whether the workflow requires human approval, and whether complexity is low, medium or high. Four rules run in order. If you chose no-code and complexity is not high, it returns Autonoly, n8n or Make. If you chose code and human approval is required, it returns LangGraph. If you chose code and complexity is high, it returns the OpenAI Agents SDK or LangGraph. Everything else returns OpenAI AgentKit.
The logic behind each rule is worth stating, because a recommendation you cannot argue with is a recommendation you cannot trust. No-code plus low or medium complexity goes to a visual builder because that is precisely the workload those platforms are designed for, and because the person who will maintain the workflow is usually the person who built it. The moment complexity goes high, the visual canvas stops being an advantage and starts being a constraint.
Code plus a hard approval requirement routes to a graph framework because approval is a state problem. A workflow that pauses, waits for a human, and resumes with that decision folded into its context needs durable state and explicit control flow, which is what a graph gives you and what a linear chain does not. Code plus high complexity routes the same way for the same reason, with the provider SDK offered as the alternative when you are already committed to one model provider.
The residual case, which returns AgentKit, covers the combinations that are neither simple enough for a visual builder nor demanding enough to justify a graph framework. That is a genuine middle ground and it is where a provider-native agent toolkit with built-in guardrails, tracing and evaluation does well. It is also the recommendation you should question hardest, because it is what the rules return when nothing else fired.
How to read the recommendation and when to override it
Override the pick when the person maintaining the workflow is not the person building it. The single strongest predictor of whether an agent workflow survives its first year is whether the owner can change it without filing a ticket. If your operations lead will own it, a no-code recommendation is right even when the complexity answer says otherwise, because a workflow nobody can edit is a workflow that quietly stops matching the process.
Override it in the other direction when the workflow touches money, customer records, or anything irreversible. Those need durable state, explicit approval steps, and tracing and logging good enough to reconstruct what happened three weeks later. Some visual builders provide that; many do not provide enough of it. If the tool returns a no-code answer for a workflow with real blast radius, treat the recommendation as being about the build and separately satisfy yourself about the controls.
The other honest override is volume. All of these recommendations are shape-based, and none of them look at how many times a day the workflow runs. Pricing units diverge sharply at scale: n8n charges per workflow execution regardless of node count, Make.com charges credits at roughly one per module action, and Zapier charges tasks per successful action step with triggers, polling, failed actions and built-in Formatter, Paths and Filter steps excluded. A workflow that is cheap on one unit can be expensive on another.
If two of the four answers feel like coin flips, that is a signal in itself. It usually means the workflow is not scoped tightly enough to have a shape yet, and the productive next step is to map it step by step before choosing anything. Picking a platform for an unmapped workflow is how teams end up with a half-built system on a tool that was never the constraint.
A worked example: a property management maintenance workflow
A property management company wants an agent that reads inbound maintenance requests, classifies urgency, checks whether the issue is a landlord or tenant responsibility, drafts the contractor instruction, and holds anything above a spend threshold for approval. Answer the picker honestly: no-code, human approval required, complexity medium. The first rule fires and returns a visual builder.
That is the right answer for this build, and the reason is the approval step rather than the classification. Spend approval is a routine pause-and-resume pattern that mainstream automation platforms handle natively, so nothing here demands a graph framework. The classification is a single model call against a short taxonomy. The responsibility check is a lookup. None of that is architecturally interesting, which is exactly why it should be built on the cheapest thing that maintains well.
Now change one answer. If the workflow also had to negotiate scheduling with a contractor over several messages, hold context across days, and back out cleanly when the tenant cancels, complexity moves to high and the recommendation changes. That is a genuinely different build with durable state at its centre, and attempting it on a visual canvas produces a workflow that works in the demo and fails on the third edge case.
The lesson generalises. The complexity answer should describe the hardest single step in the workflow, not the average across all of them. One genuinely stateful step in an otherwise simple sequence is enough to change what you should build on, and teams consistently under-answer this because they are thinking about the happy path.
The limits: what the stack picker does not consider
It does not look at your existing systems, and that is the biggest omission. The presence or absence of a working connector to the system your business actually runs on decides more builds than any architectural preference. A perfect framework with no path into your scheduling system loses to a mediocre platform that has shipped that connector for five years. Check connector coverage against your real stack before acting on any recommendation here.
It does not price anything. There is no cost input, no volume input, and no comparison of the pricing units that diverge so sharply between platforms. It also does not consider your data residency or hosting constraints, which for regulated work can eliminate an entire category of answer before the shape of the workflow is even relevant.
It does not assess vendor viability, and the agent tooling market is young enough that this matters. Being locked in to a framework that is abandoned is a real cost, and a young project with a small maintainer base is a different risk from an established platform with a decade of history. The tool has no view on any of this.
Finally, the recommendation names categories more than products. Autonoly, n8n and Make.com are not interchangeable, and neither are LangGraph and a provider SDK. Read the output as the class of tool that fits the shape of your workflow, then choose inside that class on connectors, hosting, pricing unit, and who will maintain it.
How to read the stack recommendation
The picker routes on a small number of workflow properties because those properties, not preferences, determine where a stack breaks. Workflows that are linear, low-volume, and reviewable run happily on Zapier or Make.com. Multi-step workflows at volume favor n8n, whose per-execution pricing and self-hosting option reward complexity. Code frameworks earn their overhead only when the workflow needs things no-code cannot express: per-user permissions, durable state across days, systematic evaluation of outputs, or approval logic more intricate than a hold-and-approve step.
The boundary between no-code and code moved during 2025, so recheck old instincts. Approval steps, agent nodes, and logging are now ordinary features in n8n, Make.com, and Zapier, which means human-in-the-loop alone no longer forces you into code. What still does: state that must survive restarts and span days, evaluation harnesses that score outputs against rubrics automatically, and fine-grained permissioning. If your workflow has none of those, a code recommendation deserves skepticism; if it has two or more, a no-code recommendation is deferring a rewrite.
Treat the maintenance question as a veto, not a tiebreaker. A LangGraph build is a small software product that needs a developer on call for dependency updates, API changes, and prompt drift; an n8n instance needs an operator; a Zapier workflow needs an owner with an hour a week. The best stack your team cannot maintain is worse than the second-best stack it can, and most stack regret traces to ignoring exactly this question during selection.
The code frameworks, compared honestly
LangGraph is the default recommendation for approval-heavy, stateful agent workflows, and its 1.0 release in October 2025 consolidated that position: durable execution, built-in persistence, and human-in-the-loop pause and approve as first-class APIs rather than patterns you hand-roll. It runs in production at companies including Uber, LinkedIn, and Klarna, and its repository sits around 37,000 GitHub stars. The cost is conceptual: you model your workflow as a graph, which is powerful for complex control flow and overkill for a linear draft-and-review pipeline.
OpenAI's stack trades generality for velocity. The Agents SDK, released in March 2025 as the production successor to its experimental Swarm project, gives you agents, handoffs, and guardrails in a lightweight package, and AgentKit, launched that October, adds a visual Agent Builder, embeddable ChatKit UI, evaluation tooling, and a connector registry. If your models, evals, and hosting are already OpenAI, it is the shortest path to a working agent. The tradeoff is gravitational pull toward one vendor for models, tooling, and deployment at once.
CrewAI occupies the multi-agent niche: crews of role-specialized agents collaborating on a task. It raised 18 million dollars in October 2024 with backing from Insight Partners and angels including Andrew Ng, reported over 10 million agent executions per month that year, and its repository has grown past 55,000 stars. It is the fastest way to prototype multi-agent patterns, with the caveat that most business workflows fail the do-I-need-multiple-agents test, and a single well-scoped agent with good tools outperforms a committee of them on reliability per dollar.
Stack viability and the lock-in question in 2026
Framework longevity stopped being a coin flip. LangChain raised a 125 million dollar Series B at a 1.25 billion dollar valuation in October 2025, reporting roughly 90 million combined monthly downloads and usage in 35 percent of the Fortune 500. n8n raised 180 million dollars at a 2.5 billion dollar valuation the same month, with its repository approaching 200,000 GitHub stars. Picking among the major options in 2026 no longer carries the abandonment risk that haunted 2023-era agent frameworks, most of which are already gone.
The Model Context Protocol changed what lock-in even means. With MCP under the Linux Foundation's Agentic AI Foundation since December 2025, more than 10,000 public MCP servers available, and support across Anthropic, OpenAI, Google, and the workflow platforms, your tool integrations can outlive your framework choice. A CRM or database exposed once as an MCP server is reachable from LangGraph, the OpenAI stack, n8n, and whatever you migrate to in 2028. Build integrations to the protocol, and the framework decision becomes reversible.
The residual lock-in lives in orchestration logic and evaluation data, so weight those in the decision. Graph definitions, prompt libraries, and eval suites port poorly between frameworks, which argues for two habits regardless of pick: keep prompts and test cases in your own repository rather than a vendor console, and document workflows at the specification level, trigger, inputs, approvals, outputs, so a rebuild is a translation rather than an archaeology project. Teams that do both treat stack choice as a two-year decision, not a marriage.
What changed in 2025 and 2026
The stack conversation matured from experimentation to consolidation. LangGraph and LangChain hit 1.0 in October 2025, OpenAI shipped its Agents SDK in March and AgentKit in October, and the flood of 2023-vintage frameworks thinned to a short list with real funding, real production users, and stable APIs. For a stack picker, that changes the failure mode: the risk in 2024 was betting on a framework that died; the risk in 2026 is over-engineering with a framework whose power your workflow does not need.
Protocols did the quiet work. MCP's donation to the Linux Foundation in December 2025, alongside Google's Agent2Agent protocol with more than 150 supporting organizations, means the integration layer standardized underneath the frameworks. In practice this favors mixed stacks: teams increasingly run n8n for the bulk of reviewable workflows and reserve a code framework for the two or three workflows that genuinely need custom state or evaluation, with both sides sharing MCP-based tool access.
The survivorship data kept the stakes visible. Gartner's prediction that over 40 percent of agentic AI projects will be canceled by end of 2027 was about projects, not frameworks, and the causes it cites, cost, unclear value, weak risk controls, are stack-independent. The picker's routing logic reflects that: it sends you to the simplest stack your workflow's real requirements allow, because unused capability is pure carrying cost, and every failed project autopsy includes a stack that was more interesting than the workflow deserved.
At a glance
AI agent stack options at a glance (verified July 2026)
| Stack | Type | Signals | Best for |
|---|---|---|---|
| Zapier / Make.com | No-code | Largest app catalogs; agent features on all plans | Linear, low-volume, reviewable workflows |
| n8n | Low-code | ~196k GitHub stars; $2.5B valuation; self-hostable | Multi-step workflows at volume; data residency |
| LangGraph | Code framework | 1.0 GA Oct 2025; Uber, LinkedIn, Klarna in production | Stateful, approval-heavy custom agents |
| OpenAI Agents SDK + AgentKit | Code plus visual | SDK Mar 2025; AgentKit Oct 2025 | OpenAI-centric stacks, fastest first agent |
| CrewAI | Code framework | 55k+ GitHub stars; $18M raised | Multi-agent role-based prototypes |
| MCP | Protocol | 10,000+ servers; Linux Foundation governance | Portable tool integrations across any stack |
What mistakes should you avoid?
- Choosing based on trendiness
- Ignoring who will maintain it
- Skipping approval and logging needs
FAQ
- How does the stack picker decide?
- Four rules run in order over three inputs. No-code with low or medium complexity returns a visual builder such as Autonoly, n8n or Make. Code with a human approval requirement returns LangGraph. Code with high complexity returns the OpenAI Agents SDK or LangGraph. Anything else returns OpenAI AgentKit. It is a rule set rather than a score, so the output changes discretely rather than gradually as you adjust the inputs.
- When should I ignore the recommendation?
- Override toward no-code when the person maintaining the workflow is not the person building it, because a workflow nobody can edit stops matching the process within months. Override toward a code framework when the workflow touches money, customer records or anything irreversible, since those need durable state, explicit approval steps and tracing good enough to reconstruct what happened weeks later. Also override on volume, which the picker does not consider at all.
- Does the picker account for cost?
- No. There is no cost or volume input, which matters because pricing units diverge sharply between platforms. n8n charges per workflow execution regardless of how many nodes it contains. Make.com charges credits at roughly one per module action. Zapier charges tasks, one per successful action step, with triggers, polling, failed actions and built-in Formatter, Paths and Filter steps excluded. Model your real monthly volume through each unit separately.
- What complexity level should I choose?
- Describe the hardest single step in the workflow, not the average across all of them. One genuinely stateful step, such as a negotiation that holds context across days and must back out cleanly when cancelled, is enough to change what you should build on. Teams consistently under-answer this because they are picturing the happy path, and the result is a workflow that demonstrates beautifully and fails on the third edge case.
- What is the best AI agent stack?
- There is no universal best. The right stack depends on workflow complexity, data sensitivity, approvals, and team skill.
- When should I use custom code?
- Use custom code when no-code tools cannot handle permissions, scale, evaluations, custom logic, or production reliability.
Sources & further reading
Was this page helpful?
