Dify AI Review (2026): Is It the Best No-Code AI Agent Builder?

If you’re trying to “add AI” to your business, the hard part usually isn’t the model. It’s everything around it: connecting your knowledge base, controlling what the agent can do, deploying it safely, and then monitoring whether it’s actually helping. That’s why this Dify AI Review matters—Dify AI positions itself as an all-in-one platform for building AI agents and AI applications without stitching together five separate tools. In practice, it is better described as low-code rather than truly no-code, especially once you move from prototyping to production. Dify AI is best understood as a low-code AI agent platform and AI application platform: it combines agent logic, RAG knowledge retrieval, workflows, deployment, and monitoring in one environment rather than treating AI as a single step inside an automation.

But “best” depends on what you’re building. If you only need simple no-code automation (move data between apps), Dify can be the wrong tool. If you need a durable AI application with retrieval (RAG), workflows, and observability, Dify becomes much more compelling.

Quick Answer (Commercial Verdict): Dify is one of the strongest options in 2026 for small teams that want to build production-style AI agents with built-in RAG, workflow orchestration, deployment, and logs in one platform. It’s not truly “zero-maintenance” and not the simplest choice for basic automation, but it’s a smart pick when your AI assistant must use company knowledge reliably and you want cloud or self-hosted control.

What Is Dify AI (and what problem is it trying to solve)?

Dify AI is an open-source LLM application platform designed to help teams build and operate AI apps, agentic workflows, and knowledge-based assistants. In plain English: it tries to replace a fragmented DIY stack (prompt tools + vector database + workflow glue + deployment + logging) with one integrated system.

This matters for small businesses because most AI projects fail for operational reasons, not because the AI is “bad.” Common failure patterns include:

• Prototype-only builds that never reach a reliable internal or customer-facing deployment.
• Knowledge chaos: outdated docs, duplicate policies, and missing sources lead to inconsistent answers.
• No observability: when answers go wrong, no one can trace why.
• Tool sprawl that quietly increases cost and maintenance burden.

Dify’s value proposition is that it gives you a single place to design the app/workflow, connect knowledge (RAG), choose models, deploy, and monitor behavior.

Business-First AI Framework™: Should you even be looking at Dify?

Before you compare AI software, start with the business decision. Intelligent AI Lab’s Business-First AI Framework™ is a simple way to avoid buying an “AI tool” that doesn’t map to a real workflow.

1. Business Problem: What process is slow, inconsistent, or expensive?
2. Workflow Improvement: What steps can be simplified before adding AI?
3. Choose the Right Solution: Do you need an AI app platform (Dify AI) or a workflow automation tool (Zapier/Make/n8n)?
4. Implement with Human Oversight: Who reviews outputs, exceptions, and escalations?
5. Measure Business Outcomes: What KPIs prove it’s working?
6. Standardize and Scale: Only expand after one workflow is stable.

Business-First AI Insight: Dify is most valuable when you’re building a repeatable AI application (support assistant, internal knowledge copilot, client portal assistant) rather than adding a single AI step into an existing automation. If your workflow doesn’t need a “product-like” AI layer—UI, retrieval, monitoring, permissions—start simpler and cheaper.

Who Dify Is Best For (and who should skip it)

Dify is often marketed as “no-code,” but the more accurate framing from an implementation standpoint is: a low-code production platform for AI applications. That difference matters because production needs (security, maintenance, reliability) usually require at least some technical comfort.

Dify is a strong fit if you are…

• An SMB building an internal knowledge assistant (SOPs, policies, onboarding docs) where answers must be grounded in your documents.
• A support team that wants AI triage/deflection with clear escalation paths and the ability to monitor quality.
• An agency or no-code builder productizing AI assistants for multiple clients and needing repeatable deployment + controls.
• A team that wants deployment choice (cloud now, self-host later; or self-host for data control from day one).

You should probably skip Dify if you are…

• Only trying to automate app-to-app workflows (e.g., “when a form is submitted, create a CRM contact, send an email”). Tools like Zapier/Make are typically faster to implement.
• Expecting zero maintenance while also demanding self-hosting or complex production reliability.
• Needing a conversation-design-first builder for highly scripted conversational UX where design tooling is the priority (Voiceflow may be a better fit).
• Completely non-technical and unwilling to involve anyone technical for deployment, security, or integrations.

