Setiap beberapa bulan ada je tool baru yang trending dan teams mula tanya: "Should we switch to this?" Comparison articles yang dorang jumpa online usually ditulis oleh orang yang tak pernah build production systems dengan mana-mana pun dari tiga tools ni. Dorang compare feature checklists, GitHub star counts, dan pricing tiers.
That's the wrong frame. n8n, Kestra, dan LangGraph bukan competing untuk kerja yang sama. Soalan dia bukan mana satu lebih bagus — tapi mana satu sesuai untuk masalah yang korang tengah solve.
Kami dah build dengan ketiga-tiga. Ini honest version dia.
What it is
n8n is a node-based visual workflow automation platform — think Zapier or Make, but self-hostable and with actual developer ergonomics. You connect triggers to actions using a drag-and-drop canvas. It ships with 400+ integrations out of the box: Gmail, Slack, MySQL, HubSpot, WhatsApp Business API, and most things you'd encounter in a Malaysian SME stack.
Introduced AI nodes in 2023 and has been aggressively adding LLM capabilities since. You can wire an LLM call into a workflow without writing Python. For simple AI-assisted automation — classify an incoming email, summarise a document, route a support ticket — n8n does it with minimal friction.
What it does well
- Fastest path from idea to working automation for linear workflows
- Non-developers can read, modify, and debug visually
- Self-host on a single VPS — no cloud vendor lock-in
- 400+ pre-built integrations cover most SME tooling
- Active community, solid documentation
- Webhook triggers, cron schedules, and event-based flows all natively supported
- Stateless between workflow runs — no native persistent memory across executions
- Not designed for complex branching agent logic; workarounds get messy fast
- Visual canvas becomes hard to manage past ~30 nodes
- Fair-code licence: free to self-host, but commercial embedding requires paid licence
- Error handling for multi-step failures requires manual configuration
- Not suitable for high-throughput data pipelines (>10k events/min)
Ops managers dan founders yang nak automation sekarang tanpa full engineering team. Dev teams kecil-sederhana yang nak gerak cepat on integration work. Mana-mana use case di mana workflow dia linear, triggers dia clear, dan state tak perlu persist between runs.
What it is
Kestra is a data pipeline and workflow orchestration platform in the Apache Airflow tradition — but with a cleaner YAML-first definition model, a proper UI, and significantly easier self-hosting. Flows are defined declaratively in YAML and executed by Kestra's engine. It handles scheduling, retries, dependencies between tasks, and has first-class support for running Python, R, Node.js, and shell scripts as workflow steps.
Where Airflow requires Python DAGs and a fairly heavy setup, Kestra is more accessible to teams that want infrastructure-grade orchestration without deep Python expertise. It's gained real traction as a modern alternative in data engineering stacks.
What it does well
- First-class retry logic, failure handling, and SLA alerts
- Excellent observability — full execution logs, timeline view, dependency graph
- Scales well for high-volume scheduled pipelines
- YAML definitions are version-controllable and reviewable in PRs
- Namespace-based multi-tenancy for managing multiple environments
- Apache 2.0 licence — genuinely open source, no fair-code restrictions
- Engineer-first — non-technical users won't self-serve on this
- YAML flows are powerful but verbose; complex logic gets unwieldy
- Not designed for real-time or event-driven AI agent patterns
- LLM integration is possible but you're bolting it on, not using a native pattern
- Smaller ecosystem than Airflow; some integrations need custom scripting
- Heavier infra footprint than n8n for equivalent simple automation
Data dan engineering teams yang run scheduled ETL pipelines, report generation, data sync jobs, atau batch processing workflows. Teams yang migrate off Airflow dan nak sesuatu yang lebih maintainable. Companies yang data pipeline reliability dan observability dia adalah non-negotiable — tak boleh ada downtime, tak boleh ada silent failures.
What it is
LangGraph is a Python library from LangChain for building stateful, multi-actor AI agent applications as directed graphs. You define nodes (functions that process state) and edges (conditions that route between nodes), and LangGraph handles execution, state persistence, streaming, and interrupts for human-in-the-loop checkpoints.
It's not a visual tool. It's not a no-code platform. It's a library you import into a Python application. That distinction matters — it means full control over execution logic at the cost of requiring a Python developer to build and maintain it.
As of LangGraph >=0.2, the framework has stabilised significantly. The graph compilation model, checkpoint backends (supporting both in-memory and PostgreSQL-backed persistence), and streaming interface are production-ready. This is what we use for IRIS.
What it does well
- Native persistent state across agent runs — the only tool here that does this properly
- First-class support for supervisor-specialist multi-agent patterns
- Human-in-the-loop interrupts are a core primitive, not a workaround
- Streaming support for real-time output from long-running agent tasks
- Full Python — use any library, any model, any tool call pattern
- MIT licence, actively developed, strong production adoption
- Requires a Python developer — no visual canvas, no drag-and-drop
- Debugging complex graph execution requires understanding the framework internals
- Not appropriate for simple linear automation — massive overkill
- LangChain ecosystem still evolves fast; API surface has changed significantly between versions
- Infra overhead: needs a backend for persistent checkpoints (PostgreSQL recommended)
- No built-in scheduler — needs external trigger mechanism for cron-style runs
Engineering teams yang build production AI agent systems di mana state persistence, multi-step reasoning, dan complex branching logic adalah keperluan. Mana-mana use case dalam supervisor-specialist pattern yang kami describe dalam artikel 1.2. Tak sesuai untuk non-developer teams atau simple trigger-action automation — overkill habis kalau pakai untuk benda tu.
Head-to-head: the dimensions that actually matter
| Dimension | n8n | Kestra | LangGraph |
|---|---|---|---|
| Primary job | App integration & linear automation | Data pipeline orchestration | Stateful AI agent execution |
| State persistence across runs | ✗ Stateless by default | Partial (job metadata only) | ✓ Native, configurable backends |
| Multi-agent patterns | Workaround-level | Not designed for this | ✓ First-class primitive |
| Human-in-the-loop | Webhook pause (manual) | Not native | ✓ Built-in interrupt/resume |
| Non-developer accessible | ✓ Visual canvas | YAML (developer-lite) | ✗ Python only |
| Integration library | ✓ 400+ native nodes | Good, engineer-maintained | Custom tool calls (you write it) |
| Pipeline reliability / observability | Basic | ✓ Production-grade | Framework-level logging |
| High-volume scheduled pipelines | Not recommended | ✓ Purpose-built | Not its job |
| Self-host complexity | Low — single container | Medium — needs backend services | Medium — Python app + DB |
| Licence | Fair-code (restrictions apply) | Apache 2.0 | MIT |
| Rough cost to self-host | ~RM80–150/mo VPS | ~RM150–300/mo (more infra) | Embedded in your app stack |
So which one for business korang?
Jawab dalam order ni. Stop bila korang dah jumpa answer korang.
The combination case is real. For a client running a manufacturing intelligence platform, kami guna Kestra to orchestrate the nightly data ingestion and quality scoring pipelines — scheduled, reliable, with full retry logic. LangGraph powers the AI agent layer that monitors the scored data and triggers procurement or maintenance workflows when thresholds are breached. Different tools, different jobs, same system. They don't conflict; they complement.
What we use and why
Untuk IRIS dan semua production AI agent work: LangGraph. Takde tool lain dalam comparison ni yang handle persistent state, supervisor-specialist routing, dan human-in-the-loop interrupts as first-class primitives. Masa kami evaluate alternatives, gap dia tak close langsung. Semua benda lain perlukan workarounds yang akan jadi maintenance debt.
Untuk client integration automation: n8n. Kalau client nak connect CRM dia ke accounting system, automate invoice generation, atau hantar WhatsApp notifications based on form submissions — n8n adalah tool yang betul. Cepat nak deploy, ops team client boleh maintain simple flows tanpa kami, dan kosong je nak self-host atas VPS dorang yang ada.
Untuk data pipeline work: Kestra, dengan Airflow sebagai fallback kalau team dah tahu dia. Kami dah tak default ke Airflow untuk new projects — developer experience Kestra meaningfully better dan Apache licence remove commercial ambiguity tu.
Kami tak guna n8n untuk AI agent workflows. Visual canvas dia menarik tapi stateless execution model dia adalah foundation yang salah untuk anything yang perlu reason across multiple steps dengan persistent context. Korang boleh make it work dengan workarounds, tapi dia akan break under load dan akan painful nak debug.
One honest warning about the ecosystem
Ketiga-tiga tools ni tengah bergerak laju. LangGraph's API surface in particular dah berubah significantly between major versions — code yang ditulis against 0.1.x tak akan run tanpa modification on 0.2.x. Ini adalah cost of building on a framework yang actively improving.
Mitigation dia: pin dependency versions korang. Tulis integration tests yang cover graph execution paths. Jangan upgrade LangGraph versions dalam production tanpa run full test suite dulu. Standard engineering practice, tapi jadi lebih critical bila framework tu evolve secepat ni.
n8n's fair-code licence worth baca carefully kalau korang build a product on top of it. Self-hosting untuk internal use — fine. Embedding n8n dalam product yang korang jual ke customers perlukan commercial licence. Ramai teams terkejut dengan benda ni.
Kestra adalah yang paling stable dari tiga ni dari licensing dan API perspective. Apache 2.0, well-defined release cadence, changes well-communicated. Kalau stability adalah primary concern korang, ini relevant.
Takeaway
Pick based on the job, not the hype. If your workflow is linear and connects existing apps, n8n. If you're running data pipelines that need to be bulletproof, Kestra. If you're building AI agents that think, remember, and coordinate, LangGraph.
The worst outcome is using n8n to build something that needs LangGraph's state model, or using LangGraph for something that n8n would have solved in an afternoon. Both are expensive mistakes — one in technical debt, the other in engineering time.
This wraps up Pillar 01 — AI Agents. Pillar 02 covers industry-specific AI automation: manufacturing, healthcare, F&B, legal, logistics, and property — each with the specific technical approach, data requirements, and ROI framework relevant to that sector.