Dify’s Core Capabilities (what matters for small businesses)

Rather than listing every feature, here are the capabilities that typically determine whether Dify AI will succeed or frustrate an SMB team.

1) Visual AI workflow orchestration (from idea to repeatable process)

Dify’s visual builder is designed to turn AI behavior into a workflow that your business can understand and operate. This matters because most business value comes from reliable execution, not clever prompts.

Use it when: you need multi-step logic (classify → retrieve → answer → escalate → log) rather than a single “chat” interaction.

Trade-off: visual orchestration is faster than custom code for many teams, but you still need discipline around versioning, testing, and change control.

2) Built-in RAG / knowledge base workflows (a practical advantage)

RAG (Retrieval-Augmented Generation) means the system retrieves relevant information from your documents and uses it as context for the model’s answer. For SMBs, this is the difference between “a generic chatbot” and “a Dify AI assistant that knows our policies.”

Why it matters: most business assistants fail when they answer confidently with the wrong policy, wrong pricing, or outdated SOP.

Implementation reality: your results will only be as good as your documents. If your SOPs are inconsistent, Dify won’t magically fix that—your workflow must include content governance.

3) Model flexibility (LLM-agnostic positioning)

Dify is frequently described as model-flexible or LLM-agnostic. For buyers, the business value is optionality: you’re less locked into a single model provider’s UI and can adapt as models, costs, and policies change.

Trade-off: flexibility can increase decision load. Someone still has to choose models, set budgets, and monitor token costs.

4) Observability and debugging (production gets real fast)

Once an AI agent is used by staff or customers, you need to answer questions like: What did it retrieve? Why did it respond that way? What changed since last week?

Dify emphasizes logs/observability as part of its platform story. That’s a major differentiator compared to “prompt-only” tools.

5) Dify Open Source: Cloud vs Self-Hosted

Dify offers a free-to-self-host Community Edition, while its repository is licensed under the Dify Open Source License, which is based on Apache 2.0 but includes additional conditions. Review the licence terms carefully if you plan to embed, resell, or operate Dify in a multi-client or multi-tenant product.

Agencies and SaaS businesses planning to resell, embed, or operate a shared multi-client Dify deployment should review Dify’s current licence terms before committing to that architecture.

License terms can change and may apply differently depending on how Dify is deployed, modified, embedded, or offered as a service. Businesses with commercial redistribution or multi-tenant plans should review the current license and obtain legal advice where necessary.

• Cloud: faster time-to-value, less operational burden, but you accept vendor platform dependency and plan limits.
• Self-host: more control and data sovereignty, but you take on infrastructure, upgrades, reliability, and security responsibilities.

Approach	Best for	Build effort	Control	Time to first prototype	Ongoing responsibility
Custom AI agent development	Highly specialized products, proprietary integrations, complex governance needs	High	Very high	Usually slower	High
Dify AI	RAG assistants, agent workflows, internal copilots, client-facing AI apps	Low to medium	High at the app and workflow layer	Fast	Medium
Zapier, Make, or n8n	System integrations, routing, notifications, and repeatable operational automations	Low to medium	Moderate	Very fast	Low to medium

Dify’s advantage is not that it removes engineering completely. Its advantage is that it packages much of the application-layer work—workflow orchestration, RAG, deployment, logging, and model management—into a visual environment. Dify’s workflow documentation describes connecting nodes for model calls, retrieval, code execution, and conditional logic, while its agent tools can run either independently or as part of a larger workflow.

How Dify AI’s Agent Builder Works

Dify AI’s agent builder turns an AI idea into a structured application rather than a standalone prompt. This makes Dify AI closer to a no-code AI agent builder than a traditional chatbot builder, although production deployments are better described as low-code. In a typical build, you define the business goal, set the agent’s instructions and model, connect approved knowledge sources, give the agent access to tools or APIs, and place it inside a workflow when the job requires branching, approvals, or handoffs.

For example, a customer-support agent might follow this flow:

Customer question → classify the intent → retrieve the relevant policy or help article → generate a grounded answer → escalate billing, refund, or sensitive cases → log the interaction for review.

Dify lets teams use agents on their own as chat-style applications or use an agent as one step inside a broader workflow. Its workflow builder can connect steps such as model calls, knowledge retrieval, code execution, conditional branches, triggers, and outputs. Dify also supports publishing applications as web apps or APIs and provides logs for reviewing conversations and workflow runs.

The practical advantage is that small teams can assemble and test an AI assistant faster than building every retrieval, orchestration, deployment, and monitoring component from scratch. The trade-off is that the visual builder does not eliminate the need for operational design: someone still needs to define approved knowledge, escalation rules, permissions, testing criteria, and ongoing quality checks.

Accuracy note to add: Dify’s current documentation describes its newer Agent feature as beta. For sensitive, public-facing, or multi-tenant use cases, advise readers to test it in a controlled environment and validate security boundaries before launch. Dify specifically notes that the Agent runtime is not intended to be a hardened isolation boundary between mutually untrusted users or workloads.

Dify AI Pricing in 2026: Plans and Real Cost Drivers

At the time of review, Dify AI’s cloud platform lists a free Sandbox plan, Professional at $59 per workspace per month, and Team at $159 per workspace per month. Annual billing is listed at $590 for Professional and $1,590 for Team, before applicable taxes. The free Sandbox includes 200 one-time message credits—not a monthly credit allowance—so it is best treated as a limited evaluation plan rather than a long-term free tier.

Option	Best For	What You Pay	Main Cost Risk
Sandbox (Cloud)	Testing basic workflows and fit	Usually $0 platform cost (verify limits)	You may outgrow limits quickly; model usage still matters
Professional (Cloud)	Small teams piloting real workflows	Reported ~$59/workspace/month	Scale costs: usage, seats/workspace rules, model tokens
Team (Cloud)	Teams needing more collaboration/controls	Reported ~$159/workspace/month	Same scale risks; governance becomes necessary
Community Edition (Self-host)	Data control, custom infra, long-term control	$0 license fee + your hosting costs	Ops burden: servers, updates, security, uptime, backups

Dify Cloud includes message credits, but credit consumption varies by model. Once included credits are exhausted, teams can switch to their own provider API keys, which introduces separate model-provider usage costs. Self-hosting removes Dify Cloud subscription fees, but it does not remove model, infrastructure, storage, backup, security, and maintenance costs.

The cost reality check: “Self-hosted is free” isn’t a business answer

Even when the software license is free, your total cost of ownership includes:

• Infrastructure: servers, storage, networking, backups
• Maintenance: patching, upgrades, incident response
• Security: access control, secrets management, auditing
• Model usage: token/usage costs don’t go away with self-hosting
• People time: someone must own reliability and governance

If you can’t name the person responsible for uptime and data access policies, self-hosting will likely become “free until it breaks.”

Pros and Cons (from an SMB implementation lens)

Dify is widely praised for time savings and customization, but there are consistent concerns around documentation gaps, front-end flexibility, and the operational burden of self-hosting.

Pros

• All-in-one platform structure: orchestration + RAG + deployment + observability reduces tool sprawl.
• Good fit for real AI apps: better aligned to “ship and operate” than many prompt tools.
• Self-hosting option: helpful for data control and compliance needs (with the caveat of ops burden).
• Model flexibility: reduces dependence on a single model vendor’s app layer.

Cons / Limitations

• Not truly beginner-friendly: many teams still need technical support for production deployments and integrations.
• Documentation/community gaps: can slow teams down when they hit edge cases.
• Self-hosting overhead: “free” can become expensive in time, risk, and reliability work.
• Front-end expectations: if you need highly customized customer UX, plan for extra work beyond the core platform.

Consultant Insight: Teams often underestimate the “middle layer” work: cleaning documents, defining escalation rules, setting permissions, and monitoring. Dify reduces the engineering needed to build an AI app framework, but it doesn’t remove the operational work required to make an AI assistant safe and useful.

Dify AI Alternatives: Dify vs n8n, Zapier, Make, Botpress and Voiceflow

Most comparisons go wrong by comparing feature lists. A better approach is to compare what each tool is optimized to deliver: an AI application, a workflow automation layer, or a conversation design experience.

The best Dify alternative depends on whether you need a knowledge-based AI application, a general automation platform, or a conversation-design environment. These tools overlap, but they do not solve the same business problem.

Tool	Best For	Ease of Use	Time to Value	Business Size Fit	Notes
Dify	AI apps, RAG assistants, agentic workflows	Medium	Fast for prototypes; medium for production	SMB to mid-market	All-in-one app platform; cloud or self-host
n8n	General automation and system integrations	Medium	Fast for ops workflows	SMB to mid-market	Great automation flexibility; less focused on RAG app experience
Zapier	Simple, integration-heavy automations	High	Very fast	Solo to SMB	Best when the workflow is straightforward; not an AI app platform
Make	Visual process automation	Medium	Fast	SMB	Strong workflow builder; AI app building is not the core focus
Botpress	Controlled conversational agents	Medium-High	Medium	SMB to enterprise	Often better for developer-led teams needing deeper control
Voiceflow	Conversation design and prototyping	Medium	Fast for chat UX	SMB to mid-market	Great for designing flows; less centered on broader AI app ops
Gumloop	AI workflow pipelines	Medium	Fast	SMB	More workflow-oriented; not always positioned as full app platform

My practical recommendation: the “Dify + automation layer” pattern

For many small businesses, the best architecture is:

• Dify for the AI application layer (RAG, agent logic, prompt/workflow management, logs)
• Zapier/Make/n8n for broader app integrations and operational automation (ticketing, CRM routing, notifications)

This avoids trying to force an automation tool to behave like a full AI app platform—or forcing an AI app platform to replace your integration hub.

Best Use Cases for Small Businesses (where Dify tends to pay off)

Based on common SMB workflows highlighted in reviews and typical adoption patterns, these are the use cases where Dify’s bundled approach (RAG + orchestration + deployment + observability) is most likely to create business value.

1) Internal knowledge assistant (SOPs, policies, onboarding)

Problem it solves: employees waste time searching for “the right doc” and asking the same questions in Slack.

Why Dify fits: the knowledge base + RAG workflow can deliver answers grounded in internal documents.

Operational requirement: designate an owner for document freshness and add a cadence for updates.

2) Customer support triage + escalation assistant

Problem it solves: repetitive tickets consume your team’s time and slow response times.

Why Dify fits: you can build a workflow to classify intent, answer from knowledge, and escalate edge cases.

When not to use it: if your support answers aren’t documented anywhere, you’ll need to fix the knowledge base first.

3) Policy and SOP assistant (compliance-sensitive teams)

Problem it solves: staff need consistent guidance from approved policies (healthcare, accounting, legal ops, HR).

Why Dify fits: RAG with citations plus logging/monitoring can support auditability (but it doesn’t guarantee compliance on its own).

Risk to manage: AI should not be the final authority for regulated decisions; implement review and escalation rules.

4) Agency client portal assistant (productized AI deliverable)

Problem it solves: agencies want differentiated deliverables and recurring value after onboarding.

Why Dify fits: Dify is positioned as an AI app platform, which maps well to repeatable, client-facing assistants tied to client docs.

5) Lead qualification assistant (with routing)

Problem it solves: inbound leads are unqualified, and sales time gets wasted.

Best pattern: Dify for the conversation/qualification logic + Zapier/Make/n8n for CRM routing and notifications.

Is Dify a No-Code AI Agent Builder in Practice?

Dify AI can feel no-code during prototyping, especially for straightforward chat + knowledge-base assistants. But most SMBs discover that “production no-code” still requires decisions and work that look a lot like light engineering:

• Data prep: cleaning documents, removing duplicates, deciding what’s authoritative.
• Permissions: who can access what knowledge, and how you enforce it.
• Escalation logic: when the agent must hand off to a human.
• Monitoring: reviewing failures, improving prompts/workflows, updating knowledge.
• Integrations: connecting help desks, CRMs, or internal tools (often via an automation platform).

If you treat Dify as “set and forget,” you’ll likely end up with an assistant that works in demos but becomes a risk in real operations.

Short answer: Dify is no-code for many early prototypes, but low-code in real production use. You can build a basic knowledge assistant visually, yet reliable deployment still requires decisions about knowledge quality, access controls, integrations, escalation rules, testing, and ongoing monitoring.

Implementation Advice: How to deploy Dify without creating a new headache

The fastest path to value is a narrow pilot with measurable KPIs. Here’s a practical rollout sequence that fits how small businesses actually adopt AI tools.

Before choosing Dify, test these five things:

1. Can it retrieve the correct answer from your messiest real-world documents?
2. Can you make high-risk requests reliably escalate to a human?
3. Does the workflow connect cleanly to your CRM, help desk, or internal tools?
4. What does the cost per useful conversation look like using your preferred model?
5. Can your team maintain the knowledge base, permissions, and workflow changes after launch?

Phase 1: Choose one workflow and one owner (1–3 days)

• Pick one high-volume, repetitive workflow (e.g., support FAQs, internal SOP lookup).
• Assign an owner responsible for knowledge quality and weekly review.
• Define a clear escalation rule: what the AI must not answer.

Phase 2: Prepare the knowledge base (2–10 days, depending on messiness)

• Gather the authoritative docs (not “everything you can find”).
• Remove outdated versions and duplicates.
• Decide what counts as the single source of truth.

Why this matters: a “smart” assistant built on messy knowledge becomes confidently inconsistent.

Phase 3: Build the MVP agent with guardrails (1–5 days)

• Build a workflow that retrieves from knowledge and answers with citations (when possible).
• Add a fallback response when confidence is low: ask clarifying questions or escalate.
• Log outcomes: what questions are asked, what documents are used, where it fails.

Phase 4: Measure outcomes (first 2–4 weeks)

Don’t measure “coolness.” Measure operational impact. KPIs commonly used for these deployments include:

• Time to first prototype and time to deploy
• Ticket deflection rate (for support use cases)
• Median response time improvement
• Cost per conversation/workflow (platform + model usage)
• Escalation rate and top escalation reasons
• Internal adoption rate (are people actually using it?)

Phase 5: Standardize and scale (month 2+)

• Turn your working MVP into a documented internal “pattern” your team repeats.
• Add more workflows only after the first one is stable and measurable.
• If self-hosting is a goal, migrate only after you’ve proven value and can justify the ops overhead.

Decision Tree: Dify vs n8n vs a simpler automation tool

Use this to make a clear choice without overbuying.

1. Do you need the AI to answer from internal documents (RAG) reliably?
   • If yes → go to #2
   • If no → you may not need an AI app platform; consider Zapier/Make/n8n first
2. Is this an ongoing “AI application” (support assistant, portal assistant, internal copilot) rather than a one-off automation step?
   • If yes → Dify is a strong candidate
   • If no → automation tools may be faster and cheaper
3. Do you need many app integrations and operational routing?
   • If yes → plan on Dify + Zapier/Make/n8n
   • If no → Dify alone may be enough for the first workflow
4. Do you require self-hosting for data control?
   • If yes → Community Edition is attractive, but budget for ops/security work
   • If no → cloud may deliver faster time-to-value

Common Mistakes SMBs Make with Dify (and how to avoid them)

Mistake #1: Choosing Dify for a problem that only needs simple automation

Why it happens: “AI agents” sound like the answer, even when the workflow is just moving data.

Consequence: you add complexity (and maintenance) without improving outcomes.

Better approach: map the workflow first. If the job is routing and syncing, use Zapier/Make/n8n. If the job is knowledge-driven reasoning and responses, Dify becomes relevant.

Mistake #2: Underestimating the cost of tokens + scale

Why it happens: teams budget for platform pricing but forget that model usage is often the variable cost driver.

Consequence: the assistant succeeds, usage grows, and costs surprise you.

Better approach: track cost per conversation/workflow early and set usage guardrails.

Mistake #3: Uploading messy docs and expecting good answers

Why it happens: RAG feels like a magic “connect your docs” button.

Consequence: conflicting answers, trust loss, and more escalations.

Better approach: curate a smaller, authoritative knowledge base first. Expand only after quality is stable.

Mistake #4: Launching without escalation rules and human oversight

Why it happens: teams want deflection and speed, so they remove guardrails.

Consequence: risky responses in edge cases (refunds, medical/legal guidance, pricing exceptions).

Better approach: define “must escalate” categories before launch, then refine based on logs.

Is Dify AI the Best No-Code AI Agent Builder in 2026? An expert verdict

Short answer: Dify AI is one of the strongest no-code-to-low-code AI agent builders for teams creating knowledge-based assistants, RAG applications, and structured agent workflows. It is not the best choice for every business: Zapier, Make, or n8n will usually be simpler when the actual job is basic app-to-app automation rather than operating an AI application.

Dify AI is worth it when you’re building an AI assistant that needs to behave like a real business system: grounded in your knowledge, repeatable across users, deployed reliably, and monitored over time. Its biggest advantage is combining workflow orchestration + RAG + deployment + observability in one platform—exactly what many small teams struggle to assemble.

It’s not worth it when your “AI project” is really just workflow automation, or when you want a fully managed experience but also want deep control and self-hosting without operational overhead.

Expert Verdict: For SMBs and agencies building knowledge-based assistants and agent workflows, Dify is one of the best “ship a real AI app” platforms to evaluate in 2026. Pair it with an automation tool (Zapier/Make/n8n) when integrations and routing matter. If you only need basic automations, choose the simpler tool and keep your stack lean.

Implementation Priority: Start Today → Improve Next → Scale Later

Start Today (low effort, high clarity)

• Pick one workflow with measurable volume (top 20 support questions or top 20 internal SOP lookups).
• Define 3 success metrics (e.g., response time, deflection rate, adoption rate).
• Decide your red lines: questions the AI must escalate.

Improve Next (next 30 days)

• Clean and curate the knowledge base (authoritative docs only).
• Run a controlled pilot with a small user group.
• Review logs weekly and fix failure modes before wider rollout.

Scale Later (after you’ve proven value)

• Standardize a repeatable template for new assistants/workflows.
• Add integrations using Zapier/Make/n8n where it reduces manual ops.
• Consider self-hosting only when you can staff and secure it properly.

FAQ

What is Dify AI used for?

Dify is used to build AI applications and agents—especially knowledge-based assistants that answer from internal documents using RAG, plus workflow-based agent behavior you can deploy and monitor.

Is Dify really no-code?

Dify is visual and low-code for many builds, but production deployments typically require some technical comfort: data preparation, integrations, permissions, monitoring, and (if self-hosted) infrastructure and security.

Is Dify free?

Dify’s Community Edition can be self-hosted without a Dify subscription fee, but hosting, infrastructure, model usage, maintenance, and security still create costs.

How much does Dify cost in 2026?

At the time of this review, Dify Cloud lists a free Sandbox plan, Professional at $59 per workspace per month, and Team at $159 per workspace per month. Annual billing is listed at $590 for Professional and $1,590 for Team, before applicable taxes. Dify also offers a Community Edition for self-hosting, but self-hosting still involves infrastructure, model usage, security, maintenance, and other operating costs. Check Dify’s official pricing page for the latest prices before purchasing.

Can Dify be self-hosted?

Yes. Dify’s Community Edition supports self-hosting, which can help with data control. The trade-off is operational responsibility: uptime, patching, backups, and security controls become your job.

Does Dify support RAG?

Yes. RAG (Retrieval-Augmented Generation) is a major reason teams choose Dify—so the agent can answer based on your documents and knowledge base rather than generic model knowledge.

Is Dify production-ready for small businesses?

Many sources position Dify as production-ready, especially compared to prompt-only tools. In practice, “production-ready” depends on your implementation: knowledge quality, guardrails, monitoring, and whether you can operate cloud or self-hosted infrastructure reliably.

Dify vs n8n: which should I choose?

Dify can be used for production AI applications, but production readiness depends on how you configure and operate it. Knowledge quality, access controls, guardrails, monitoring, integrations, and infrastructure all affect whether a Dify deployment is reliable enough for your business. For customer-facing or sensitive use cases, start with a controlled pilot, define escalation rules, monitor performance, and validate security before expanding.

What are the main downsides of Dify?

Common downsides include documentation gaps, the operational burden of self-hosting, and the reality that cloud/platform pricing and model usage costs can increase as adoption grows.

Conclusion: The real question isn’t “Is Dify the best?”—it’s “Do you need an AI app platform?”

Most small businesses don’t need more AI tools. They need one workflow that reliably saves time or improves customer experience. Dify AI earns its place when your goal is a durable AI application—grounded in your knowledge, deployed with guardrails, and monitored like a real business system.

Pick a narrow, high-ROI workflow first (support Q&A, internal SOP assistant). Prove impact with clear KPIs. Then scale. That’s how you turn AI software into business outcomes—without creating a fragile system your team has to babysit.

Next step: If you’re evaluating Dify and want to avoid overbuilding, start by mapping one workflow end-to-end (inputs, knowledge sources, escalation rules, success metrics). Once that’s clear, the tool choice usually becomes obvious.