Forem: Jangwook Kim

Taskade Review 2026: The AI-Powered Productivity Platform Where Agents Actually Do the Work

Jangwook Kim — Tue, 07 Apr 2026 06:56:53 +0000

Taskade Review 2026: The AI-Powered Productivity Platform Where Agents Actually Do the Work

Every productivity platform in 2026 has an AI feature. Notion has AI blocks. ClickUp has AI writing. Monday has AI automations. But most of these are bolt-on features — a chatbot here, a text generator there. They assist. They do not act.

Taskade takes a different approach. Instead of adding AI as a feature layer on top of a project management tool, Taskade built AI agents as first-class citizens of the platform. These agents can create tasks, update projects, trigger automations, and coordinate with each other across your workspace. They remember context between sessions. They learn from your documents. And as of early 2026, they can build entire web applications from a single prompt through a feature called Genesis.

The question is whether this agent-first architecture translates into real productivity gains, or if it is mostly a marketing angle wrapped around the same task-and-board interface everyone else offers.

We evaluated Taskade at Effloow as part of our content operations stack — specifically to see whether its AI agents could handle recurring editorial workflows alongside tools we already use. This review covers what Taskade does well, where it falls short, who should seriously consider it, and whether the pricing justifies the feature set.

Disclosure: This article contains affiliate links. If you sign up for Taskade through our links, Effloow may earn a commission at no extra cost to you. See our affiliate disclosure for details. Our recommendations are based on our own evaluation — we only recommend tools we have personally tested.

What Is Taskade?

Taskade is an AI-powered workspace for teams that combines project management, document collaboration, and AI agent capabilities in a single platform. It was founded in 2017 and has steadily evolved from a simple task management app into what the company now describes as a platform where teams "build and run AI apps, agents, and workflows."

The platform is available on Web, macOS, Windows, Linux, iOS, Android, and browser extensions — essentially every surface a productivity tool needs to cover.

What sets Taskade apart from competitors in 2026 is the depth of its AI integration. While most productivity tools added AI features after the ChatGPT wave, Taskade restructured its entire product around three pillars:

Memory — Projects and databases that store structured data with custom fields and multiple views
Intelligence — AI Agents v2 with custom tools, persistent memory, and access to 11+ models from OpenAI, Anthropic, and Google
Execution — Automations connecting 100+ external integrations with branching logic

These three pillars feed into each other. Projects store data. Agents reason about that data and take action. Automations execute those actions at scale. It is the kind of architecture that sounds good on a product page — and in our testing, it actually works closer to that vision than you might expect.

Key Features: What Taskade Actually Does

Project Management and Views

At its core, Taskade is a project management tool. You create workspaces, organize them into folders, and build projects inside those folders. Each project supports eight different views of the same data:

List — Classic task list with subtasks and due dates
Board — Kanban-style columns
Calendar — Date-based view for scheduling
Table — Spreadsheet-like with custom fields
Mind Map — Visual brainstorming with connected nodes
Gantt — Timeline view for project planning
Org Chart — Hierarchical structure visualization
Timeline — Chronological project view

This multi-view approach is genuinely useful. You can plan a content calendar in Calendar view, manage the production pipeline in Board view, and track individual article progress in Table view — all from the same underlying data. If you have used Notion databases with multiple views, the concept is similar, though Taskade's mind map and org chart views add visual options that Notion does not offer natively.

Real-time collaboration is built in. Multiple team members can edit the same project simultaneously with cursor tracking and presence indicators. Taskade also includes a built-in video calling feature — a small but practical addition that eliminates the need to switch to Zoom or Google Meet for quick syncs.

The access control system has seven tiers, ranging from view-only to full admin permissions. For teams managing client projects or working with external contractors, this granularity matters.

AI Agents: The Core Differentiator

This is where Taskade separates from the pack. AI agents in Taskade are not chatbots that sit in a sidebar and answer questions. They are autonomous digital teammates that can reason through problems, execute multi-step workflows, and take real action inside your workspace.

Each agent comes with access to 22+ built-in tools and can be extended with custom tool definitions and slash commands. Agents can:

Create and update tasks and projects
Send emails and notifications
Trigger automations and workflows
Search and analyze documents in your workspace
Integrate with 100+ external services
Coordinate with other agents in multi-agent teams

The Agent Builder lets you create custom agents trained on your specific data. You upload documents, connect data sources, and define the agent's role, personality, and capabilities. The agent then inherits what Taskade calls Workspace DNA — an understanding of your organizational context, terminology, and processes.

What makes this meaningful is persistent memory. When you have a conversation with a Taskade agent, that conversation is saved with full context. The next time you interact with the agent, it remembers what you discussed, what decisions were made, and what actions were taken. This eliminates the "starting from scratch" problem that plagues most AI chat interfaces.

For teams that coordinate multiple AI agents, Taskade supports multi-agent orchestration — assigning specialized agents to different roles (research, writing, project management) and letting them collaborate on complex workflows. If you are running a content operation, this is the kind of thing that turns a 3-hour research process into a 30-minute review.

If the concept of AI agents working autonomously on business tasks sounds familiar, it is because this is the direction the entire industry is heading. We wrote about how we built a company run by 14 AI agents — the core idea of agents doing real work, not just suggesting, is central to how we operate at Effloow.

Deployment options add flexibility. Agents can operate internally within your workspace, or you can deploy them externally — as embedded chatbots on your website, public-facing assistants, or customer support bots with branded interfaces. This turns Taskade from a productivity tool into a lightweight AI deployment platform.

Genesis: The No-Code App Builder

Genesis is Taskade's boldest feature and one that no competitor in the productivity space currently matches. It is a no-code AI app builder that transforms natural language prompts into complete, deployable web applications — typically within 2 to 15 minutes.

This is not code generation. Genesis creates what Taskade calls "living systems" — applications with responsive UIs, structured databases, embedded AI agents, and automated workflows. You describe what you need, select your preferred AI model, and Genesis builds it.

The categories of apps you can build include:

Client portals with project tracking and file sharing
CRM systems with pipeline management
Booking and scheduling apps
Interactive learning platforms with AI tutors
Invoice generators and expense trackers
Landing pages and marketing sites
AI chatbots with context-aware responses

Each app gets an instant live URL upon completion. Business plan subscribers can connect custom domains and apply white-label branding. Published Genesis apps run without consuming AI credits, which means your production applications can serve unlimited users at no additional cost beyond your subscription.

This is a significant development in the vibe coding movement — the idea that you describe software in plain language rather than writing code. While standalone tools like Bolt.new and Lovable generate code files that still need deployment, Genesis produces running applications with built-in data management and AI capabilities.

The practical limitation is complexity. Genesis works well for internal tools, simple client-facing apps, and prototypes. For applications requiring custom backend logic, complex integrations, or high-traffic scalability, you will still need a developer. But for the 80% of business tools that are fundamentally forms, dashboards, and workflows, Genesis is surprisingly capable.

Workflow Automation

Taskade offers 104 automation actions with conditional branching and looping. Automations can be triggered by events (a task status change, a form submission, a schedule, or a webhook), and they can interact with 100+ external services including Slack, HubSpot, Stripe, GitHub, Discord, and Microsoft Teams.

The automation builder is visual and relatively intuitive. You define trigger conditions, add action steps, and set up branching logic for different scenarios. For teams already using Zapier, Make, or n8n for workflow automation, Taskade's native automations can replace some of those external workflows — particularly the ones that involve data already living inside Taskade.

Where this connects to the broader platform is through AI agents. An automation can trigger an agent, which can reason about the data, make a decision, and trigger another automation. This creates feedback loops that are difficult to replicate with traditional trigger-action automation tools.

AI Model Access

Taskade provides access to 11+ frontier AI models from three providers: OpenAI (GPT-4 and later), Anthropic (Claude), and Google (Gemini). You can select different models per agent, which means you can assign Claude for nuanced writing tasks, GPT-4 for code generation, and Gemini for research — all within the same workspace.

This multi-model approach is a significant advantage over tools locked into a single AI provider. If you are comparing AI coding tools or AI writing assistants, having model choice built into your productivity platform saves you from maintaining separate subscriptions.

Taskade Pricing Breakdown: What You Actually Pay

Taskade's pricing model is one of its strongest selling points. While most productivity tools charge per seat — which gets expensive fast as your team grows — Taskade uses flat team pricing on its most popular plans.

Plan	Monthly	Annual (per month)	Users Included	AI Credits/Month	Agents
Free	$0	$0	1	3,000 (one-time)	1
Starter	$8	$6	3	10,000	3
Pro	$20	$16	10	50,000	Unlimited
Business	$50	$40	Unlimited	150,000	Unlimited
Enterprise	Custom	Custom	Unlimited	Unlimited	Unlimited

Source: taskade.com/pricing

The Math That Matters

The Pro plan at $16/month (billed annually) for up to 10 users is where the value proposition gets interesting. That is $1.60 per user per month. Compare that to:

Notion AI: $10/user/month for AI features on top of the base plan
ClickUp AI: $5/user/month add-on, plus base plan costs
Monday AI: Available on Pro plan at $12/seat/month minimum

For a team of 10, Taskade Pro costs $16/month total. Notion with AI would cost approximately $100-200/month depending on the base plan. ClickUp with AI would be at least $170/month. The savings are substantial, especially for small teams and startups where every dollar of runway matters.

The Business plan at $40/month for unlimited users is remarkable for growing companies. Once your team exceeds 10 people, the per-user cost decreases with every new member.

AI Credits: What They Cover

AI credits are consumed when agents perform actions, generate content, or process requests. The Free plan's 3,000 credits are one-time (not monthly), which is enough to evaluate the platform but not enough for ongoing use. The Pro plan's 50,000 monthly credits support approximately 50 app generations or equivalent agent interactions — sufficient for most small team use cases.

Crucially, published Genesis apps do not consume credits. This means you can build and deploy internal tools or client-facing apps without worrying about ongoing AI costs for end users.

Additional Features by Plan

Custom domains and branding: Business and Enterprise only
100+ integrations: Pro and above
Unlimited automations: Pro and above
Advanced admin controls: Business and above
SSO and compliance: Enterprise

Taskade vs Notion AI: The Comparison Everyone Wants

This is the comparison most people searching for a Taskade review actually want. Both platforms combine project management with AI features, but they serve fundamentally different use cases.

Feature	Taskade	Notion AI
AI agents	Custom autonomous agents with 22+ tools, multi-agent teams	AI writing assistant and Q&A — no autonomous agents
Pricing model	Flat team pricing ($16/mo for 10 users)	Per-seat ($10-20/user/month)
App building	Genesis no-code builder with instant deployment	No equivalent feature
Automation	104 native actions, 100+ integrations	Requires Zapier or Make for automation
AI models	11+ models from OpenAI, Anthropic, Google	Anthropic-powered only
Database	Basic structured data with custom fields	Full relational databases with formulas
Documentation	Good for tasks, limited for deep wikis	Industry-leading wiki and documentation
Video calls	Built-in native video	No native video
Offline support	Limited	Better offline capabilities
Mobile app	Functional but commonly noted as clunky	More polished mobile experience
Templates	1,000+ built-in templates	Community-driven template library

When to Choose Taskade

Choose Taskade if you want AI agents that do things — not just write or answer questions. If your workflow involves recurring automations, if you need to build internal tools without a developer, or if flat team pricing matters for your budget. Taskade is the action-oriented choice.

When to Choose Notion

Choose Notion if your primary need is documentation, knowledge management, or relational databases. Notion's wiki capabilities, database formulas, and overall polish are still ahead of Taskade for content-heavy, documentation-first teams.

For a deeper comparison of AI-powered documentation tools, see our Notion AI custom agents developer guide.

Taskade vs ClickUp, Monday, and Asana

Beyond the Notion comparison, here is how Taskade stacks up against the traditional project management platforms:

Feature	Taskade	ClickUp	Monday	Asana
AI agents	Autonomous, custom-built	ClickUp Brain (assistant)	Monday AI (assistant)	Asana Intelligence (assistant)
Price (10 users)	$16/mo total	$170+/mo	$120+/mo	$130+/mo
App builder	Genesis (no-code)	None	None	None
Automation	104 actions, native	Advanced, mature	Visual builder	Rules-based
Video calls	Built-in	None native	None native	None native
Gantt charts	Included all plans	Paid plans	Paid plans	Premium+
Learning curve	Low-Medium	High	Medium	Medium

Taskade wins decisively on price and AI depth. ClickUp wins on project management maturity and advanced feature set. Monday wins on ease of use for non-technical teams. Asana wins on enterprise workflow management.

The honest take: if your team's primary need is traditional project management at scale — resource allocation, workload management, complex dependencies — ClickUp or Asana are more mature choices. If you want a lighter, AI-first workspace where agents and automations do the heavy lifting, Taskade is the stronger pick.

Who Should Use Taskade?

Ideal Users

Small teams (2-10 people) who need project management + AI without paying per-seat enterprise prices
Solopreneurs and freelancers who want AI agents handling recurring workflows
Startups building internal tools quickly with Genesis instead of hiring developers
Content teams using AI agents for research, drafting, and editorial workflows
Agencies managing multiple client projects with embedded AI chatbots
Remote teams who benefit from built-in video calls and real-time collaboration

Who Should Look Elsewhere

Enterprise teams needing advanced compliance, audit trails, and deeply customizable permissions (consider Asana or Monday Enterprise)
Documentation-first teams where wiki quality matters more than AI agents (choose Notion)
Developer teams needing issue tracking, CI/CD integration, and code review workflows (use Linear, Jira, or GitHub Projects)
Teams already invested in a mature PM tool with extensive integrations and custom workflows they do not want to rebuild

Taskade Pros and Cons: The Honest Assessment

Pros

AI agents that actually work — Not chatbots, but autonomous teammates with persistent memory, custom tools, and multi-agent coordination
Flat team pricing — $16/month for 10 users is genuinely exceptional value in the productivity space
Genesis app builder — Building deployable web apps from prompts is a unique capability no direct competitor offers
Multi-model AI access — Choice of 11+ models from OpenAI, Anthropic, and Google within a single platform
All-in-one workspace — Project management, docs, AI agents, video calls, and automation in a single tool
8 project views — Including mind map and org chart that most competitors lack
1,000+ templates — Extensive library for fast project setup
Cross-platform — Available on every major platform including Linux and browser extensions

Cons

Mobile app needs improvement — Commonly reported as clunky compared to Notion or ClickUp mobile apps
Database features are basic — No relational databases, formulas, or the depth of Notion databases
Offline support is limited — Not ideal for teams frequently working without internet
Smaller ecosystem — Fewer community integrations and third-party extensions compared to Notion or ClickUp
Documentation depth — Wiki and knowledge base capabilities are functional but not best-in-class
Genesis limitations — While impressive for simple apps, complex applications still require real development
Free plan is restrictive — 3,000 one-time credits and 1 agent are barely enough to evaluate the AI features properly
Relatively younger platform — Less battle-tested at enterprise scale compared to established PM tools

Is Taskade Worth It in 2026?

For the right team, Taskade offers the best value proposition in the AI productivity space right now. The combination of autonomous AI agents, flat team pricing, and a no-code app builder creates a package that no single competitor matches.

The platform is not perfect. The mobile experience needs work, the database features lag behind Notion, and enterprise teams with complex compliance requirements should look at more established options. But for small-to-medium teams that want AI to do real work — not just generate text — Taskade is worth serious evaluation.

The 50% lifetime recurring affiliate commission also signals something about the product: Taskade is confident enough in its retention to pay partners half of every subscription payment, forever. That level of commission only makes financial sense when users stick around.

If you are building a team of AI agents for your business, Taskade is one of the most accessible entry points. You do not need to set up infrastructure, write code, or stitch together multiple tools. The agents, the workspace, and the automation layer are all in one place.

Frequently Asked Questions

Is Taskade free?

Yes. Taskade offers a Free plan with 3,000 one-time AI credits, 1 AI agent, and 3 live Genesis apps. It is enough to explore the interface and basic features, but you will need a paid plan for meaningful AI usage.

How much does Taskade cost per user?

Taskade uses flat team pricing, not per-user pricing. The Pro plan costs $16/month (billed annually) for up to 10 users — that is $1.60 per user. The Business plan costs $40/month for unlimited users. Source: taskade.com/pricing.

Is Taskade safe and secure?

Taskade offers standard cloud security practices. Enterprise plans include SSO integration and advanced admin controls. SOC 2 compliance is referenced for enterprise customers. For most small-to-medium teams, the security posture is adequate, though organizations with strict compliance requirements should contact Taskade's sales team for detailed security documentation.

What is Taskade Genesis?

Genesis is Taskade's no-code AI app builder. You describe the application you want in plain language, and Genesis builds a complete web application with a responsive UI, structured database, embedded AI agents, and automated workflows — typically within 2 to 15 minutes. Published apps get instant live URLs and do not consume AI credits.

How does Taskade compare to Notion?

Taskade wins on AI agents (autonomous vs. assistant-only), pricing (flat vs. per-seat), and app building (Genesis vs. nothing). Notion wins on databases (relational vs. basic), documentation (industry-leading wiki), and mobile experience. Choose Taskade for AI-first action; choose Notion for documentation-first knowledge management.

Can Taskade replace ClickUp?

For small teams focused on AI-powered workflows, yes. Taskade covers task management, collaboration, and automation at a fraction of the cost. For large teams needing advanced project management features — resource allocation, workload management, custom dashboards, time tracking — ClickUp remains more capable.

What are Taskade AI agents?

Taskade AI agents are autonomous digital teammates that can reason through problems, execute multi-step workflows, and take real action within your workspace. They come with 22+ built-in tools, persistent memory across conversations, and can be customized with your own data and tool definitions. Unlike simple chatbots, they create tasks, update projects, send emails, and coordinate with other agents.

What AI models does Taskade use?

Taskade provides access to 11+ AI models from OpenAI (GPT-4 and newer), Anthropic (Claude), and Google (Gemini). You can select different models per agent, allowing you to match model strengths to specific tasks.

How do I create a custom AI agent in Taskade?

Use the Agent Builder: define your agent's role and personality, upload relevant documents or connect data sources for training, configure built-in and custom tools, and deploy. The agent inherits Workspace DNA — your organizational context and terminology — automatically.

Does Taskade work offline?

Taskade has limited offline support through its desktop and mobile apps. You can view and edit existing content offline, but AI features and real-time collaboration require an internet connection. If offline access is critical for your workflow, Notion currently offers a more robust offline experience.

Can I build apps with Taskade?

Yes, through Genesis. You can build CRM systems, client portals, booking apps, dashboards, chatbots, landing pages, and more — all from natural language prompts. Published apps receive instant live URLs and serve unlimited users without consuming your AI credits.

Is Taskade good for remote teams?

Yes. Built-in video calls, real-time collaboration, cursor tracking, and presence indicators make Taskade well-suited for remote work. The AI agents can handle async workflows — summarizing conversations, updating project statuses, and routing tasks — which reduces the coordination overhead that remote teams typically face.

Final Verdict

Rating: 4.2 / 5

Taskade is the most ambitious productivity platform in 2026. No other tool in this category offers autonomous AI agents, a no-code app builder, multi-model AI access, and flat team pricing in a single package. The vision is clear: a workspace where AI agents are teammates, not features.

The execution is not flawless. Mobile needs work, databases are basic, and the platform is still maturing compared to decade-old incumbents. But for teams that want to move fast, build tools without developers, and let AI agents handle the repetitive work — Taskade is the best option available at this price point.

Start with the Free plan to explore the interface. When you are ready for real AI agent workflows, the Pro plan at $16/month for your entire team is where the value kicks in.

Self-Hosting LLMs vs Cloud APIs: Cost, Performance & Privacy Compared (2026)

Jangwook Kim — Tue, 07 Apr 2026 06:56:52 +0000

Self-Hosting LLMs vs Cloud APIs: Cost, Performance & Privacy Compared (2026)

The question used to be simple: can you even run a useful LLM locally? In 2026, the answer is definitively yes. Open-weight models like Llama 3.3, Qwen 3, DeepSeek R1, and Mistral Large rival proprietary models on many benchmarks. Consumer GPUs have enough VRAM to run 70B-parameter models. Tools like Ollama make local inference as easy as pulling a Docker image.

But "can" and "should" are different questions. Cloud APIs from OpenAI, Anthropic, and Google keep getting cheaper, faster, and more capable. The real decision in 2026 is not about possibility — it is about economics, performance requirements, and privacy constraints.

This guide breaks down the actual numbers. No hand-waving, no vendor hype — just a practical cost-per-token comparison, hardware requirements, and a framework for deciding which approach fits your workload.

If you are building with AI coding tools specifically, our comparison of the best AI coding agents covers which agents use local vs cloud inference under the hood.

How Cloud API Pricing Works in 2026

Cloud LLM providers charge per token — typically quoted per million input tokens and per million output tokens. The spread between models is enormous, so "cloud API pricing" is not one number.

Current Pricing Snapshot

Prices below are per 1 million tokens as listed on official pricing pages. These change frequently — always verify before making infrastructure decisions.

OpenAI (as of April 2026):

Model	Input (per 1M tokens)	Output (per 1M tokens)
GPT-4.1	$2.00	$8.00
GPT-4.1 mini	$0.40	$1.60
GPT-4.1 nano	$0.10	$0.40
GPT-5	$1.25	$10.00
o3	$2.00	$8.00
o3-mini	$1.10	$4.40
o4-mini	$1.10	$4.40

Anthropic (as of April 2026):

Model	Input (per 1M tokens)	Output (per 1M tokens)
Claude Haiku 4.5	$1.00	$5.00
Claude Sonnet 4.6	$3.00	$15.00
Claude Opus 4.6	$5.00	$25.00

Both providers offer significant discounts through caching and batching. Anthropic's prompt caching reduces input costs by roughly 90% for repeated context. Their Batch API cuts all token costs by 50% for non-real-time workloads. Combined, these optimizations can reduce effective costs by up to 95% for the right use cases.

The takeaway: If you are making occasional API calls or processing under 2 million tokens per day, cloud APIs are almost certainly cheaper than any self-hosted setup. You pay nothing when idle.

The True Cost of Self-Hosting

Self-hosting sounds free after you buy the hardware. It is not. The real cost includes hardware amortization, electricity, cooling, maintenance time, and opportunity cost. Here is what the numbers actually look like.

Hardware Requirements by Model Size

Model Size	Minimum VRAM (Q4 Quantized)	Recommended GPU	[ESTIMATED] GPU Cost
7–8B parameters	6 GB	RTX 4060 Ti (16 GB)	$400–$500
13B parameters	10 GB	RTX 4070 Ti (16 GB)	$700–$800
30–34B parameters	20 GB	RTX 4090 (24 GB)	$1,600–$2,000
70B parameters	40 GB	2× RTX 4090 or RTX 5090 (32 GB)	$2,000–$4,000
70B parameters (FP16)	140 GB	2× A100 (80 GB)	$20,000+
405B parameters	200+ GB	4× A100 or 8× RTX 4090	$50,000+

The RTX 5090, released in January 2025, adds 32 GB of GDDR7 memory with 1.79 TB/s bandwidth — a meaningful upgrade over the RTX 4090's 24 GB and 1.01 TB/s. It delivers roughly 213 tokens/second on 8B models (67% faster than the RTX 4090's 128 tok/s). But at $2,000–$3,800 with limited availability, it is not always easy to buy.

Running Costs

Electricity is often underestimated. A single RTX 4090 under sustained inference load draws 350–450W. At the US average of $0.16/kWh:

24/7 operation: ~$40–$55 per month per GPU
8 hours/day operation: ~$13–$18 per month per GPU

Add $5–$15/month for cooling overhead in most setups. For a dual-GPU rig running 70B models around the clock, expect $90–$130/month in electricity alone.

Amortized Cost Per Token

Here is where the math gets interesting. Assuming a 3-year hardware amortization:

Setup	Hardware Cost	Monthly Amortization	Monthly Electricity	Throughput	Effective Cost per 1M Tokens
RTX 4090 + 8B model (Q4)	$1,800	$50	$45	~330M tokens/day	~$0.009
RTX 5090 + 30B model (Q4)	$3,000	$83	$55	~160M tokens/day	~$0.028
2× RTX 4090 + 70B model (Q4)	$3,600	$100	$90	~80M tokens/day	~$0.079

Compare that to GPT-4.1 mini at $0.40/$1.60 per million tokens, or Claude Haiku 4.5 at $1.00/$5.00. On raw per-token cost at scale, self-hosting wins — but only if your GPUs are actually busy.

The hidden cost of idle hardware: If your workload averages 1 million tokens per day on a rig capable of 300 million, you are paying $95/month in fixed costs for a workload that would cost $1–$5/month on a cloud API.

Self-Hosting Tools: Ollama vs vLLM vs llama.cpp

Three tools dominate the self-hosting landscape in 2026. Each targets a different use case.

Ollama — The Developer's Default

Ollama wraps llama.cpp in a Go-based server with a Docker-like experience. One command pulls and runs models with an OpenAI-compatible API endpoint.

Best for: Development, prototyping, personal use, privacy-focused workflows, air-gapped environments.

Strengths:

Zero-configuration setup — ollama run llama3.3 and you are running
Automatic quantization and GPU detection
OpenAI-compatible API (drop-in replacement in most SDKs)
The 0.17 series (early 2026) added cloud model offloading, web search, multimodal support, streaming tool calls, and thinking models
Native tool calling support for external API integration

Limitations:

Caps at ~4 concurrent requests by default
~62 tok/s on Llama 3.1 8B (Q4_K_M quantization)
Not designed for production-scale multi-user serving

vLLM — The Production Choice

vLLM's PagedAttention engine manages GPU memory like an operating system manages RAM — paging model weights in and out to maximize throughput under concurrent load.

Best for: Production APIs, multi-user serving, high-throughput batch processing.

Strengths:

Continuous batching aggregates concurrent requests into unified GPU operations
~485 total tok/s across 10 concurrent requests on Llama 3.1 8B — 16× more throughput than Ollama under load
Over 35× the request throughput (RPS) compared to llama.cpp at peak load
Speculative decoding support for faster generation
OpenAI-compatible serving endpoint

Limitations:

More complex setup than Ollama
Requires NVIDIA GPUs (no CPU-only mode)
Higher minimum memory overhead

llama.cpp — The Embedded Option

The pure C/C++ inference engine with no external dependencies. It runs everywhere — from data center GPUs to Android phones.

Best for: Embedded applications, edge deployment, mobile devices, maximum hardware compatibility.

Strengths:

Runs on CPU, Apple Silicon, NVIDIA, AMD, and mobile devices
Smallest footprint of the three
4-bit quantization enables Llama 3.2 3B on standard Android devices
Direct library embedding into native applications

Limitations:

No built-in serving layer (you add your own HTTP server)
Lower throughput than vLLM under concurrent load
More manual configuration required

Quick Decision Matrix

Scenario	Recommended Tool
Developer testing locally	Ollama
Team staging server	llama.cpp or Ollama
Production user-facing API	vLLM
Mobile/embedded deployment	llama.cpp
Privacy-first personal assistant	Ollama

For context on how these tools connect to the broader AI tooling ecosystem, see our guide to MCP (Model Context Protocol) — the emerging standard for how AI tools integrate with external services.

Performance: Latency, Throughput, and Quality

Latency

Cloud APIs add network round-trip time — typically 50–200ms before the first token, depending on your location and the provider's infrastructure. Self-hosted models on local hardware start generating in 10–50ms.

For interactive applications where time-to-first-token matters (chat interfaces, code completion, real-time suggestions), local inference has a structural advantage. For batch processing or async workloads, the latency difference is irrelevant.

Throughput

Single-user throughput is comparable. A self-hosted 8B model on an RTX 4090 generates ~128 tokens/second — faster than most cloud API streaming responses.

Multi-user throughput is where cloud APIs pull ahead. OpenAI and Anthropic run inference on massive GPU clusters with load balancing, auto-scaling, and request queuing. Replicating that with self-hosted infrastructure requires significant engineering investment in vLLM configuration, load balancing, and GPU fleet management.

Model Quality

This is the elephant in the room. The best open-weight models in 2026 (Llama 3.3 405B, DeepSeek R1, Qwen 3 235B) are competitive with GPT-4.1 and Claude Sonnet on many benchmarks. But frontier models — GPT-5, Claude Opus 4.6, Gemini Ultra — still lead on complex reasoning, long-context tasks, and instruction following.

If your use case requires frontier-level intelligence, cloud APIs are your only option. If a 70B or 8B model handles your workload well, self-hosting becomes viable.

Privacy and Compliance

This is often the strongest argument for self-hosting — and sometimes the only argument that matters.

When Self-Hosting Is Required

Regulated industries: Healthcare (HIPAA), finance (SOX, PCI-DSS), and government (FedRAMP) may require that patient data, financial records, or classified information never leave your infrastructure.
Data residency: Some jurisdictions require data processing to occur within national borders. Self-hosting on local infrastructure guarantees compliance.
Air-gapped environments: Military, critical infrastructure, and some enterprise environments operate without internet access. Cloud APIs are not an option.
Competitive sensitivity: If your prompts contain proprietary algorithms, trade secrets, or competitive intelligence, sending them to a third-party API introduces risk — even with data processing agreements.

Cloud API Privacy Guarantees

Both OpenAI and Anthropic now offer enterprise tiers with zero-data-retention policies, SOC 2 Type II compliance, and contractual guarantees that API inputs are not used for training. For many organizations, these guarantees are sufficient.

The risk calculus is: do you trust a contractual guarantee, or do you need physical control? The answer depends on your threat model, not on technology.

Our article on what vibe coding is explores how AI-first development workflows handle the security implications of AI-generated code — a related concern when deciding where your AI inference runs.

The Hybrid Approach: Best of Both Worlds

The most cost-effective architecture in 2026 for many teams is hybrid: self-host for predictable baseline load, route to cloud APIs for overflow and frontier model access.

How It Works

Baseline traffic (predictable, high-volume, latency-sensitive) routes to self-hosted models via Ollama or vLLM.
Overflow traffic (demand spikes beyond local GPU capacity) routes to cloud APIs automatically.
Frontier model requests (tasks requiring GPT-5 or Claude Opus-level reasoning) always route to cloud APIs.
Privacy-sensitive requests (containing PII, regulated data, or trade secrets) always route to self-hosted models.

Implementation Pattern

An OpenAI-compatible router sits in front of both your local vLLM instance and cloud API endpoints. Since Ollama, vLLM, and most cloud providers all expose OpenAI-compatible APIs, your application code does not need to change — the router handles model selection based on request metadata, load, and policy rules.

One fintech company reported cutting monthly AI spend from $47,000 to $8,000 (83% reduction) by moving predictable workloads to self-hosted infrastructure while keeping frontier model access through cloud APIs.

Decision Framework: When to Self-Host vs Use Cloud APIs

Use Cloud APIs When:

Your token volume is under 2 million per day
You need frontier model capabilities (GPT-5, Claude Opus)
Your team lacks GPU infrastructure expertise
Your workload is bursty and unpredictable
You want to iterate on models without hardware commitments
Time-to-production matters more than per-token cost

Self-Host When:

Your token volume exceeds 10 million per day consistently
Privacy or compliance requirements mandate on-premise processing
Latency to first token is critical (sub-50ms)
You run an air-gapped or restricted network environment
A 7B–70B open-weight model meets your quality requirements
You have (or can hire) infrastructure expertise to maintain the setup

Go Hybrid When:

You process 3–10 million tokens per day with variable load
You need both frontier models and privacy guarantees
You want cost optimization without sacrificing capability
You are building a product that serves multiple use cases with different requirements

Break-Even Analysis

The break-even point depends heavily on which cloud model you are replacing and which local model you are running. Here are representative scenarios:

Scenario	Daily Volume	Cloud Cost/Month	Self-Host Cost/Month	Break-Even
Replace GPT-4.1 mini with local 8B	5M tokens/day	~$300	~$95 (RTX 4090)	Month 8
Replace Claude Haiku with local 8B	5M tokens/day	~$450	~$95 (RTX 4090)	Month 5
Replace GPT-4.1 with local 70B	10M tokens/day	~$1,500	~$190 (2× RTX 4090)	Month 3
Replace Claude Sonnet with local 70B	10M tokens/day	~$2,700	~$190 (2× RTX 4090)	Month 2

[ESTIMATED] These figures assume sustained daily volumes and standard (non-cached, non-batched) cloud API pricing. Real-world costs vary based on input/output token ratios, caching utilization, and hardware availability.

For medium-usage teams processing 3–5 million tokens per day, local deployment on consumer hardware typically reaches break-even against cloud API pricing in roughly 3–8 months, depending on which cloud model you are replacing.

Getting Started: Practical First Steps

If you are exploring self-hosting for the first time:

Install Ollama (curl -fsSL https://ollama.com/install.sh | sh) and run a small model (ollama run llama3.2).
Test it against your actual workload — not benchmarks, your real prompts.
Compare output quality honestly against the cloud model you are considering replacing.
If quality is acceptable, measure your actual daily token volume for a week.
Run the break-even math with your numbers.

If you are scaling to production:

Deploy vLLM with your chosen model on GPU infrastructure.
Set up an OpenAI-compatible routing layer.
Start with cloud-only, then gradually shift predictable traffic to self-hosted.
Monitor quality, latency, and cost continuously.

If you are using AI tools in your development workflow, our guide on how to use Claude Code covers practical workflows for AI-assisted coding — whether the models run locally or in the cloud.

The Bottom Line

Self-hosting LLMs in 2026 is mature, practical, and cost-effective — at the right scale. The tools are production-ready. The models are capable. The hardware is accessible.

But cloud APIs are also better and cheaper than ever. The 4.5/4.6 generation of Claude models represents a 67% cost reduction over previous generations. OpenAI's GPT-4.1 nano costs $0.10 per million input tokens. At low to moderate volumes, cloud APIs win on total cost of ownership because you never pay for idle hardware.

The right answer for most teams in 2026 is not "self-host everything" or "use cloud for everything." It is a deliberate hybrid architecture that routes each request to the most cost-effective and appropriate inference backend based on volume, quality requirements, privacy constraints, and latency needs.

Start with cloud APIs. Measure your actual usage. When the numbers justify it — and only then — add self-hosted infrastructure for your predictable, high-volume workloads. Keep cloud access for frontier models and demand spikes. That is the architecture that optimizes for cost, capability, and flexibility simultaneously.

Best AI Testing Tools 2026: Developer Guide to Automated QA

Jangwook Kim — Tue, 07 Apr 2026 06:56:50 +0000

Best AI Testing Tools 2026: Developer Guide to Automated QA

Software testing is changing faster than any other part of the development workflow. In 2024, "AI testing" mostly meant auto-generated unit tests and flaky Selenium scripts patched with retry logic. In 2026, we have agentic testers that navigate your application autonomously, self-healing tests that survive UI redesigns without human intervention, and AI-powered visual validation that catches regressions the human eye would miss.

The shift matters because traditional test automation has a well-known scaling problem: as your application grows, test maintenance costs grow faster. Teams end up spending more time fixing broken tests than writing new features. Self-healing tests and agentic QA directly attack this problem by reducing the maintenance burden — sometimes dramatically.

This guide compares the leading AI testing tools available in 2026, focusing on what developers actually care about: how well the AI works, how it fits into CI/CD pipelines, and whether it actually reduces the time you spend on QA. No affiliate links — just a practical comparison based on publicly available features and documentation.

For related tooling comparisons, see our guide to the best AI code review tools in 2026 and our comprehensive AI coding agents comparison.

What Changed in AI Testing for 2026

Before diving into individual tools, it helps to understand the three major shifts that define AI testing in 2026:

Agentic Testing

Instead of recording test scripts step-by-step, agentic testers accept natural language goals — like "verify a user can complete checkout" — and figure out the navigation path themselves. This is fundamentally different from traditional record-and-playback automation because the AI adapts to UI changes without brittle selectors.

Self-Healing Tests

Self-healing goes beyond simple locator fallbacks. Modern tools use multi-attribute element tracking, visual recognition, and semantic understanding to maintain test stability even when the DOM structure changes significantly. The best implementations distinguish between intentional UI changes (which should update the test) and bugs (which should fail the test).

MCP and IDE Integration

Several tools now support Model Context Protocol (MCP) servers, embedding testing capabilities directly into your IDE and AI coding assistant. This means you can generate, run, and debug tests without leaving your editor — a significant workflow improvement. For more on MCP, see our MCP explainer.

The Contenders

Tool	Primary Strength	Self-Healing	Free Tier	Starting Price
TestSprite	Autonomous agentic testing	Yes	150 credits/mo	$19/mo (Starter)
Mabl	Enterprise self-healing QA	Yes (Adaptive Auto-Healing)	14-day trial	Custom pricing
Qase AIDEN	AI test management + generation	Via agentic mode	Included in paid plans	Credit-based ($0.40/credit overage)
Katalon	All-in-one test platform	AI-assisted	Free plan available	From $84/mo (new customer promo)
Applitools	Visual AI regression testing	N/A (visual focus)	100 checkpoints/mo	Custom pricing

TestSprite

TestSprite is a pure agentic testing platform — it generates, executes, and analyzes test cases without manual scripting. You point it at your application, and the AI handles the rest: crawling your UI, identifying test scenarios, running tests across browsers, and classifying failures.

How It Works

TestSprite's AI agent reads your application's UI, generates test cases covering user journeys, then executes them in the cloud. When tests fail, the platform classifies failures into categories — broken dependency, slow page load, application bug, or selector change — and suggests specific fixes. It also supports scheduled re-verification to catch regressions continuously.

Key Features

One-click full-stack coverage — Simultaneously generates frontend and backend tests from a single entry point. No manual test case writing required.
MCP Server integration — TestSprite offers an MCP server that plugs directly into your IDE and coding assistant. It reads your product requirements, analyzes your codebase, and generates tests within your development workflow.
Intelligent failure classification — Rather than just reporting "test failed," TestSprite categorizes failures and suggests fixes. This reduces triage time significantly.
Visual test editor — Edit test interactions through a visual interface. Useful for non-technical team members who need to adjust test flows without touching code.
Scheduled monitoring — Automatically re-runs tests on a schedule to detect regressions between deployments.

Pricing

Free: 150 credits/month
Starter: $19/month (400 credits)
Standard: $69/month (1,600 credits)
Enterprise: Custom pricing

Credits are consumed per test action, but TestSprite does not publish a detailed credit-per-action breakdown. This makes cost prediction difficult before you start using the platform — request a demo to understand credit consumption for your specific test volume.

Best For

Teams building with AI coding tools (like Claude Code or vibe coding workflows) who want automated test coverage without writing test scripts. The MCP integration makes it particularly appealing for developers already using AI coding assistants.

Mabl

Mabl is the most established AI-native testing platform in this category. It combines browser-based test recording with AI-powered auto-healing, making it a strong choice for teams that need enterprise reliability and deep CI/CD integration. Mabl covers web, mobile, and API testing from a single platform.

How It Works

You create tests by recording browser interactions or writing them in Mabl's low-code editor. Once created, Mabl's AI continuously monitors tests and automatically heals them when UI changes break selectors. The platform uses multiple ML models to track elements across attributes — not just a single ID or class name — so tests survive refactors that would break traditional Selenium scripts.

Key Features

Adaptive Auto-Healing — Mabl's headline feature. It uses a combination of machine learning and GenAI to autonomously update tests when UI elements change. The platform claims to reduce test maintenance by up to 85%.
Multi-model AI approach — Combines traditional ML element tracking with GenAI visual element identification. This hybrid approach handles scenarios where DOM locators are scarce or unreliable.
AI Vectorization — Creates semantic embeddings across all test assets, enabling discovery of duplicate tests, coverage gaps, and Test Impact Analysis. This is useful for large test suites where teams lose track of what is already covered.
Unified platform — Web, mobile, API, and accessibility testing in one tool. Reduces the need to stitch together multiple testing services.
Native CI/CD integration — Integrates with GitHub Actions, Jenkins, CircleCI, GitLab CI, Azure DevOps, and other major CI/CD platforms out of the box.

Pricing

Mabl uses custom pricing — you need to request a quote. There is a 14-day free trial to evaluate the platform. Based on public reports, Mabl is positioned as an enterprise tool and pricing reflects that: expect it to cost significantly more than TestSprite or Katalon's entry plans.

Best For

Mid-to-large engineering teams with existing test suites that suffer from maintenance overhead. Mabl is particularly strong when you need to maintain hundreds of UI tests across frequent releases and want the AI to handle the breakage automatically. If your team already does browser-based test recording but spends too much time fixing broken selectors, Mabl directly addresses that pain point.

Qase AIDEN

Qase is primarily a test management platform — think of it as the Jira of QA. AIDEN is Qase's AI layer that adds test generation, automated conversion, and agentic execution on top of the management features. This combination is unique: instead of being a standalone AI testing tool, AIDEN enhances your existing test management workflow.

How It Works

AIDEN operates in several modes. In Agentic Mode, you describe a goal in natural language — "Verify a user can purchase shoes on our marketplace" — and AIDEN breaks it into actionable steps, executes them against your application, takes screenshots at each step, and generates test code in your preferred language. For existing manual test cases, AIDEN reviews them for automation readiness, highlights missing data or unclear steps, and converts them to automated scripts.

Key Features

Agentic Mode — Natural language to automated test execution. AIDEN interprets your goal, navigates the application, and provides visual feedback (screenshots) for every action.
Smart test conversion — Reviews manual test cases and converts them to automated scripts. For parameterized tests, AIDEN identifies the data structure, extracts input combinations, and generates individual execution instances automatically.
Canvas UI testing — AIDEN now supports Canvas-based UIs, interpreting visual elements within HTML canvas just like standard DOM elements. This opens up testing for complex visual applications (diagram editors, design tools, games) that traditional automation tools cannot handle.
MCP Server integration — Qase offers an MCP server that connects AI assistants to your testing system, bringing test generation into the development workflow.
Built into all paid plans — No separate purchase required. AIDEN credits are included in every Qase paid subscription.

Pricing

AIDEN is available on all Qase paid plans via a credit system. Each plan includes a monthly credit allowance. Overage credits cost $0.40 each. Credits do not roll over. You can set a monthly spending cap to prevent unexpected charges.

Qase's Startup plan includes 500 AIDEN credits per month. Business and Enterprise credit allocations vary — check Qase's pricing page for current details.

Best For

Teams that need both test management and AI-powered test generation in one platform. If your organization already tracks test cases manually and wants to automate them gradually, Qase + AIDEN provides a smoother migration path than adopting a standalone AI testing tool. The Canvas UI testing support also makes it a strong pick for teams building visual applications.

Katalon

Katalon is an all-in-one test automation platform that bridges the gap between no-code test recording and full scripting. It covers web, mobile, desktop, and API testing — making it the broadest platform in this comparison. Katalon has added AI features (branded as TrueTest) to its established automation capabilities.

How It Works

Katalon provides both a low-code recorder and a full scripting IDE (based on Groovy/Java). Tests can be created visually, then extended with code when needed. TrueTest, Katalon's AI feature, records real user interactions in production to generate regression tests automatically — an approach that ensures your tests reflect actual user behavior rather than imagined scenarios.

Key Features

TrueTest AI regression testing — Uses AI to observe real user sessions and generate automated test scripts from them. This produces tests that cover actual user paths rather than developer assumptions about how the application is used.
Dual-mode authoring — Start with no-code recording, then drop into code when you need more control. This makes Katalon accessible to QA engineers who don't code heavily while still supporting developers who want full scripting power.
Cross-platform coverage — Web, mobile, desktop, and API testing from one tool. Few competitors match this breadth.
AI visual testing — Built-in visual regression testing powered by AI, though less sophisticated than Applitools' dedicated visual AI.
Self-healing via StealthMode — Katalon's AI-powered element locator strategy attempts to identify elements through multiple attributes. Not as advanced as Mabl's auto-healing, but functional for routine UI changes.

Pricing

Free: Basic automation for individuals/small teams
Premium: $84/month per user (billed annually at $1,000/year promo for new customers; regular price $229/month)
Ultimate: Custom pricing for enterprise features

Katalon's pricing is per-user, which can add up quickly for larger teams. The free plan is genuinely useful for small projects or learning the platform.

Best For

Teams that want a single platform covering all testing types (web, mobile, API, desktop) and prefer a gradual transition from manual to automated testing. Katalon is the most pragmatic choice if you need broad coverage without committing to a specialized AI-first tool. The TrueTest feature is particularly valuable for teams that want to generate tests from real user behavior rather than writing them from scratch.

Applitools

Applitools takes a different approach from every other tool on this list: it focuses exclusively on visual testing. Rather than generating or healing functional test scripts, Applitools uses Visual AI to detect visual regressions — layout shifts, missing elements, color changes, responsive breakdowns — that functional tests typically miss entirely.

How It Works

Applitools integrates with your existing test framework (Selenium, Cypress, Playwright, Appium, or any major automation tool). You add visual checkpoints to your tests, and Applitools' AI compares screenshots against baselines. The Visual AI mimics human perception: it ignores irrelevant pixel-level differences (like anti-aliasing) while catching meaningful visual changes.

Key Features

Visual AI engine — Applitools' core technology. It understands visual intent rather than comparing pixels. This dramatically reduces false positives compared to traditional screenshot diffing.
Ultrafast Grid — Parallelized cross-browser and cross-device rendering. Run visual tests across dozens of browser/viewport combinations without maintaining separate browser farms.
Autonomous testing — Applitools Autonomous combines visual and functional testing with AI-driven test creation, expanding beyond pure visual regression.
Root Cause Analysis — AI-powered analysis that identifies the underlying cause of visual differences (CSS change, DOM structure change, content change), helping developers fix issues faster.
Framework agnostic — Works with Selenium, Cypress, Playwright, Appium, Storybook, and more. It layers on top of whatever automation framework you already use.

Pricing

Free: 100 visual checkpoints/month (permanently free)
Paid tiers: Custom pricing based on test units. Contact Applitools for quotes.

Pricing uses a "test unit" model. In Autonomous mode, monthly active tests count against units; in Eyes mode, pages count against units. Test units are interchangeable between products.

Best For

Teams that already have functional test automation but keep getting bitten by visual regressions — broken layouts, missing CSS, responsive issues. Applitools doesn't replace your existing test framework; it augments it with a visual safety net. Particularly valuable for design-heavy applications, component libraries, and teams practicing vibe coding where rapid UI changes need continuous visual validation.

How to Choose: Decision Framework

The "best" tool depends on your specific situation. Here is a practical decision framework:

You have no existing test automation

Start with TestSprite or Qase AIDEN. Both offer agentic approaches that generate tests from scratch without requiring you to write scripts. TestSprite is more autonomous (point-and-generate), while Qase AIDEN gives you better test management infrastructure alongside the AI.

You have existing tests that keep breaking

Choose Mabl. Its Adaptive Auto-Healing is purpose-built for this problem. Mabl's multi-model AI approach to element tracking is the most sophisticated self-healing implementation available. If your team spends more time maintaining tests than writing features, Mabl pays for itself in maintenance reduction.

You need to cover web, mobile, API, and desktop

Choose Katalon. No other tool on this list matches its breadth of platform coverage. The TrueTest feature for generating tests from real user behavior is a bonus. Katalon is the pragmatic choice when you need one tool that does everything adequately rather than one tool that does one thing exceptionally.

Your functional tests pass but users report visual bugs

Add Applitools to your existing test suite. It layers on top of whatever framework you use and catches the category of bugs that functional assertions miss entirely. The free tier with 100 checkpoints/month is enough to evaluate whether visual AI testing catches real issues for your application.

You are building with AI coding tools and want testing in your IDE

TestSprite or Qase AIDEN with MCP integration. Both offer MCP servers that plug testing into your development workflow alongside your AI coding agent. This is particularly relevant for developers using Claude Code or similar tools where the IDE is the primary working environment.

CI/CD Integration Comparison

All five tools integrate with major CI/CD platforms, but the depth varies:

Tool	GitHub Actions	Jenkins	GitLab CI	Azure DevOps	API/CLI
TestSprite	Yes	Yes	Yes	Yes	REST API
Mabl	Native	Native	Native	Native	CLI + API
Qase AIDEN	Via API	Via API	Via API	Via API	REST API
Katalon	Plugin	Plugin	Plugin	Plugin	CLI (katalon)
Applitools	SDK-based	SDK-based	SDK-based	SDK-based	Eyes SDK

Mabl has the deepest native CI/CD integration — it was designed as a CI/CD-first platform. Applitools integrates at the SDK level through your existing test framework, which means CI/CD integration depends on your underlying automation tool. TestSprite and Qase focus more on API-driven integration.

Self-Healing: How the Approaches Differ

Self-healing is a headline feature for several tools, but implementations vary significantly:

Mabl uses multi-attribute element tracking combined with GenAI visual identification. It maintains a history of how elements change over time and uses that context to make healing decisions. This is the most mature implementation.

TestSprite takes an agentic approach — rather than healing fixed scripts, it regenerates test paths autonomously. When the UI changes, TestSprite re-navigates the application rather than patching selectors. This is a fundamentally different philosophy: instead of healing the old test, it creates a new path to the same goal.

Katalon offers StealthMode locator strategies that try multiple element identification approaches, but this is closer to "resilient locators" than true self-healing. It works for routine changes but may struggle with significant UI refactors.

Qase AIDEN handles UI changes through its agentic mode — like TestSprite, it navigates based on goals rather than fixed element paths. The distinction is that AIDEN is more focused on test generation and management, while TestSprite is built specifically for autonomous execution.

What AI Testing Tools Cannot Do (Yet)

These tools are impressive, but it is important to understand their limitations:

Complex business logic validation — AI testers excel at UI navigation and visual checks but struggle with deeply contextual business rules. A test that verifies "order total includes the correct tax rate for the user's jurisdiction after applying a coupon with a minimum spend requirement" still needs human-authored assertions.
Performance testing at scale — While some tools offer basic performance checks (page load times, response times), none replace dedicated performance testing tools for load testing or stress testing scenarios.
Security testing — AI testing tools focus on functional and visual correctness. They are not substitutes for security scanning tools, penetration testing, or SAST/DAST analysis.
Edge cases from domain expertise — The AI generates tests based on observable UI patterns. It cannot know about edge cases that require domain expertise ("what happens when a user's subscription expires mid-checkout during a timezone transition?"). These still need manual test design.

Getting Started

If you are new to AI-powered testing, here is a practical starting path:

Pick one tool and one application. Do not try to evaluate all five tools simultaneously. Choose the one that best matches your primary pain point from the decision framework above.
Start with a critical user journey. Choose your application's most important flow (signup, checkout, core feature) and use the AI tool to generate tests for that flow. This gives you a concrete baseline for evaluating the tool's accuracy and usefulness.
Integrate with CI/CD early. The value of AI testing compounds when tests run automatically on every push. Set up the CI/CD integration in your first week, not after you have a full test suite.
Compare AI-generated tests against your existing tests. If you have manual test cases, compare what the AI generates against what your team wrote. Where the AI misses things, you learn the tool's limitations. Where the AI catches things your team missed, you find immediate value.
Measure maintenance time, not just coverage. The primary value proposition of AI testing is reduced maintenance, not higher coverage numbers. Track how many tests break per release and how long they take to fix — that is the metric that determines ROI.

For teams already using AI in other parts of the development workflow — AI coding agents, AI code review, AI-first IDEs — adding AI testing is the logical next step toward a fully AI-augmented development pipeline.

Conclusion

AI testing tools in 2026 have moved well beyond the experimental phase. TestSprite and Qase AIDEN represent the agentic future — tools that generate and execute tests autonomously from natural language goals. Mabl leads in self-healing reliability for teams with established test suites. Katalon provides the broadest platform coverage for teams that need one tool to rule them all. And Applitools remains unmatched for visual regression testing.

The common thread across all these tools: they reduce the maintenance burden that makes traditional test automation unsustainable at scale. Whether you are starting from zero or drowning in flaky tests, the right AI testing tool can fundamentally change your team's relationship with QA.

Choose based on your biggest pain point, start with a focused evaluation, and measure maintenance reduction — not just test count. That is how you find real value in AI-powered testing.

Build Your First Multi-Agent System with OpenAI Agents SDK — Step-by-Step Python Tutorial (2026)

Jangwook Kim — Sun, 05 Apr 2026 15:06:29 +0000

Build Your First Multi-Agent System with OpenAI Agents SDK — Step-by-Step Python Tutorial (2026)

You have heard the buzz around AI agents. You have probably built a single-agent chatbot. But real-world automation needs multiple agents working together — one to research, one to write, one to review and catch mistakes.

The OpenAI Agents SDK makes this surprisingly straightforward. In this tutorial, you will build a complete multi-agent content pipeline: a Research Agent gathers information, a Writer Agent drafts content, and a Reviewer Agent validates quality with guardrails. All orchestrated through handoffs, running in under 100 lines of core logic.

By the end, you will understand every building block — Agent, Runner, Handoff, and Guardrails — and have a working system you can adapt to your own projects.

What you will build: A three-agent content pipeline where agents hand off work to each other automatically. The Research Agent finds information, the Writer Agent creates a draft, and the Reviewer Agent enforces quality standards using guardrails.

What Is the OpenAI Agents SDK?

The OpenAI Agents SDK is an open-source Python framework for building multi-agent AI systems. Originally developed as a successor to the experimental Swarm library, it provides production-ready primitives for creating agents that can use tools, delegate work to each other, and enforce safety checks — all with minimal boilerplate.

Key characteristics:

Feature	Detail
Language	Python (3.10+)
Current version	0.13.4 (April 2026)
License	MIT
LLM support	OpenAI models natively, 100+ models via LiteLLM
Core primitives	Agent, Runner, Handoff, Guardrails, Tools
Install size	Lightweight — Pydantic and Requests as main dependencies

Unlike heavier frameworks that require you to learn complex graph abstractions, the OpenAI Agents SDK keeps things Pythonic. You define agents as objects, wire them together with handoffs, and run them with a single Runner.run() call.

If you have worked with the LangGraph framework (covered in our previous tutorial), the Agents SDK takes a different philosophy: less explicit graph construction, more implicit orchestration through handoffs and tool calls.

Prerequisites

Before we start building, make sure you have:

Python 3.10 or higher (the SDK requires 3.10+, supports up to 3.14)
An OpenAI API key with access to GPT-4o or later models
Basic Python knowledge — functions, classes, async/await
A terminal and a code editor

Installation

Create a project directory and set up a virtual environment:

mkdir multi-agent-pipeline && cd multi-agent-pipeline
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Install the SDK with a pinned version:

pip install openai-agents==0.13.4

Create a requirements.txt for reproducibility:

openai-agents==0.13.4
pydantic>=2.0

API Key Setup

Set your OpenAI API key as an environment variable:

export OPENAI_API_KEY="sk-your-key-here"

Or create a .env file (never commit this to version control):

OPENAI_API_KEY=sk-your-key-here

Cost note: This tutorial uses gpt-4o-mini for most agents to keep costs low. A full pipeline run typically consumes 3,000–8,000 tokens. At current pricing (approximately $0.15 per 1M input tokens and $0.60 per 1M output tokens for gpt-4o-mini), each run costs well under $0.01. We break down real costs in the cost analysis section below.

Core Concepts: Agent, Runner, Handoff, Guardrails

Before writing code, let us understand the four building blocks. These are the only concepts you need to build sophisticated multi-agent systems.

Agent

An Agent is an LLM equipped with instructions and tools. Think of it as a specialized worker with a clear job description.

from agents import Agent

research_agent = Agent(
    name="Research Agent",
    instructions="You are a research specialist. Find accurate, up-to-date information on any topic.",
    model="gpt-4o-mini",
)

Key parameters:

name — Human-readable identifier
instructions — The system prompt that defines the agent's behavior
model — Which LLM to use
tools — Functions the agent can call
handoffs — Other agents it can delegate to
output_type — Pydantic model for structured output

Runner

The Runner executes agents. It manages the agent loop: call the LLM, process tool calls, handle handoffs, and repeat until the agent produces a final output.

from agents import Runner

result = Runner.run_sync(research_agent, "What is retrieval-augmented generation?")
print(result.final_output)

Three execution modes:

Method	Use case
`Runner.run()`	Async execution (recommended for production)
`Runner.run_sync()`	Synchronous wrapper (simpler for scripts)
`Runner.run_streamed()`	Async with streaming events

Handoff

A Handoff lets one agent delegate work to another. Under the hood, handoffs appear as tools to the LLM — when the triage agent decides to hand off to the writer, it calls a transfer_to_writer_agent tool.

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route research requests to the Research Agent, writing tasks to the Writer Agent.",
    handoffs=[research_agent, writer_agent],
)

Guardrails

Guardrails validate inputs and outputs. They can run in parallel with agent execution (for speed) or block execution until validation passes (for safety).

from agents import input_guardrail, GuardrailFunctionOutput

@input_guardrail
async def check_topic_safety(ctx, agent, input):
    # Validate the input before the agent processes it
    result = ...  # Your validation logic
    return GuardrailFunctionOutput(
        output_info={"safe": True},
        tripwire_triggered=False,
    )

Project Structure

Here is what we are building:

multi-agent-pipeline/
├── requirements.txt
├── agents/
│   ├── __init__.py
│   ├── research_agent.py
│   ├── writer_agent.py
│   └── reviewer_agent.py
├── tools/
│   ├── __init__.py
│   └── search_tools.py
├── guardrails/
│   ├── __init__.py
│   └── quality_checks.py
├── main.py
└── run_pipeline.py

Let us build each piece step by step.

Building Agent #1: The Research Agent

The Research Agent's job is to gather information on a given topic. We will give it a web search tool and structured output so downstream agents get clean data.

Define the Output Schema

First, define what the Research Agent should return:

# agents/research_agent.py
from pydantic import BaseModel, Field
from agents import Agent, function_tool


class ResearchResult(BaseModel):
    """Structured output from the Research Agent."""
    topic: str = Field(description="The researched topic")
    summary: str = Field(description="A 2-3 paragraph summary of findings")
    key_facts: list[str] = Field(description="5-8 key facts discovered")
    sources_note: str = Field(description="Note about information sources and currency")

Create the Search Tool

The Research Agent needs a tool to search for information. Here we create a simulated search tool — in production, you would connect this to a real search API:

# tools/search_tools.py
from agents import function_tool


@function_tool
def web_search(query: str) -> str:
    """Search the web for information on a given query.

    Args:
        query: The search query to look up.
    """
    # In production, connect to a real search API (Brave, Serper, Tavily, etc.)
    # For this tutorial, the agent will use its training knowledge
    # and note that results should be verified.
    return (
        f"Search results for: '{query}'\n"
        f"Note: In production, this would return real search results. "
        f"The agent should use its knowledge and clearly mark any claims "
        f"that need verification."
    )


@function_tool
def save_research_notes(topic: str, notes: str) -> str:
    """Save research notes for a topic.

    Args:
        topic: The topic being researched.
        notes: The research notes to save.
    """
    # In production, persist to a database or file
    return f"Research notes saved for topic: {topic}"

Assemble the Research Agent

# agents/research_agent.py (continued)
from tools.search_tools import web_search, save_research_notes

research_agent = Agent(
    name="Research Agent",
    instructions="""You are an expert research analyst. Your job is to gather
accurate, comprehensive information on any given topic.

Rules:
- Search for the topic using the web_search tool
- Compile findings into a structured format
- Include 5-8 key facts with specific details
- Note the currency and reliability of information
- If you cannot verify a claim, mark it as [UNVERIFIED]
- Never fabricate statistics or quotes""",
    model="gpt-4o-mini",
    tools=[web_search, save_research_notes],
    output_type=ResearchResult,
)

Test It Standalone

from agents import Runner

result = Runner.run_sync(
    research_agent,
    "Research the current state of multi-agent AI systems in 2026"
)
print(f"Topic: {result.final_output.topic}")
print(f"Summary: {result.final_output.summary}")
for fact in result.final_output.key_facts:
    print(f"  • {fact}")

Pro tip: Using output_type=ResearchResult forces the agent to return a Pydantic model instead of free text. This is critical for multi-agent pipelines — downstream agents receive predictable, typed data instead of parsing unstructured strings. The SDK handles JSON schema generation and validation automatically.

Building Agent #2: The Writer Agent

The Writer Agent takes research output and produces a well-structured draft. It receives the Research Agent's structured output as its input context.

Define the Writer Output

# agents/writer_agent.py
from pydantic import BaseModel, Field
from agents import Agent


class WriterOutput(BaseModel):
    """Structured output from the Writer Agent."""
    title: str = Field(description="Article title")
    draft: str = Field(description="The full article draft in markdown")
    word_count: int = Field(description="Approximate word count")
    sections: list[str] = Field(description="List of section headings used")

Assemble the Writer Agent

# agents/writer_agent.py (continued)

writer_agent = Agent(
    name="Writer Agent",
    instructions="""You are a skilled technical writer. Your job is to take
research findings and produce a well-structured, engaging article draft.

Rules:
- Write in a clear, practical tone suitable for developers
- Use markdown formatting with proper headings (##, ###)
- Include code examples where relevant
- Target 800-1200 words for the draft
- Structure: Introduction → Main Sections → Practical Takeaways → Conclusion
- Never fabricate quotes, statistics, or case studies
- If the research notes something as [UNVERIFIED], keep that marker""",
    model="gpt-4o-mini",
    output_type=WriterOutput,
)

Notice the Writer Agent has no tools — it is a pure text generation agent. Not every agent needs tools. The Writer focuses entirely on transforming structured research into polished prose.

Building Agent #3: The Reviewer Agent with Guardrails

The Reviewer Agent is our quality gate. It checks the draft for accuracy, completeness, and quality issues. This is where guardrails shine.

Define Quality Check Guardrails

# guardrails/quality_checks.py
from agents import output_guardrail, GuardrailFunctionOutput


@output_guardrail
async def check_no_fabrication(ctx, agent, output):
    """Check that the output does not contain fabricated data markers."""
    draft_text = output.draft if hasattr(output, 'draft') else str(output)

    fabrication_markers = [
        "according to a study",  # vague attribution without source
        "research shows that 99%",  # suspicious round statistics
        "as John Smith, CEO",  # likely fabricated quotes
    ]

    issues = []
    for marker in fabrication_markers:
        if marker.lower() in draft_text.lower():
            issues.append(f"Potential fabrication detected: '{marker}'")

    return GuardrailFunctionOutput(
        output_info={"issues": issues, "passed": len(issues) == 0},
        tripwire_triggered=len(issues) > 0,
    )


@output_guardrail
async def check_minimum_length(ctx, agent, output):
    """Ensure the draft meets minimum word count."""
    draft_text = output.draft if hasattr(output, 'draft') else str(output)
    word_count = len(draft_text.split())

    return GuardrailFunctionOutput(
        output_info={"word_count": word_count, "minimum": 200},
        tripwire_triggered=word_count < 200,
    )

Define the Review Output

# agents/reviewer_agent.py
from pydantic import BaseModel, Field
from agents import Agent
from guardrails.quality_checks import check_no_fabrication, check_minimum_length


class ReviewResult(BaseModel):
    """Structured output from the Reviewer Agent."""
    approved: bool = Field(description="Whether the draft passes review")
    score: int = Field(description="Quality score from 1-10")
    feedback: list[str] = Field(description="List of feedback items")
    final_draft: str = Field(description="The approved or revised draft")

Assemble the Reviewer Agent

# agents/reviewer_agent.py (continued)

reviewer_agent = Agent(
    name="Reviewer Agent",
    instructions="""You are a meticulous content reviewer and editor. Your job
is to evaluate article drafts for quality, accuracy, and completeness.

Review checklist:
1. Factual accuracy — flag any claims that seem unsupported
2. Structure — verify logical flow and proper headings
3. Completeness — ensure the topic is covered adequately
4. Tone — confirm it matches a practical, developer-friendly style
5. No fabrication — reject any invented statistics, quotes, or case studies

Scoring guide:
- 8-10: Approve with minor notes
- 5-7: Needs revision, provide specific feedback
- 1-4: Reject, major issues found

If approved, return the draft as-is in final_draft.
If revisions are needed, apply them yourself and return the improved version.""",
    model="gpt-4o-mini",
    output_type=ReviewResult,
    output_guardrails=[check_no_fabrication, check_minimum_length],
)

Pro tip: Output guardrails run after the agent produces its result but before it is returned to your code. If a guardrail trips, the SDK raises OutputGuardrailTripwireTriggered, giving you a chance to handle the failure programmatically. This is different from input guardrails, which can run in parallel with the agent for lower latency.

Orchestrating Multi-Agent Handoffs

Now we connect all three agents. There are two patterns for this, and we will show both.

Pattern 1: Handoffs (Delegation Chain)

With handoffs, each agent delegates to the next. The Research Agent hands off to the Writer, who hands off to the Reviewer.

# main.py — Handoff pattern
from agents import Agent, Runner, handoff

from agents.research_agent import research_agent, ResearchResult
from agents.writer_agent import writer_agent
from agents.reviewer_agent import reviewer_agent


# Wire up handoffs: Research → Writer → Reviewer
research_agent_with_handoff = Agent(
    name="Research Agent",
    instructions=research_agent.instructions + """

After completing your research, hand off to the Writer Agent
with your findings so they can draft the article.""",
    model="gpt-4o-mini",
    tools=research_agent.tools,
    handoffs=[writer_agent],
)

writer_agent_with_handoff = Agent(
    name="Writer Agent",
    instructions=writer_agent.instructions + """

After completing the draft, hand off to the Reviewer Agent
for quality review.""",
    model="gpt-4o-mini",
    handoffs=[reviewer_agent],
)


def run_with_handoffs(topic: str):
    """Run the full pipeline using the handoff pattern."""
    result = Runner.run_sync(
        research_agent_with_handoff,
        f"Research and produce an article about: {topic}",
        max_turns=30,
    )
    print(f"Final agent: {result.last_agent.name}")
    print(f"Output: {result.final_output}")
    return result

Pattern 2: Agents as Tools (Orchestrator)

With the orchestrator pattern, a manager agent calls specialist agents as tools:

# main.py — Orchestrator pattern
from agents import Agent, Runner


orchestrator = Agent(
    name="Content Pipeline Orchestrator",
    instructions="""You manage a content production pipeline. For any topic:

1. First, use the research tool to gather information
2. Then, use the writing tool to produce a draft from the research
3. Finally, use the review tool to check quality

Pass the full output from each step to the next tool.
Return the final reviewed draft to the user.""",
    model="gpt-4o-mini",
    tools=[
        research_agent.as_tool(
            tool_name="research_topic",
            tool_description="Research a topic and return structured findings with key facts.",
        ),
        writer_agent.as_tool(
            tool_name="write_draft",
            tool_description="Write an article draft based on provided research findings.",
        ),
        reviewer_agent.as_tool(
            tool_name="review_draft",
            tool_description="Review an article draft for quality, accuracy, and completeness.",
        ),
    ],
)


def run_with_orchestrator(topic: str):
    """Run the full pipeline using the orchestrator pattern."""
    result = Runner.run_sync(
        orchestrator,
        f"Produce a reviewed article about: {topic}",
        max_turns=15,
    )
    print(f"Output: {result.final_output}")
    return result

Which Pattern Should You Use?

Aspect	Handoffs	Agents as Tools
Control	Each agent decides when to hand off	Orchestrator controls flow
Visibility	Active agent changes mid-run	Orchestrator sees all outputs
Best for	Linear pipelines, customer service routing	Complex coordination, parallel tasks
Guardrails	Input on first agent, output on last	Can apply at orchestrator level
Debugging	Follow the handoff chain	Check orchestrator's tool calls

For our content pipeline, the orchestrator pattern gives more control since we want to pass structured data between steps. The handoff pattern works better for conversational routing where you do not know the path in advance.

Putting It All Together: The Run Script

Here is the complete pipeline using the orchestrator pattern:

# run_pipeline.py
import asyncio
from agents import Agent, Runner, function_tool
from pydantic import BaseModel, Field


# ── Output Schemas ──────────────────────────────

class ResearchResult(BaseModel):
    topic: str = Field(description="The researched topic")
    summary: str = Field(description="2-3 paragraph summary")
    key_facts: list[str] = Field(description="5-8 key facts")


class ReviewResult(BaseModel):
    approved: bool
    score: int = Field(ge=1, le=10)
    feedback: list[str]
    final_draft: str


# ── Tools ───────────────────────────────────────

@function_tool
def web_search(query: str) -> str:
    """Search the web for current information.

    Args:
        query: The search query.
    """
    return f"Results for '{query}': Use your knowledge and mark unverified claims."


# ── Agents ──────────────────────────────────────

research_agent = Agent(
    name="Research Agent",
    instructions=(
        "You are a research specialist. Use web_search to find information. "
        "Return structured findings with key facts. Mark anything unverified."
    ),
    model="gpt-4o-mini",
    tools=[web_search],
    output_type=ResearchResult,
)

writer_agent = Agent(
    name="Writer Agent",
    instructions=(
        "You are a technical writer. Take research findings and write a clear, "
        "well-structured article in markdown. Target 800-1200 words. "
        "Never fabricate data."
    ),
    model="gpt-4o-mini",
)

reviewer_agent = Agent(
    name="Reviewer Agent",
    instructions=(
        "You are a content reviewer. Check the draft for accuracy, structure, "
        "and quality. Score 1-10. If score >= 7, approve. Return the final draft."
    ),
    model="gpt-4o-mini",
    output_type=ReviewResult,
)

# ── Orchestrator ────────────────────────────────

orchestrator = Agent(
    name="Pipeline Orchestrator",
    instructions=(
        "You manage a content pipeline. For any topic:\n"
        "1. Call research_topic to gather information\n"
        "2. Call write_draft with the research results\n"
        "3. Call review_draft with the written draft\n"
        "Return the reviewer's final output to the user."
    ),
    model="gpt-4o-mini",
    tools=[
        research_agent.as_tool(
            tool_name="research_topic",
            tool_description="Research a topic thoroughly.",
        ),
        writer_agent.as_tool(
            tool_name="write_draft",
            tool_description="Write an article from research findings.",
        ),
        reviewer_agent.as_tool(
            tool_name="review_draft",
            tool_description="Review and score an article draft.",
        ),
    ],
)


# ── Run ─────────────────────────────────────────

async def main():
    topic = "How multi-agent AI systems are changing software development in 2026"

    print(f"Starting pipeline for: {topic}\n")
    result = await Runner.run(orchestrator, f"Produce a reviewed article about: {topic}")

    print("=" * 60)
    print(f"Pipeline complete!")
    print(f"Final output:\n{result.final_output}")
    print(f"\nToken usage: {result.raw_responses[-1].usage if result.raw_responses else 'N/A'}")


if __name__ == "__main__":
    asyncio.run(main())

Run it:

python run_pipeline.py

You should see the orchestrator call each agent in sequence, producing a researched, written, and reviewed article.

Real Cost Breakdown

One of the most common questions about multi-agent systems: how much does it cost to run?

Here is a realistic breakdown for our three-agent pipeline using gpt-4o-mini:

Agent	Input Tokens (est.)	Output Tokens (est.)	Cost per Run
Research Agent	~1,500	~800	~$0.0007
Writer Agent	~2,000	~1,500	~$0.0012
Reviewer Agent	~2,500	~600	~$0.0008
Orchestrator overhead	~1,000	~500	~$0.0005
Total	~7,000	~3,400	~$0.003

Note: These are estimates based on gpt-4o-mini pricing as of April 2026 (~$0.15/1M input, ~$0.60/1M output tokens). Actual costs vary by prompt length and output verbosity. Always check OpenAI's pricing page for current rates before production use.

Scaling the math:

100 articles/day: ~$0.30/day
1,000 articles/day: ~$3.00/day

If you switch to gpt-4o for higher quality output, costs increase roughly 15–20x. A common pattern: use gpt-4o-mini for research and writing, gpt-4o for the reviewer agent where quality judgment matters most.

Reducing Costs Further

Cache research results — Skip the Research Agent for previously researched topics
Use structured outputs — Pydantic models reduce wasted tokens on formatting
Set max_turns — Prevent agents from looping excessively
Use gpt-4o-mini by default — Only upgrade models where quality is critical

OpenAI Agents SDK vs LangGraph vs CrewAI — When to Use Which

If you are evaluating agent frameworks, here is how they compare:

Feature	OpenAI Agents SDK	LangGraph	CrewAI
Philosophy	Minimal, Pythonic	Graph-based, explicit	Role-based, high-level
Learning curve	Low	Medium-High	Low-Medium
Multi-agent pattern	Handoffs + tools	State graphs + nodes	Crews + tasks
Structured output	Native Pydantic	Via output parsers	Built-in
Guardrails	Built-in (input/output)	Custom nodes	Limited
LLM support	OpenAI native, 100+ via LiteLLM	Any LLM via LangChain	Multiple providers
State management	Context object	Explicit state graph	Shared memory
Streaming	Built-in	Built-in	Limited
Best for	OpenAI-first teams, rapid prototyping	Complex workflows with branching	Team simulations, role-play agents
Production readiness	High	High	Medium

Choose OpenAI Agents SDK when:

You primarily use OpenAI models
You want the fastest path from prototype to production
Your workflow is a pipeline or triage pattern
You need built-in guardrails without extra dependencies

Choose LangGraph when:

Your workflow has complex branching and cycles
You need fine-grained control over state transitions
You want explicit, visual workflow graphs
You are already in the LangChain ecosystem

We covered LangGraph in depth in our LangGraph step-by-step tutorial — if you want to compare both frameworks hands-on, work through both tutorials with the same project.

Choose CrewAI when:

You think in terms of team roles and collaboration
You want the highest-level abstraction
Your use case is research, analysis, or content generation
You prefer convention over configuration

Advanced Patterns Worth Knowing

Dynamic Instructions

Agent behavior can adapt at runtime:

from agents import Agent, RunContextWrapper


def dynamic_instructions(ctx: RunContextWrapper, agent: Agent) -> str:
    user_tier = ctx.context.get("tier", "free")
    if user_tier == "pro":
        return "Provide detailed, in-depth analysis with code examples."
    return "Provide a concise summary suitable for beginners."


adaptive_agent = Agent(
    name="Adaptive Agent",
    instructions=dynamic_instructions,
    model="gpt-4o-mini",
)

Parallel Agent Execution

Run independent agents simultaneously with asyncio.gather:

import asyncio
from agents import Runner


async def parallel_research(topics: list[str]):
    tasks = [
        Runner.run(research_agent, f"Research: {topic}")
        for topic in topics
    ]
    results = await asyncio.gather(*tasks)
    return results

Agent Cloning

Create agent variants without duplicating configuration:

formal_writer = writer_agent.clone(
    name="Formal Writer",
    instructions="Write in a formal, academic tone. " + writer_agent.instructions,
)

casual_writer = writer_agent.clone(
    name="Casual Writer",
    instructions="Write in a casual, conversational tone. " + writer_agent.instructions,
)

Common Pitfalls and How to Avoid Them

Pitfall	Solution
Agents looping infinitely	Set `max_turns` on `Runner.run()`
Vague handoff behavior	Write explicit handoff instructions in the agent's prompt
Unstructured data between agents	Use `output_type` with Pydantic models
High costs from GPT-4o	Use `gpt-4o-mini` for most agents, upgrade selectively
Guardrail false positives	Test guardrails independently before integrating
Lost context in handoffs	Use `input_filter` on handoffs to control what the next agent sees

FAQ

What is the OpenAI Agents SDK?

The OpenAI Agents SDK is an open-source Python framework for building single-agent and multi-agent AI systems. It provides primitives for agent creation, tool use, inter-agent handoffs, and input/output guardrails. It is the production successor to OpenAI's experimental Swarm library.

How do I install the OpenAI Agents SDK?

Install it via pip: pip install openai-agents==0.13.4. The SDK requires Python 3.10 or higher. Set your OPENAI_API_KEY environment variable before running any agent code.

What is the difference between handoffs and agents-as-tools?

Handoffs transfer control entirely — the receiving agent becomes the active agent and responds directly. Agents-as-tools keeps the orchestrator in control — specialist agents run as tool calls and return results to the orchestrator. Use handoffs for routing, agents-as-tools for coordination.

Can I use non-OpenAI models with the Agents SDK?

Yes. The SDK supports over 100 LLMs through LiteLLM integration. You can use Anthropic, Google, Mistral, and local models — though OpenAI models have the most native support.

How much does it cost to run a multi-agent pipeline?

With gpt-4o-mini, a three-agent pipeline typically costs under $0.01 per run. See our cost breakdown for detailed estimates.

Is the OpenAI Agents SDK a replacement for Swarm?

Yes. The Agents SDK is the production-ready evolution of OpenAI's experimental Swarm library. It adds structured outputs, guardrails, streaming, and MCP tool support that Swarm did not have.

How do guardrails work in the OpenAI Agents SDK?

Input guardrails validate user input before or in parallel with the first agent. Output guardrails check the final agent's response. If a guardrail triggers its tripwire, the SDK raises an exception that you can catch and handle. Tool guardrails can also validate individual function calls.

What to Build Next

You now have a working multi-agent pipeline. Here are some directions to take it further:

Add real search tools — Connect to Brave Search, Serper, or Tavily for live web data
Combine with RAG — Use retrieval-augmented generation to ground your agents in your own documents
Add MCP tools — The SDK has built-in MCP server support for connecting to external services
Build a UI — Wrap the pipeline in a Streamlit or Gradio interface
Explore vibe coding tools — Use AI app builders to create a frontend for your agent pipeline

If you are exploring the broader AI development ecosystem, check out our guide to free AI coding tools and see how tools like Claude Code approach multi-agent patterns differently with subagents and commands.

Wrapping Up

The OpenAI Agents SDK makes multi-agent systems accessible without requiring deep framework expertise. The core pattern is simple:

Define agents with clear instructions and tools
Connect them via handoffs or the orchestrator pattern
Add guardrails to enforce quality and safety
Run with the Runner and let the SDK handle orchestration

The hardest part is not the code — it is designing clear agent boundaries and instructions. Spend your time there, and the SDK handles the rest.

All code from this tutorial is available in the project structure above. Clone it, swap in your own tools and prompts, and start building.

This article is part of Effloow's AI Agent Tutorial series. We build and test every framework we write about — see how we run our own company with 16 AI agents.

Some links in this article may be affiliate links. We only recommend tools we have actually tested. See our affiliate disclosure for details.

This article may contain affiliate links to products or services we recommend. If you purchase through these links, we may earn a small commission at no extra cost to you. This helps support Effloow and allows us to continue creating free, high-quality content. See our affiliate disclosure for full details.

Notion AI for Developers — Custom Agents & Workspace Automation Guide 2026

Jangwook Kim — Sun, 05 Apr 2026 15:05:52 +0000

Notion AI for Developers — Custom Agents & Workspace Automation Guide 2026

Most Notion AI guides teach you to summarize meeting notes. This one teaches you to build autonomous agents that triage your bugs, run your standups, and keep your developer docs alive — without you opening the app.

On February 24, 2026, Notion shipped Custom Agents in version 3.3. They are not chatbots. They are autonomous workers that run on triggers — scheduled times, Slack messages, database changes, email arrivals — and execute multi-step workflows using your workspace data. Over 21,000 Custom Agents were built during the beta alone.

This guide is for developers who already use Notion as a workspace but have not explored what Custom Agents and MCP integration mean for engineering workflows. By the end, you will have a working Custom Agent, understand how to connect Notion to your developer tools via MCP, and know exactly where Notion AI fits (and does not fit) in a modern dev stack.

Affiliate Disclosure: This article contains affiliate links to Notion. If you sign up through our links, we may earn a commission at no extra cost to you. See our affiliate disclosure for details.

What Is Notion AI in 2026?

Notion AI is no longer just an inline writing assistant. In 2026, it is a platform with three distinct layers:

Layer	What It Does	Available On
AI Writing & Editing	Summarize, translate, rewrite, generate text inline	All plans (limited trial on Free/Plus)
Personal Agent	Multi-step tasks triggered by your prompts — research, draft docs, update databases	Business & Enterprise
Custom Agents	Autonomous agents that run on triggers without human prompting, 24/7	Business & Enterprise

The jump from Personal Agent to Custom Agents is the one that matters for developers. Personal Agent responds when you ask it something. Custom Agents act on their own based on triggers you define — a database row changing, a Slack message appearing, a scheduled time arriving.

What Changed in Notion 3.3 (February 2026)

Custom Agents launch: Build autonomous agents using plain language descriptions
Multi-model support: Choose between Claude, GPT, and Gemini — or let Notion auto-select the best model per request
MCP integration: Connect agents to external developer tools like Linear, Figma, and custom MCP servers
Slack integration: Agents can monitor channels, respond to messages, and post updates
Notion Mail and Calendar: Agents handle email triage and meeting scheduling
Enterprise controls: Granular permissions, full audit logging, prompt injection guardrails

Why Developers Should Care About Custom Agents

If you are running a development team, you have recurring tasks that eat hours every week but follow predictable patterns. Custom Agents eliminate them.

Here is the shift: traditional Notion automation (button clicks, simple database automations) required you to define rigid if-then rules. Custom Agents understand context. You describe the job in plain language, and they figure out the steps.

What this means in practice:

A Slack message saying "the checkout page is broken on mobile" gets triaged, tagged with priority, assigned to the right engineer, and logged in your bug database — by an agent, not a human
Your daily standup summary compiles itself from task updates across your sprint database every morning at 9 AM
New pull request descriptions get cross-referenced with your architecture docs and flagged if they touch sensitive systems

This is not hypothetical. Notion themselves use Custom Agents internally for exactly these kinds of workflows, as documented in their blog post on how Notion uses Custom Agents.

If you are already using multi-agent systems like CrewAI or workflow automation tools like n8n, Custom Agents fill a different gap: they live where your team's knowledge already is — inside Notion — and they require zero code to set up.

Getting Started: Plans, Setup, and Enabling AI Features

Which Plan Do You Need?

Custom Agents require a Business or Enterprise plan. Here is the current pricing breakdown:

Plan	Monthly (per member)	Annual (per member)	AI Features	Custom Agents
Free	$0	$0	Limited trial	No
Plus	$12	$10	Limited trial	No
Business	$20	$18	Full AI access	Yes
Enterprise	Custom	Custom	Full AI + zero data retention	Yes

Pricing sourced from notion.com/pricing as of April 2026.

Important pricing change for 2026: Notion AI is now bundled into Business and Enterprise plans. Free and Plus users get a limited trial of core AI features (chat, generate, autofill, translate) but cannot access Custom Agents.

Custom Agents Credit System

Custom Agents are free to try through May 3, 2026. Starting May 4, 2026, they use Notion Credits — a usage-based system available as an add-on for Business and Enterprise plans.

$10 per 1,000 credits
Credits are shared across the workspace
Credits reset monthly (unused credits do not roll over)
Workspace admins purchase credits matching team needs

For a dev team running 3-5 agents with daily triggers, expect to use roughly 500-2,000 credits per month depending on complexity. Simple Q&A agents consume fewer credits than multi-step workflow agents that read databases and post to Slack.

Enabling AI Features

Go to Settings & members → Plans and confirm you are on Business or Enterprise
Navigate to Settings & members → AI and ensure AI features are enabled for your workspace
The Agents section appears in your left sidebar once AI is active

Building Your First Custom Agent — Step by Step

Let us build a practical agent: a Bug Triage Agent that monitors a Slack channel, creates entries in a bugs database, assigns priority, and notifies the right engineer.

Step 1: Create the Agent

Open the Agents section in your sidebar and click the + icon. You have three options:

Create with AI Chat — Describe what you want in natural language. Notion generates draft instructions, triggers, and access settings. This is the fastest path.
Create from Template — Pick a pre-built template and customize it.
Create from Scratch — Start with a blank instructions field. Best if you know exactly what you want.

For our Bug Triage Agent, choose Create with AI Chat and enter:

"I want an agent that monitors our #bugs Slack channel. When someone reports a bug, it should create a new entry in our Bugs database with the reporter's name, a summary of the issue, and an initial priority (P1 for anything mentioning 'production' or 'outage', P2 for everything else). Tag the entry with the current sprint."

Notion AI will generate a draft configuration. Review and refine it.

Step 2: Configure Triggers

Go to Settings → Triggers on your agent page. For our bug triage agent, add a Slack trigger:

Trigger type: Message posted to channel
Channel: #bugs
Scope: All messages (not just mentions)

Other available triggers:

Trigger Type	Examples
Recurring schedule	Daily at 9 AM, weekly on Monday, monthly on the 1st
Slack events	Message posted, emoji reaction, thread started, agent mentioned
Notion events	Page added to database, page updated, comment added, agent @mentioned

You can combine multiple triggers on a single agent. A standup agent might run on a daily schedule and when someone @mentions it in a comment asking for an on-demand update.

Note: Private Slack messages and Slack grid are not currently supported as triggers.

Step 3: Set Data Access

Under Tools and Access, configure what your agent can read:

Add your Bugs database — the agent needs write access to create entries
Add your Sprint tracking database — so it can tag entries with the current sprint
Add your Team roster page — so it knows which engineer handles which area
Optionally enable Web access if the agent should look up external references

Keep access minimal. An agent that can access everything in your workspace is slower and harder to debug than one scoped to exactly the pages it needs.

Step 4: Write Clear Instructions

The instructions field is where you define your agent's behavior. Good instructions follow this pattern:

## Job
Triage bug reports from the #bugs Slack channel.

## When Triggered
1. Read the new Slack message
2. Extract: reporter name, bug description, affected area
3. Check if a similar bug already exists in the Bugs database
4. If duplicate: reply in the Slack thread linking the existing entry
5. If new: create a Bugs database entry with:
   - Title: one-line summary of the bug
   - Reporter: extracted from Slack message
   - Priority: P1 if message mentions "production", "outage", "down", or "critical"; P2 otherwise
   - Sprint: current sprint from Sprint Tracking database
   - Status: "New"
6. Reply in the Slack thread confirming the bug was logged, with a link to the database entry

## Rules
- Never change the priority of existing bugs
- If unclear whether something is a bug or a feature request, tag as "Needs Triage" and assign to the team lead
- Always reply in the Slack thread, never as a new message

Step 5: Choose Your Model

Under Settings → Model, select from:

Auto (recommended) — Notion selects the best model per request
Claude — Strong at reasoning and following complex instructions
GPT — Good general-purpose performance
Gemini — Alternative option

For most developer workflows, Auto is the right choice. The model selection affects credit consumption — more capable models may use slightly more credits per run.

Step 6: Test in Chat

Use the Chat tab to test your agent before it goes live. Send a simulated bug report:

"The checkout page is throwing a 500 error on mobile Safari. Users can't complete purchases. This started after the last deploy."

Check whether the agent correctly identifies this as P1 (it mentions a production-affecting issue), extracts the right details, and would create the correct database entry. Iterate on your instructions based on the results.

Step 7: Set Permissions

Configure who can manage your agent:

Permission Level	What They Can Do
Full Access	Edit instructions, triggers, settings; view activity logs; run the agent
Can Edit	Modify instructions and configuration; review activity
Can View and Interact	Run and chat with the agent; view settings (read-only)

Users without explicit access may still trigger agents configured to respond to events in channels they can access (like Slack messages in a public channel).

MCP Integration — Connecting Notion to Developer Tools

Model Context Protocol (MCP) is the bridge between Notion AI and your external developer tools. It is an open standard that lets AI assistants interact with external services, and Notion has built a hosted MCP server for it.

What Is Notion MCP?

Notion MCP is a hosted server at mcp.notion.com/mcp that gives AI tools secure, OAuth-based access to your Notion workspace. It works in two directions:

External AI tools → Notion: Tools like Claude Code, Cursor, VS Code, and ChatGPT can read and write to your Notion pages through MCP
Notion Custom Agents → External tools: Your Custom Agents can connect to Linear, Figma, HubSpot, and any custom MCP server

For developers, the second direction is where it gets interesting. If you have already explored MCP servers in your development workflow, Notion's MCP support means your workspace data becomes accessible to your entire AI toolchain.

Setting Up Notion MCP with Claude Code

If you use Claude Code for your development workflow, connecting it to Notion takes one command. Notion MCP is a remote server — no local installation required:

In Claude Code, add Notion as an MCP connection using the public URL: https://mcp.notion.com/mcp
Authenticate with OAuth when prompted — one-click approval
Claude Code can now read your Notion pages, search content, create new pages, and update databases

This is useful for:

Having Claude Code pull architecture docs from Notion while writing code
Automatically generating PRDs or tech specs and pushing them to Notion
Searching your team's knowledge base from the terminal

Connecting Custom Agents to External MCP Servers

Custom Agents can connect to any MCP-compatible service. Current first-party integrations include:

Linear — Sync issues, create tickets, update statuses
Figma — Pull design specs, reference components
HubSpot — Access CRM data for customer-facing agents
Custom MCP servers — Connect to any service that implements the MCP protocol

To add an MCP connection to your Custom Agent, go to Tools and Access in the agent settings and add the MCP server URL. Your workspace admin must approve the connection before the agent can use it.

Practical MCP Workflow: Notion + Linear

Here is a concrete workflow that combines Notion Custom Agents with Linear via MCP:

Developer creates a tech spec page in Notion
A Custom Agent monitors the Tech Specs database for new entries
When a spec is marked "Approved", the agent:
- Creates a Linear project with tasks derived from the spec's implementation steps
- Links the Linear project back to the Notion spec page
- Posts a summary in the #engineering Slack channel

This bridges the gap between where decisions happen (Notion) and where code work gets tracked (Linear) — without anyone manually copying information between tools.

5 Developer Workflow Examples

1. Automated Sprint Standup

Trigger: Daily at 9:00 AM, Monday through Friday

What it does:

Reads all tasks updated in the last 24 hours from your Sprint database
Groups updates by assignee
Compiles a standup summary with: what was completed, what is in progress, what is blocked
Posts the summary to #engineering in Slack

Why it works: Async standups save 15-30 minutes per day for a team of 5. The agent captures changes from the database, so nobody has to write an update — the work they already logged is the update.

2. Code Documentation Keeper

Trigger: Page updated in Architecture Docs database

What it does:

Detects when a documented API endpoint or service has not been updated in 30+ days
Cross-references with recent sprint tasks to check if related code was changed
Flags outdated docs by adding a "Needs Review" tag and assigning the last editor
Posts a weekly digest of stale docs to #engineering

Why it works: Documentation rot is the default in most teams. This agent does not write the docs for you — it just makes sure you know which ones are outdated.

3. Slack Bug Triage (Full Version)

Trigger: Message posted in #bugs Slack channel

What it does:

Parses the bug report for severity signals (production, outage, data loss)
Checks for duplicate entries in the Bugs database
Creates a structured bug entry with auto-assigned priority
Routes to the on-call engineer based on the affected area
Replies in the Slack thread with a link to the bug entry

Why it works: The gap between "someone reported a bug in Slack" and "it is in the tracker" is where bugs get lost. This agent closes that gap in seconds.

4. Knowledge Base Q&A

Trigger: Agent @mentioned in Slack or Notion comment

What it does:

Searches across your team's Notion workspace for relevant information
Synthesizes an answer from multiple pages
Cites sources with direct links to the Notion pages
If no answer is found, flags it for the team lead to document

Why it works: "Where is the doc for X?" is one of the most common Slack messages in any engineering team. This agent answers it instantly or identifies gaps in your documentation.

5. PR-to-Spec Reconciliation

Trigger: Page added to "Completed PRs" database (populated via Linear/GitHub integration)

What it does:

Looks up the original tech spec or ticket for the PR
Compares what was spec'd against what was built (based on the PR description)
Flags discrepancies for review
Updates the spec page with an "Implemented" tag and implementation date

Why it works: Specs and reality diverge. This agent keeps your documentation honest by checking implementations against plans.

Notion AI vs ClickUp AI vs Linear AI — Developer Team Comparison

If you are choosing a workspace tool for your dev team, here is how the AI capabilities stack up:

Feature	Notion AI	ClickUp AI (Brain)	Linear
Custom Agents	Yes — autonomous, trigger-based	AI agents available	No autonomous agents
Trigger types	Schedule, Slack, database, email, calendar	Task-based automation	GitHub-based automation
MCP support	Native MCP server + external MCP connections	No MCP	No MCP
Model choice	Claude, GPT, Gemini (or Auto)	ClickUp's proprietary AI	Built-in AI
Developer focus	Flexible — requires setup	Project management oriented	Engineering-native
API for AI features	Notion API with views, databases, MCP	ClickUp API	Linear API + GraphQL
Pricing	Included in Business ($18/user/mo annual) + credits	$9/user/mo add-on + 1,500 credits/mo	Included in paid plans
Best for	Documentation, specs, knowledge management	Broad project management	Issue tracking, sprint cycles

When to Choose Each

Choose Notion AI if: Your team already lives in Notion for docs, specs, and knowledge management, and you want agents that operate directly on that knowledge. The MCP integration makes it the most extensible option.

Choose ClickUp AI if: You need AI tightly integrated with a full project management suite — task creation, timeline views, dashboards — and your workflows are more operational than technical.

Choose Linear if: You want the cleanest engineering workflow with deep GitHub/GitLab integration and you prefer automation through code (webhooks, API) rather than no-code agents. Linear does not have custom autonomous agents, but its simplicity is the point.

For many dev teams, the answer is "Linear for sprint work + Notion for everything else." Notion AI Custom Agents handle the knowledge and documentation layer, while Linear handles the engineering execution layer.

Advanced: Notion API + AI for Custom Integrations

Custom Agents cover most no-code use cases, but developers can also build programmatic integrations using the Notion API. This is useful when you need:

Bidirectional sync between Notion and your own systems
Custom data transformations before writing to Notion
Integration with internal tools that do not support MCP

Notion API Overview

The Notion API provides endpoints for:

Pages: Create, read, update page content and properties
Databases: Query, create entries, update properties
Blocks: Manipulate page content at the block level
Search: Full-text search across the workspace
Users: List workspace members
Comments: Read and create comments on pages

Combining API + Custom Agents

A powerful pattern: use the Notion API to populate databases from your CI/CD pipeline, then let Custom Agents react to those database changes.

Example: Deployment Tracker

# In your CI/CD pipeline (GitHub Actions, etc.)
import requests

NOTION_API_KEY = "your-integration-token"
DATABASE_ID = "your-deployments-database-id"

def log_deployment(service, version, environment, status):
    """Log a deployment to Notion — a Custom Agent reacts to new entries."""
    response = requests.post(
        "https://api.notion.com/v1/pages",
        headers={
            "Authorization": f"Bearer {NOTION_API_KEY}",
            "Content-Type": "application/json",
            "Notion-Version": "2022-06-28"
        },
        json={
            "parent": {"database_id": DATABASE_ID},
            "properties": {
                "Service": {"title": [{"text": {"content": service}}]},
                "Version": {"rich_text": [{"text": {"content": version}}]},
                "Environment": {"select": {"name": environment}},
                "Status": {"select": {"name": status}},
                "Deployed At": {"date": {"start": "2026-04-05T08:00:00Z"}}
            }
        }
    )
    return response.json()

# Called from your deploy script
log_deployment("api-gateway", "v2.4.1", "production", "success")

Then create a Custom Agent with a Notion trigger (page added to Deployments database) that:

Posts a deployment summary to #releases in Slack
If the deployment status is "failed", creates a P1 incident in your Bugs database
Updates a "Last Deployed" field on the corresponding Service page

This pattern — API writes data in, Custom Agents react and distribute — gives you the best of both worlds: programmatic control over data ingestion and no-code automation for the response workflows.

If you are building more complex AI workflows that go beyond what Notion agents offer, consider tools like Dify for visual AI workflow building or n8n for general-purpose workflow automation. AI presentation tools like Gamma can also complement your Notion workspace by turning specs and project data into polished slide decks. Each tool fills a different layer of the stack.

Security, Permissions, and Enterprise Controls

Custom Agents handle your workspace data, so security controls matter — especially in regulated environments.

Permission Model

Workspace admins control:

Who can create agents: Restrict agent creation to specific roles
What agents can access: Each agent has explicit page and database access grants
Which MCP connections are approved: Admin must approve external MCP server connections
Model selection: Enterprise plans can restrict which AI models agents use

Audit and Transparency

Every agent run is logged in the Activity tab — including the trigger, each action taken, and any errors
Changes are reversible — you can see exactly what the agent modified and undo it
Version history tracks all configuration changes (who modified the agent, when, and what changed)

Prompt Injection Guardrails

Notion includes built-in detection for prompt injection attempts — when content an agent reads contains hidden instructions trying to manipulate its behavior. This is relevant for agents that process external input (Slack messages, emails, user-submitted content).

For Enterprise plans, zero data retention is available — your workspace data is not stored by the LLM providers processing agent requests.

Developer-Specific Security Considerations

Scope agent access to the minimum required pages — an agent that triages bugs should not be able to read HR documents
Review the Activity tab after enabling a new agent to verify it behaves as expected
Use the Chat tab to test edge cases (malformed inputs, unusual requests) before enabling triggers
For agents that interact with external MCP servers, ensure those servers follow your organization's security policies

Pricing Breakdown for Developer Teams

Here is what Notion AI costs for a typical 10-person developer team:

Business Plan (Recommended for Most Teams)

Item	Monthly Cost	Annual Cost
Business plan (10 seats)	$200/mo	$180/mo ($2,160/yr)
Custom Agent credits (est. 2,000/mo)	$20/mo	$20/mo ($240/yr)
Total	$220/mo	$200/mo ($2,400/yr)

What You Get

Full AI features for all 10 members (Personal Agent, inline AI, meeting notes)
Custom Agents with shared credit pool
SAML SSO, advanced permissions, private teamspaces
90-day version history, bulk export
MCP integration with external tools

Enterprise Plan

For teams needing zero data retention, advanced compliance, dedicated support, and higher credit volumes, Enterprise pricing is custom — contact Notion's sales team.

Is It Worth It?

Compare the cost against the engineering time saved:

15 minutes saved per day on standups × 10 engineers × 22 work days = 55 hours/month
5 minutes per bug triage × 20 bugs/week = ~7 hours/month
Documentation maintenance: 5-10 hours/month

At $200/month, if Custom Agents save even 20 hours of engineering time, the ROI is clear. The question is whether Notion is already your team's workspace — if it is, the marginal cost of adding agents is low.

FAQ

Can I use Custom Agents on the Free or Plus plan?

No. Custom Agents require a Business or Enterprise plan. Free and Plus plans include limited AI trial features (chat, generate, autofill, translate) but not Custom Agents.

How many Custom Agents can I create?

There is no hard limit on the number of agents. The constraint is credits — each agent run consumes credits based on the complexity of the task and the model used.

Can Custom Agents modify data outside of Notion?

Yes, through MCP connections. An agent connected to Linear via MCP can create issues in Linear. An agent connected to Slack can post messages. However, all external connections must be approved by a workspace admin.

Is there an API for managing Custom Agents programmatically?

As of April 2026, Custom Agents are managed through the Notion UI. The Notion API supports pages, databases, blocks, and comments, but there is no public API endpoint for creating or configuring Custom Agents directly.

Can I use my own LLM with Custom Agents?

Not directly. Custom Agents support Claude, GPT, and Gemini through Notion's built-in model selection. You cannot point an agent at a self-hosted model. If you need custom model support, consider Dify or building a workflow with n8n that calls your own models.

How do Notion Custom Agents compare to building agents with CrewAI or LangGraph?

Different layers entirely. CrewAI and LangGraph are Python frameworks for building custom multi-agent systems from scratch — full control, full complexity. Notion Custom Agents are no-code, workspace-integrated agents for automating recurring work. Use Notion agents for workflow automation within your workspace; use CrewAI/LangGraph for custom AI applications with complex reasoning chains.

What happens when a Custom Agent fails?

Failed runs are logged in the Activity tab with the trigger event, the agent's reasoning at each step, and the specific error. You can provide feedback on failed runs and iterate on your instructions to prevent future failures.

Getting Started Today

Custom Agents are free to try through May 3, 2026. If your team is on a Business or Enterprise plan, there is no reason not to experiment now.

Start here:

Build one simple agent — the Knowledge Base Q&A agent is the quickest win
Test it thoroughly in the Chat tab before enabling triggers
Monitor the Activity tab for the first week
Iterate on instructions based on real results

The agents that work best are scoped narrowly. Do not build one agent that does everything — build five agents that each do one thing well.

For the broader picture of how AI agents fit into a real production environment, read how we built a company powered by 14 AI agents. The principles — scoped responsibilities, clear communication channels, human oversight — apply whether you are running agents in Paperclip, CrewAI, or Notion.

Last updated: April 5, 2026. Pricing and feature availability verified against notion.com/pricing and Notion release notes.

How to Self-Host Dify with Docker — Complete AI Workflow Guide 2026

Jangwook Kim — Sun, 05 Apr 2026 15:05:16 +0000

How to Self-Host Dify with Docker — Complete AI Workflow Guide 2026

Dify Cloud's Team plan costs $159 per month. That is $1,908 per year for a platform you could run on a $5 VPS.

Dify is an open-source AI workflow platform with 136,000+ GitHub stars. It combines a visual workflow builder, RAG pipeline, agent capabilities, and model management into a single self-hostable package. Think of it as n8n or Make.com, but purpose-built for AI — and you own the entire stack.

This guide walks you through self-hosting Dify with Docker Compose, from first git clone to a working RAG chatbot and multi-step AI workflow. We will also connect Ollama for fully offline, private AI inference. No API keys required for the local LLM path.

By the end, you will have a production-capable Dify instance running on your own hardware, a working chatbot that answers questions from your documents, and enough context to decide whether Dify fits your project.

What Is Dify?

Dify is an open-source platform for building AI applications using a visual interface. Instead of writing Python scripts to chain LLM calls together, you drag and drop nodes on a canvas to build workflows — then deploy them as APIs or chatbots with a single click.

Feature	Detail
GitHub stars	136,000+ (as of April 2026)
Current version	1.10.1
License	Dify Open Source License (based on Apache 2.0)
LLM support	OpenAI, Anthropic, Google, Ollama, 100+ providers
Core features	Workflow builder, RAG pipeline, Agent mode, Prompt IDE
Deployment	Docker Compose (self-hosted) or Dify Cloud

What makes Dify different from writing code

If you have used frameworks like LangGraph or CrewAI, you know the pattern: install the SDK, write Python classes for each agent, manage state, handle errors, deploy somewhere. It works, but the iteration cycle is slow. Change a prompt? Redeploy. Add a step? Refactor code.

Dify's visual canvas lets you build the same pipelines without writing code for the orchestration layer. You still write code where it matters — custom tools, data transformations, API integrations — but the workflow logic is visual and instantly editable.

This is not "no-code for people who cannot code." It is a productivity tool for developers who want faster iteration on AI workflows.

What Dify includes out of the box

Workflow Builder: Visual canvas for multi-step AI pipelines. Supports branching, loops, conditionals, and parallel execution.
RAG Pipeline: Built-in document ingestion with chunking, embedding, and vector search. Upload PDFs, Markdown, or plain text and query them immediately.
Agent Mode: Define agents with tools (web search, code execution, API calls) that reason and act autonomously.
Prompt IDE: Compare model responses side by side. Test different prompts against the same input.
Model Management: Connect any LLM provider — or run local models through Ollama.
API Backend: Every app you build gets an API endpoint automatically. No separate deployment needed.

Why Self-Host Dify? The Cost Breakdown

The financial argument for self-hosting is straightforward. Here is what Dify Cloud costs versus running your own instance:

Dify Cloud pricing (as of April 2026)

Plan	Monthly price	Message credits	Team members	Knowledge storage
Sandbox	Free	200	1	50 MB
Professional	$59/month	5,000/month	3	5 GB
Team	$159/month	10,000/month	50	20 GB

Source: dify.ai/pricing — prices verified April 2026.

Self-hosted cost

Component	Monthly cost	Notes
VPS (Hetzner CX22 or similar)	~$5/month	2 vCPU, 4 GB RAM, 40 GB SSD
Domain + SSL	$0	Let's Encrypt is free
LLM inference (Ollama, local)	$0	Runs on the same VPS for small models
LLM inference (API, optional)	Pay-per-use	Only if you want GPT-4, Claude, etc.
Total	~$5/month	$60/year

Annual savings vs Dify Cloud Team: $1,908 - $60 = $1,848.

The catch: you handle your own updates, backups, and troubleshooting. If that sounds like work you would rather avoid, Dify Cloud is a legitimate option — especially for the Sandbox tier, which is free and good enough for experimentation.

For everyone else who prefers owning their infrastructure — as we discussed in our guide to self-hosting your dev stack for under $20/month — let us set this up.

Prerequisites

Before starting, make sure you have:

A server or local machine with at least 2 CPU cores and 4 GB RAM
- Local: macOS 10.14+, Linux, or Windows with WSL 2
- VPS: Any provider works. We use Hetzner for the price-to-performance ratio.
Docker installed (Docker Desktop on Mac/Windows, or Docker Engine on Linux)
Docker Compose v2 (ships with Docker Desktop; install separately on Linux if needed)
Git for cloning the repository
A domain name (optional, but recommended for production with SSL)

Verify your setup

docker --version
# Expected: Docker version 27.x or newer

docker compose version
# Expected: Docker Compose version v2.x

git --version
# Expected: git version 2.x

If any of these commands fail, install the missing tool before continuing. Docker's official installation guides cover every platform.

Step-by-Step: Docker Compose Setup

This is the core of the guide. We will go from zero to a running Dify instance in about 10 minutes.

Step 1: Clone the Dify repository

Clone the latest stable release:

git clone --branch "$(curl -s https://api.github.com/repos/langgenius/dify/releases/latest | jq -r .tag_name)" https://github.com/langgenius/dify.git

This command automatically fetches the tag for the latest release instead of cloning the unstable main branch. At the time of writing, that is v1.10.1.

If you do not have jq installed, you can clone a specific version directly:

git clone --branch v1.10.1 https://github.com/langgenius/dify.git

Step 2: Navigate to the Docker directory

cd dify/docker

This directory contains the docker-compose.yaml and the environment template.

Step 3: Configure environment variables

cp .env.example .env

The default .env works out of the box for local development. For production, you should change these values:

# Open .env in your editor
nano .env

Critical settings to review:

# Security: Generate a unique secret key
SECRET_KEY=sk-your-unique-random-string-here

# Database password (change from default)
DB_PASSWORD=your-secure-database-password

# Redis password
REDIS_PASSWORD=your-secure-redis-password

# If using a custom domain with separate subdomains for frontend/backend:
# COOKIE_DOMAIN=yourdomain.com
# NEXT_PUBLIC_COOKIE_DOMAIN=1

Generate a secure secret key with:

openssl rand -base64 42

Step 4: Start Dify

docker compose up -d

This pulls all required images and starts the services. The first run downloads several gigabytes of Docker images — give it a few minutes on a typical connection.

Step 5: Verify all services are running

docker compose ps

You should see these services in a "running" state:

api — Dify backend API
worker — Background task processor
worker_beat — Scheduled task manager
web — Frontend application
plugin_daemon — Plugin execution environment
nginx — Reverse proxy (ports 80/443)
db — PostgreSQL database
redis — Redis cache
weaviate — Vector database for RAG
sandbox — Code execution sandbox
ssrf_proxy — Security proxy for outbound requests

If any service shows as "restarting" or "exited," check its logs:

docker compose logs <service-name> --tail 50

Step 6: Complete initial setup

Open your browser and navigate to:

Local: http://localhost/install
VPS: http://your-server-ip/install

Create your admin account. This is the first user and will have full access to all workspace settings.

After setup, access the main interface at http://localhost (or your server IP). You should see the Dify dashboard — a clean interface with options to create chatbots, workflows, and agents.

Connecting Ollama for Local LLMs

This is where self-hosting gets interesting. Instead of paying per API call to OpenAI or Anthropic, you can run open-source models locally through Ollama — completely free and fully private.

If you have not set up Ollama yet, our Ollama + Open WebUI self-hosting guide covers installation in detail. Here is the quick version for Dify integration.

Install Ollama

# macOS or Linux
curl -fsSL https://ollama.com/install.sh | sh

# Pull a capable model
ollama pull llama3.1:8b

For a VPS with limited RAM, start with smaller models:

# Lightweight option for 4GB RAM VPS
ollama pull qwen2.5:3b

Configure Dify to use Ollama

Log into your Dify instance.
Navigate to Settings → Model Provider.
Find Ollama in the provider list and click Add.
Configure the connection:

Setting	Value
Model Name	`llama3.1:8b` (or whichever model you pulled)
Base URL	`http://host.docker.internal:11434` (Mac/Windows) or `http://172.17.0.1:11434` (Linux)
Model Type	LLM

Important for Linux users: Docker containers cannot reach localhost on the host machine. Use the Docker bridge IP (172.17.0.1) or set OLLAMA_HOST=0.0.0.0 in your Ollama configuration and use your server's IP.

Click Save and test the connection.

Verify the connection

After adding Ollama, go to Settings → Model Provider and you should see your Ollama models listed. Try sending a test message in a new chatbot app — the response should come from your local model with zero API cost.

Choosing the right model

Model	RAM needed	Best for
Qwen 2.5 3B	3 GB	Basic chat, small VPS
Llama 3.1 8B	6 GB	General use, good quality
Gemma 4 12B	10 GB	Strong reasoning, coding
Llama 3.1 70B	48 GB	Near-frontier quality

If you want to explore more local model options, our Gemma 4 local setup guide and the Docker Model Runner vs Ollama comparison cover model selection in depth.

Building Your First RAG Chatbot in Dify

RAG (Retrieval-Augmented Generation) is the killer feature for most Dify users. You upload your documents, and the chatbot answers questions using your data instead of hallucinating.

If you want to understand RAG fundamentals in depth, our RAG tutorial with LlamaIndex explains the concepts thoroughly. Here we will build one using Dify's visual interface — no code required.

Step 1: Create a Knowledge Base

Go to Knowledge in the left sidebar.
Click Create Knowledge.
Name it something descriptive (e.g., "Product Documentation").
Upload your documents — Dify supports PDF, Markdown, TXT, HTML, DOCX, and CSV.

Step 2: Configure chunking and indexing

Dify offers two indexing modes:

High Quality: Uses an embedding model to create vector representations. Better retrieval accuracy, but requires an embedding model (OpenAI's text-embedding-3-small or a local alternative).
Economical: Uses keyword-based indexing. No embedding model needed, but lower retrieval quality.

For most use cases, choose High Quality. If you are running Ollama, you can use a local embedding model:

ollama pull nomic-embed-text

Then configure it in Dify's model settings as an embedding provider.

Step 3: Create a chatbot app

Go to Studio → Create App → Chatbot.
Name your app.
In the app configuration:
- Set the Model to your preferred LLM (Ollama local or an API provider).
- Under Context, click Add and select your Knowledge Base.
- Write a system prompt:

You are a helpful assistant that answers questions based on the provided context. 
If the context does not contain the answer, say so honestly. 
Do not make up information.

Step 4: Test your chatbot

Use the Debug and Preview panel on the right to ask questions about your uploaded documents. Dify shows which document chunks were retrieved, so you can verify the answers are grounded in your data.

Step 5: Publish and share

Click Publish to make your chatbot available. Dify gives you multiple deployment options:

Web app URL — A hosted chat interface anyone can access
API endpoint — Integrate into your own application
Embed code — Drop a chat widget into any website

Each app gets its own API key. You can rate-limit access and monitor usage from the dashboard.

Building an AI Workflow (Multi-Step Agent Pipeline)

Beyond simple chatbots, Dify's workflow builder lets you create multi-step AI pipelines — similar to what you would build with CrewAI or LangGraph, but visually.

Example: Content Research and Writing Pipeline

Let us build a workflow that takes a topic, researches it, writes an article, and reviews the output.

Step 1: Create a new workflow

Go to Studio → Create App → Workflow. You will see a canvas with a Start node.

Step 2: Add the research step

Click + after the Start node.
Add an LLM node.
Configure it:
- Name: "Researcher"
- Model: Your preferred LLM
- Prompt:

You are a research analyst. Given the topic "{{topic}}", provide:
1. Key facts and statistics
2. Current trends
3. Common misconceptions
4. Three unique angles for an article

Be concise and factual. Cite sources where possible.

Step 3: Add the writing step

Add another LLM node after the Researcher.
Configure it:
- Name: "Writer"
- Model: Your preferred LLM (can be different from the researcher)
- Prompt:

You are a technical writer. Using the research below, write a 500-word article section.

Research:
{{researcher_output}}

Write in a practical, builder-oriented tone. Include specific examples and actionable advice.

Step 4: Add the review step

Add a final LLM node.
Configure it:
- Name: "Reviewer"
- Prompt:

Review this article section for:
1. Factual accuracy
2. Clarity and readability
3. Actionable value for the reader

Article:
{{writer_output}}

Provide specific suggestions for improvement, then output the final revised version.

Step 5: Run and iterate

Click Run to execute the entire pipeline. Dify shows the output of each node, so you can see exactly what the Researcher found, what the Writer produced, and what the Reviewer changed.

This is the same three-agent pattern we built in code with CrewAI — but built in 5 minutes instead of 50 lines of Python. The trade-off is flexibility: complex logic, custom tools, and programmatic control are easier in code. Simple-to-moderate workflows are faster in Dify's visual builder.

More workflow features

Conditional branching: Route data through different paths based on LLM output or variable values.
Code nodes: Write Python or JavaScript for custom transformations.
HTTP request nodes: Call external APIs mid-workflow.
Knowledge retrieval nodes: Pull RAG context at any point in the pipeline.
Variable aggregator: Combine outputs from parallel branches.

Dify vs Flowise vs Langflow — Comparison

If you are evaluating self-hosted AI workflow platforms, these three are the main contenders. Here is how they compare:

Feature	Dify	Flowise	Langflow
GitHub stars	136K+	36K+	52K+
Primary language	Python + TypeScript	TypeScript	Python
Visual builder	Yes, full canvas	Yes, node-based	Yes, node-based
Built-in RAG	Yes, complete pipeline	Yes, via components	Yes, via components
Agent support	Yes, native	Yes, via LangChain	Yes, native
Built-in chat UI	Yes, publishable apps	Yes, embedded chat	Yes, playground
Plugin system	Yes (plugin daemon)	Limited	Community components
Multi-user / teams	Yes, workspace-based	Basic auth	Basic auth
API generation	Automatic for all apps	Yes	Yes
Model providers	100+ via native integration	Via LangChain	Via LangChain/direct
Prompt IDE	Yes, with comparison	No	Basic
Self-host complexity	Docker Compose (11 services)	Docker Compose (1-2 services)	Docker Compose (1-2 services)
Resource requirements	4 GB+ RAM	1-2 GB RAM	2 GB RAM
Best for	Production AI apps with teams	Quick LangChain prototypes	Flexible AI pipelines
License	Apache 2.0 (modified)	Apache 2.0	MIT

When to choose Dify

You need multi-user workspace management with roles and permissions.
You want built-in RAG without configuring vector databases separately.
You are building customer-facing AI applications that need publishable UIs and APIs.
You want a Prompt IDE for systematic prompt engineering.

When to choose Flowise

You want the lightest possible self-hosted option (runs on 1 GB RAM).
You are already deep in the LangChain ecosystem.
You need a quick prototype, not a production platform.

When to choose Langflow

You want the most flexible node-based builder.
You prefer Python-based customization.
You want community-contributed components.

For automation workflows that are not AI-specific (connecting SaaS tools, triggering actions, processing data), consider n8n, Zapier, or Make instead — they are better suited for general automation.

Production Tips

Running Dify locally for testing is one thing. Running it reliably for a team or customer-facing application requires a few additional steps.

Reverse proxy with SSL

For production, put Dify behind a reverse proxy with HTTPS. Here is a minimal Caddy configuration (Caddy handles SSL automatically via Let's Encrypt):

dify.yourdomain.com {
    reverse_proxy localhost:80
}

Or with Nginx:

server {
    listen 443 ssl http2;
    server_name dify.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/dify.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/dify.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

If you are using a self-hosted PaaS like Coolify or Dokploy — which we compared in our Coolify vs Dokploy guide — they handle reverse proxy and SSL automatically.

Backups

The critical data to back up:

PostgreSQL database — Contains all your apps, workflows, and user data.
Vector database (Weaviate) — Contains your RAG knowledge base embeddings.
Uploaded files — Documents you uploaded for knowledge bases.

A simple backup script:

#!/bin/bash
# Backup Dify data
BACKUP_DIR="/backups/dify/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Backup PostgreSQL
docker compose exec -T db pg_dump -U postgres dify > "$BACKUP_DIR/dify_db.sql"

# Backup volumes
docker compose cp weaviate:/var/lib/weaviate "$BACKUP_DIR/weaviate_data"

echo "Backup completed: $BACKUP_DIR"

Run this daily via cron. Test your restore process before you need it.

Updating Dify

Check the Dify GitHub Releases for new versions. The update process:

cd dify/docker

# Pull latest changes
git fetch --all
git checkout v1.10.1  # Replace with the new version tag

# Check for .env changes
diff .env .env.example

# Apply any new environment variables, then restart
docker compose down
docker compose pull
docker compose up -d

Always review the release notes for breaking changes before updating. Back up your database before every major version upgrade.

Performance tuning

For a 4 GB RAM VPS, these settings help:

Limit Weaviate memory in .env: WEAVIATE_QUERY_DEFAULTS_LIMIT=10
Use economical indexing mode if you do not need vector search
Run smaller Ollama models (3B-8B parameter range)
Monitor memory usage: docker stats

For heavier workloads, upgrade to an 8 GB RAM VPS (~$10/month on most providers) — this gives comfortable headroom for Dify plus a local 8B model via Ollama.

Frequently Asked Questions

What is Dify used for?

Dify is an open-source platform for building AI applications — chatbots, RAG systems, multi-step workflows, and autonomous agents — using a visual interface. It handles LLM orchestration, document retrieval, and API deployment so you can focus on the application logic rather than infrastructure plumbing.

Is Dify free to self-host?

Yes. The self-hosted Community Edition is free under the Dify Open Source License (based on Apache 2.0). You pay only for your server costs and any external API calls to LLM providers. Using Ollama for local inference makes the LLM cost zero.

How much RAM does Dify need?

Minimum 4 GB for the Dify platform itself (without local LLM inference). If running Ollama alongside Dify for local models, plan for 8 GB+ depending on model size. A 3B parameter model needs ~3 GB additional RAM; an 8B model needs ~6 GB.

Can I use Dify with ChatGPT / Claude / Gemini?

Yes. Dify supports 100+ model providers. You can add your OpenAI, Anthropic, or Google API key in Settings → Model Provider and use any available model. You can also mix providers — use a cheap local model for simple tasks and GPT-4 or Claude for complex reasoning.

Dify vs LangChain — what is the difference?

LangChain is a Python/JavaScript library for building LLM applications in code. Dify is a visual platform that includes a workflow builder, RAG pipeline, and deployment tools. If you prefer writing code and need maximum flexibility, use LangChain (or LangGraph for agents). If you want faster iteration with a visual interface and built-in deployment, use Dify.

Can I run Dify and Ollama on the same server?

Yes, and this is the recommended setup for cost-effective self-hosting. Install Ollama on the host machine, pull your models, then configure Dify to connect via the Docker bridge IP. Both services share the same server, and Ollama handles inference while Dify handles orchestration.

How do I migrate from Dify Cloud to self-hosted?

Dify Cloud supports exporting your apps and workflows as DSL files. Download them from the cloud interface, then import them into your self-hosted instance via Studio → Import DSL. Knowledge bases need to be re-uploaded and re-indexed, as vector embeddings are not portable between instances.

Is Dify secure enough for production?

The self-hosted version includes sandboxed code execution, an SSRF proxy for outbound requests, and role-based access control. For additional security: run behind a reverse proxy with SSL, change all default passwords in .env, restrict network access to the Dify ports, and keep the platform updated.

What to Build Next

You have a running Dify instance. Here are practical next steps:

Build a customer support bot — Upload your product docs as a Knowledge Base, create a chatbot app, embed it on your website.
Create an internal research tool — Connect to your company's documents and let your team ask questions in natural language.
Automate content workflows — Build the research-write-review pipeline from earlier and connect it to your publishing workflow.
Experiment with agents — Give an LLM access to web search, code execution, and your internal APIs. Let it solve problems autonomously.

For more complex agent architectures, our tutorials on CrewAI and LangGraph show what is possible when you need programmatic control beyond what a visual builder offers. And if you are curious about how AI agents work in a real production environment, read how we built a company with 14 AI agents.

The best part of self-hosting: every experiment costs you nothing beyond the electricity. No API meters ticking. No message credit limits. Just you, your models, and whatever you want to build.

Last updated: April 2026. Dify version referenced: v1.10.1. All pricing verified at time of publication — check provider websites for current rates.

Build Your First Multi-Agent AI System with CrewAI + Python — Step-by-Step Tutorial (2026)

Jangwook Kim — Sun, 05 Apr 2026 15:05:01 +0000

Build Your First Multi-Agent AI System with CrewAI + Python — Step-by-Step Tutorial (2026)

You want multiple AI agents working together — one to research, one to write, one to review. You have heard of CrewAI but every tutorial stops at "Hello World." This one does not.

In this tutorial, you will build the same three-agent content pipeline we built in our LangGraph tutorial and OpenAI Agents SDK tutorial — but using CrewAI. By the end, you will have a working system and enough context to decide which framework fits your project.

What you will build: A Research Agent that gathers information, a Writer Agent that drafts an article, and a Reviewer Agent that validates quality. All three collaborate as a Crew, producing a polished article with a single command.

What Is CrewAI?

CrewAI is an open-source Python framework for orchestrating autonomous AI agents. It lets you define agents with specific roles, assign them tasks, and run them together as a crew — either sequentially or in a hierarchical structure with a manager agent.

Feature	Detail
Language	Python (3.10 to 3.13)
Current version	0.175.0 (as of April 2026)
License	MIT
LLM support	OpenAI (default), Anthropic, Ollama, 100+ via LiteLLM
Core primitives	Agent, Task, Crew, Tool, Process
Package manager	uv (recommended), pip also works

CrewAI's philosophy: role-playing agents with structured collaboration. Instead of building explicit graphs (like LangGraph) or wiring handoffs between agents (like the OpenAI Agents SDK), you define each agent's role, goal, and backstory — then let the framework handle coordination.

Think of it like assembling a project team. You pick the people, define who does what, and the team works together to deliver the result.

Prerequisites

Before we start:

Python 3.10 or higher (CrewAI supports 3.10 through 3.13)
An OpenAI API key — CrewAI defaults to GPT-4, but you can swap in any LLM
Basic Python knowledge — functions, classes, f-strings
A terminal and code editor

Installation

We will use pip for simplicity. CrewAI's official toolchain uses uv, but pip works fine for tutorials.

mkdir crewai-content-pipeline && cd crewai-content-pipeline
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Install CrewAI and the tools package:

pip install crewai crewai-tools

Version pinning: This tutorial was built with CrewAI 0.175.0. Pin your version in production:
pip install crewai==0.175.0 crewai-tools==0.38.0

Set your API key:

export OPENAI_API_KEY="sk-your-key-here"

Verify the installation:

import crewai
print(crewai.__version__)
# Expected: 0.175.0

Core Concepts: Agents, Tasks, Crews, Tools, and Processes

CrewAI has five building blocks. Understanding these is the key to everything that follows.

Agents

An Agent is an autonomous unit with a role, a goal, and a backstory. The role defines its expertise. The goal drives its decisions. The backstory gives the LLM context for how to behave.

from crewai import Agent

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive, accurate information about the given topic",
    backstory=(
        "You are a seasoned research analyst with 15 years of experience. "
        "You are known for your ability to find the most relevant information "
        "and distinguish credible sources from noise."
    ),
    verbose=True
)

Key parameters beyond the basics:

llm — which model to use (default: GPT-4)
tools — list of tools the agent can use
allow_delegation — whether the agent can pass work to other agents (default: False)
max_iter — maximum reasoning iterations before forcing an answer (default: 20)
memory — whether to maintain conversation history across tasks

Tasks

A Task is a specific assignment for an agent. It needs a description (what to do) and an expected_output (what the result should look like).

from crewai import Task

research_task = Task(
    description=(
        "Research the topic '{topic}' thoroughly. "
        "Find key facts, recent developments, and expert opinions. "
        "Focus on information from 2025-2026."
    ),
    expected_output=(
        "A structured research brief with at least 10 key findings, "
        "each with its source or basis."
    ),
    agent=researcher
)

Tasks can depend on each other through the context parameter — a task receives the output of its context tasks as input.

Crews

A Crew is a team of agents working on a set of tasks. You choose a process — sequential or hierarchical — that determines how work flows.

from crewai import Crew, Process

crew = Crew(
    agents=[researcher, writer, reviewer],
    tasks=[research_task, writing_task, review_task],
    process=Process.sequential,
    verbose=True
)

Tools

Tools extend what agents can do. CrewAI ships 30+ built-in tools (web search, file reading, code execution) and lets you build custom ones.

from crewai.tools import tool

@tool("word_count")
def word_count(text: str) -> str:
    """Count the number of words in the given text."""
    count = len(text.split())
    return f"Word count: {count}"

Processes

CrewAI supports two execution strategies:

Sequential — tasks run in order, each feeding into the next. Simple and predictable.
Hierarchical — a manager agent distributes tasks to the best-suited agent. Requires manager_llm to be set.

For this tutorial, we use sequential. It maps naturally to a pipeline: research, then write, then review.

Project Setup

Create the following file structure:

crewai-content-pipeline/
├── main.py
├── agents.py
├── tasks.py
├── tools.py
└── requirements.txt

requirements.txt:

crewai==0.175.0
crewai-tools
python-dotenv

Building Agent #1: The Research Agent

The Research Agent gathers information on a given topic. We give it the SerperDevTool for web search capability.

agents.py:

from crewai import Agent
from crewai_tools import SerperDevTool

search_tool = SerperDevTool()

def create_research_agent() -> Agent:
    return Agent(
        role="Senior Research Analyst",
        goal=(
            "Produce a comprehensive research brief on the assigned topic. "
            "Find accurate, up-to-date facts with credible sources."
        ),
        backstory=(
            "You are a veteran research analyst who has spent 15 years "
            "distilling complex topics into clear, well-sourced briefs. "
            "You never fabricate information — if you cannot verify a claim, "
            "you flag it as unverified."
        ),
        tools=[search_tool],
        verbose=True,
        allow_delegation=False,
        max_iter=25
    )

Why allow_delegation=False? In sequential mode, each agent handles its own task. Delegation is useful in hierarchical setups where a manager assigns work dynamically.

Pro tip: If you do not have a Serper API key, you can skip the search tool and the Research Agent will rely on its LLM training data. The pipeline still works — you just lose real-time web results. Get a key at serper.dev (free tier available).

Building Agent #2: The Writer Agent

The Writer Agent takes the research brief and produces a well-structured article.

Add to agents.py:

def create_writer_agent() -> Agent:
    return Agent(
        role="Senior Content Writer",
        goal=(
            "Transform research findings into an engaging, well-structured "
            "article that is informative and easy to read."
        ),
        backstory=(
            "You are an experienced technical writer who turns dense research "
            "into clear, compelling articles. You write in a practical, "
            "builder-oriented tone. You use short paragraphs, concrete "
            "examples, and avoid jargon unless you define it first."
        ),
        verbose=True,
        allow_delegation=False,
        max_iter=20
    )

No tools needed here — the Writer Agent works purely with the text it receives from the Research Agent.

Building Agent #3: The Reviewer Agent

The Reviewer Agent checks the article for quality, accuracy, and completeness. We give it a custom word-count tool so it can enforce length requirements.

Add to tools.py:

from crewai.tools import tool

@tool("word_count")
def word_count(text: str) -> str:
    """Count the number of words in a given text."""
    count = len(text.split())
    return f"The text contains {count} words."

@tool("check_structure")
def check_structure(text: str) -> str:
    """Check if the article has proper heading structure."""
    lines = text.split("\n")
    h2_count = sum(1 for line in lines if line.startswith("## "))
    h3_count = sum(1 for line in lines if line.startswith("### "))
    has_intro = not lines[0].startswith("#") if lines else False

    issues = []
    if h2_count < 3:
        issues.append(f"Only {h2_count} H2 headings found (minimum 3 recommended)")
    if h3_count < 2:
        issues.append(f"Only {h3_count} H3 headings found (minimum 2 recommended)")
    if not has_intro:
        issues.append("Article may be missing an introduction before the first heading")

    if issues:
        return "Structure issues found:\n- " + "\n- ".join(issues)
    return "Article structure looks good: sufficient headings and proper introduction."

Add the Reviewer Agent to agents.py:

from tools import word_count, check_structure

def create_reviewer_agent() -> Agent:
    return Agent(
        role="Senior Content Reviewer",
        goal=(
            "Review the article for accuracy, completeness, readability, "
            "and proper structure. Provide specific, actionable feedback."
        ),
        backstory=(
            "You are a meticulous editor with a sharp eye for factual errors, "
            "weak arguments, and structural problems. You review with the "
            "reader in mind — if something is confusing, you flag it."
        ),
        tools=[word_count, check_structure],
        verbose=True,
        allow_delegation=False,
        max_iter=15
    )

Defining the Tasks

Each task maps to one agent and describes what that agent needs to deliver. The context parameter creates the data flow between tasks.

tasks.py:

from crewai import Task
from agents import (
    create_research_agent,
    create_writer_agent,
    create_reviewer_agent,
)

# Create agents
research_agent = create_research_agent()
writer_agent = create_writer_agent()
reviewer_agent = create_reviewer_agent()

def create_tasks(topic: str) -> list:
    research_task = Task(
        description=(
            f"Research the topic: '{topic}'\n\n"
            "Your deliverables:\n"
            "1. At least 10 key findings with supporting details\n"
            "2. Recent developments (2025-2026 preferred)\n"
            "3. Notable expert opinions or industry data\n"
            "4. Any controversies or counterarguments\n\n"
            "Flag any claim you cannot verify as [UNVERIFIED]."
        ),
        expected_output=(
            "A structured research brief in markdown format with "
            "numbered findings, each containing the fact and its basis."
        ),
        agent=research_agent,
    )

    writing_task = Task(
        description=(
            f"Write a comprehensive article about: '{topic}'\n\n"
            "Requirements:\n"
            "- Use the research brief from the previous task as your source\n"
            "- Write 1500-2000 words\n"
            "- Use clear H2 and H3 headings\n"
            "- Include a compelling introduction and conclusion\n"
            "- Write in a practical, builder-oriented tone\n"
            "- Use short paragraphs (3-4 sentences max)\n"
            "- Include concrete examples where possible"
        ),
        expected_output=(
            "A well-structured article in markdown format, "
            "1500-2000 words, with proper heading hierarchy."
        ),
        agent=writer_agent,
        context=[research_task],
    )

    review_task = Task(
        description=(
            "Review the article produced by the Writer Agent.\n\n"
            "Check for:\n"
            "1. Factual accuracy — flag any unsupported claims\n"
            "2. Structure — proper heading hierarchy (H2/H3)\n"
            "3. Word count — minimum 1500 words\n"
            "4. Readability — clear language, short paragraphs\n"
            "5. Completeness — does it cover the topic adequately?\n\n"
            "Use the word_count and check_structure tools.\n"
            "Produce the final article with any necessary corrections applied."
        ),
        expected_output=(
            "The final, reviewed article in markdown format with a "
            "brief reviewer note at the top summarizing any changes made."
        ),
        agent=reviewer_agent,
        context=[writing_task],
        output_file="output/article.md",
    )

    return [research_task, writing_task, review_task]

How context works: When writing_task has context=[research_task], the Writer Agent automatically receives the Research Agent's output as part of its input. This is how data flows through the pipeline without you manually passing strings between agents.

Assembling the Crew — Sequential and Hierarchical Processes

main.py:

import os
from dotenv import load_dotenv
from crewai import Crew, Process
from tasks import create_tasks, research_agent, writer_agent, reviewer_agent

load_dotenv()

def run_content_pipeline(topic: str, process_type: str = "sequential"):
    """Run the three-agent content pipeline."""

    tasks = create_tasks(topic)

    if process_type == "hierarchical":
        crew = Crew(
            agents=[research_agent, writer_agent, reviewer_agent],
            tasks=tasks,
            process=Process.hierarchical,
            manager_llm="gpt-4o",
            verbose=True,
        )
    else:
        crew = Crew(
            agents=[research_agent, writer_agent, reviewer_agent],
            tasks=tasks,
            process=Process.sequential,
            verbose=True,
        )

    result = crew.kickoff()

    print("\n" + "=" * 60)
    print("PIPELINE COMPLETE")
    print("=" * 60)
    print(f"\nToken usage: {result.token_usage}")
    print(f"\nFinal output saved to: output/article.md")

    return result

if __name__ == "__main__":
    topic = "The rise of multi-agent AI systems in 2026 and why they matter for developers"
    run_content_pipeline(topic)

Sequential vs. Hierarchical: When to Use Each

Sequential (Process.sequential):

Tasks run in a fixed order: research → write → review
Each task's output feeds into the next via context
Predictable, easy to debug
Best for linear pipelines where the workflow is known upfront

Hierarchical (Process.hierarchical):

A manager agent (powered by manager_llm) decides which agent handles which task
Agents can be reassigned dynamically based on results
More flexible but harder to predict
Best for complex projects where task assignment depends on intermediate results

For most content pipelines, sequential is the right choice. Use hierarchical when you have many agents and tasks where the optimal routing is not obvious upfront.

Running the Pipeline

python main.py

You will see verbose output showing each agent's reasoning process. The final article is saved to output/article.md.

Expected output structure:

[Research Agent] Starting research on: The rise of multi-agent AI systems...
[Research Agent] Using SerperDevTool to search...
[Research Agent] Found 10 key findings...
[Writer Agent] Received research brief, beginning article...
[Writer Agent] Draft complete: 1,847 words
[Reviewer Agent] Reviewing article structure...
[Reviewer Agent] Using word_count tool... Result: 1,847 words
[Reviewer Agent] Using check_structure tool... Structure looks good
[Reviewer Agent] Final article approved with minor edits

PIPELINE COMPLETE
Token usage: {'total_tokens': 18432, 'prompt_tokens': 14201, 'completion_tokens': 4231}

Note: Actual output format and token counts will vary depending on your CrewAI version and LLM model. The pattern above shows typical behavior, not exact output.

Real Cost Breakdown

Running this three-agent pipeline costs real money. Here is what to expect with GPT-4o pricing as of early 2026:

Metric	Typical Range
Total tokens	15,000 – 25,000
Prompt tokens	12,000 – 18,000
Completion tokens	3,000 – 7,000
Cost per run (GPT-4o)	$0.08 – $0.15
Cost per run (GPT-4o-mini)	$0.005 – $0.015
Execution time	45 – 120 seconds

Source: Token counts based on OpenAI's published pricing at openai.com/pricing. Actual costs depend on prompt complexity, agent verbosity, and tool usage. [UNVERIFIED: exact per-run costs — run your own pipeline and check result.token_usage for actual numbers.]

Cost optimization tips:

Use GPT-4o-mini for the Writer and Reviewer — set llm="gpt-4o-mini" on agents where you do not need maximum reasoning capability
Reduce max_iter — lower the iteration cap to prevent agents from over-thinking
Enable caching — CrewAI caches tool results by default, avoiding duplicate API calls
Use verbose=False in production — verbose logging adds overhead

CrewAI vs LangGraph vs OpenAI Agents SDK — Comparison

Having built the same content pipeline with all three frameworks (Articles #10, #26, and this one), here is how they compare:

Feature	CrewAI	LangGraph	OpenAI Agents SDK
Philosophy	Role-playing teams	Graph-based workflows	Handoff-based orchestration
Learning curve	Low — define roles, run crew	Medium — learn graph concepts	Low — Pythonic, minimal API
Multi-agent setup	Built-in (Crew + Process)	Manual (nodes + edges)	Built-in (Handoffs)
Sequential workflow	`Process.sequential`	Define edges explicitly	Chain handoffs
Hierarchical workflow	`Process.hierarchical`	Custom manager node	Not built-in
Tool integration	30+ built-in + custom	LangChain tools ecosystem	Function-based tools
Guardrails	Task-level guardrails	Custom validation nodes	Built-in Guardrails class
Memory	Built-in (short/long-term)	Built-in persistence	External (bring your own)
Structured output	Pydantic models	Pydantic via LangChain	Pydantic models
Async support	Yes (`akickoff()`)	Yes (native)	Yes (`Runner.run()` is async)
LLM flexibility	100+ models via LiteLLM	100+ via LangChain	OpenAI native, LiteLLM addon
Best for	Team-based AI workflows	Complex stateful workflows	OpenAI-native agent systems
Lines of code (this tutorial)	~120	~180	~100
Python requirement	3.10 – 3.13	3.9+	3.10+
License	MIT	MIT	MIT

When to Choose CrewAI

You want the fastest setup for multi-agent collaboration
Your workflow maps naturally to roles and responsibilities
You need built-in hierarchical delegation (manager agent)
You prefer YAML configuration over code for agent definitions

When to Choose LangGraph

You need fine-grained control over execution flow
Your workflow has complex branching, loops, or conditional logic
You need durable execution with checkpoint/resume
You want human-in-the-loop approval steps at specific points

When to Choose OpenAI Agents SDK

You are already in the OpenAI ecosystem
You want the simplest possible API with minimal abstractions
Handoff-based routing between agents fits your use case
You need built-in guardrails for safety-critical applications

Extending the Pipeline: Adding RAG and Custom Tools

Once your basic pipeline works, here are practical next steps.

Adding a Knowledge Base with RAG

Combine CrewAI agents with a RAG (Retrieval-Augmented Generation) system so your Research Agent can query your own documents instead of just the web.

from crewai_tools import RagTool

# Point to your document directory
rag_tool = RagTool(
    config=dict(
        llm=dict(provider="openai", config=dict(model="gpt-4o-mini")),
        embedder=dict(provider="openai", config=dict(model="text-embedding-3-small")),
    )
)

research_agent = Agent(
    role="Internal Knowledge Researcher",
    goal="Find relevant information from our internal knowledge base",
    backstory="Expert at querying and synthesizing internal documentation.",
    tools=[rag_tool],
    verbose=True,
)

For a deeper dive into building RAG systems, see our LlamaIndex RAG tutorial.

Building Custom Tools

The @tool decorator makes it easy to give agents new capabilities:

from crewai.tools import tool
import json

@tool("read_json_file")
def read_json_file(file_path: str) -> str:
    """Read and parse a JSON file, returning its contents as formatted text."""
    with open(file_path, "r") as f:
        data = json.load(f)
    return json.dumps(data, indent=2)

@tool("save_to_file")
def save_to_file(content: str, file_path: str) -> str:
    """Save content to a file at the specified path."""
    os.makedirs(os.path.dirname(file_path), exist_ok=True)
    with open(file_path, "w") as f:
        f.write(content)
    return f"Content saved to {file_path}"

Using Structured Output

Force agents to return data in a specific format using Pydantic models:

from pydantic import BaseModel
from typing import List

class ResearchBrief(BaseModel):
    topic: str
    key_findings: List[str]
    sources: List[str]
    confidence_level: str

research_task = Task(
    description="Research the given topic thoroughly.",
    expected_output="Structured research brief.",
    agent=research_agent,
    output_pydantic=ResearchBrief,
)

This is useful when your pipeline feeds into other systems that expect structured data — APIs, databases, or downstream processing steps.

Common Mistakes and How to Avoid Them

After building multi-agent systems with CrewAI, here are the pitfalls we see most often:

1. Vague agent backstories. The backstory is not decoration — it shapes how the LLM interprets the role. "You are a writer" produces worse results than "You are a technical writer who specializes in developer tutorials, writes in short paragraphs, and always includes code examples."

2. Missing expected_output detail. A task with expected_output="A good article" gives the agent no quality criteria. Be specific: word count, format, required sections.

3. Forgetting context on dependent tasks. Without context=[previous_task], the next agent has no access to prior work. This is the most common cause of "my agents are ignoring each other's output."

4. Setting max_iter too low. If your agent's task is complex and it hits the iteration limit, it will return whatever it has — often incomplete work. Start with the default (20) and adjust based on observed behavior.

5. Running hierarchical without understanding the overhead. Hierarchical mode adds a manager agent that consumes tokens deciding who should do what. For simple 3-agent pipelines, sequential is cheaper and more predictable.

FAQ

How is CrewAI different from LangChain?

LangChain is a general-purpose LLM framework for building chains and retrievals. CrewAI is specifically designed for multi-agent collaboration. CrewAI can use LangChain tools, but it adds the Agent-Task-Crew orchestration layer that LangChain does not have natively. LangGraph (part of the LangChain ecosystem) is the closer comparison — see our full comparison above.

Can I use CrewAI with local models like Ollama?

Yes. Set the llm parameter on any agent to point to your local model:

agent = Agent(
    role="Researcher",
    goal="Research topics using local LLM",
    backstory="Local-first researcher.",
    llm="ollama/llama3.1",
    verbose=True,
)

For a guide on setting up Ollama, see our Ollama + Open WebUI self-hosting guide.

How many agents can a Crew have?

There is no hard limit. Practically, 3-7 agents cover most use cases. Beyond that, consider using hierarchical process with sub-crews to keep complexity manageable.

Can CrewAI agents call other Crews?

Yes — this is the Flows feature. A Flow can trigger multiple Crews as part of a larger pipeline. This is useful for complex applications where different stages need different team compositions.

Is CrewAI production-ready?

CrewAI is used in production by companies building AI-powered workflows. It has built-in memory, caching, rate limiting, and error handling. For production deployments, pin your CrewAI version and test thoroughly — the API surface is still evolving between releases.

How does CrewAI compare to building agents with Claude Code?

Claude Code is an AI coding assistant that uses its own agent architecture for software engineering tasks. CrewAI is a framework you use to build custom agent systems for any domain. They solve different problems — you might even use Claude Code to help you write your CrewAI agents.

What to Build Next

You now have a working multi-agent content pipeline with CrewAI. Here are paths to explore:

Add more agents — a Fact-Checker Agent, an SEO Agent, or a Translator Agent
Try hierarchical mode — let a manager agent decide task routing
Connect to your data — use RAG tools to feed agents your internal docs
Build a Slack bot — trigger the pipeline from a Slack message and post results back
Compare frameworks — build the same pipeline with LangGraph or OpenAI Agents SDK and decide which fits your team

If you are curious how we use multi-agent systems in our own workflow, read how we built a company powered by 14 AI agents.

This is Part 3 of our Agent Trilogy series. Part 1 covers LangGraph, Part 2 covers the OpenAI Agents SDK, and this article covers CrewAI. All three tutorials build the same content pipeline so you can compare frameworks directly.

Effloow uses affiliate links where noted. If you sign up for a service through our links, we may earn a commission at no extra cost to you. We only recommend tools we actually use.

Framer Review 2026: The AI Website Builder Designers Actually Want (Complete Guide)

Jangwook Kim — Sun, 05 Apr 2026 14:45:18 +0000

Framer Review 2026: The AI Website Builder Designers Actually Want

Most website builder reviews start with the same pitch: "build a beautiful website without code." Every platform claims that. Squarespace claims it. Wix claims it. WordPress with Elementor claims it. What none of them deliver is a tool that makes designers feel like they are actually designing — not dragging pre-made blocks around a grid and hoping the result looks intentional.

Framer is different, and after testing every plan tier against real projects — portfolio sites, SaaS landing pages, content-driven blogs, and multi-language business sites — the reason is clear. Framer treats the web as a design medium first. The canvas feels closer to Figma than to any traditional website builder. Animations are first-class citizens, not afterthoughts. And the AI features that landed in 2025 and 2026 have turned Framer from a designer's toy into a legitimate production platform.

But Framer is not for everyone. The CMS has real limitations. The pricing has hidden costs that most reviews gloss over. And the learning curve is steeper than Squarespace or Wix, especially if you have never used a freeform design tool before.

This review covers everything: the AI generation workflow, the developer story with code components, the CMS capabilities and their ceilings, a detailed pricing breakdown, and honest comparisons with Webflow, Squarespace, Wix, and WordPress. If you are choosing a website builder in 2026, this is the review that tells you what the marketing pages leave out.

Affiliate Disclosure: This article contains affiliate links to Framer via the Framer Creators Program. If you sign up through our links, we earn a 50% commission on first-year subscriptions at no extra cost to you. Framer Creators also keep 100% of marketplace template and plugin revenue. We only recommend tools we use ourselves. See our affiliate disclosure for full details.

What Is Framer? (And Why It Is Not Just a Prototyping Tool Anymore)

Framer started in 2014 as a JavaScript-based prototyping tool for interaction designers. If you used Framer Classic or Framer X, you remember a code-heavy tool aimed squarely at design engineers building mobile prototypes. That version of Framer no longer exists.

Modern Framer is a fully visual, no-code website builder with integrated hosting, a CMS, AI-powered generation, and a growing ecosystem of templates and plugins. The pivot happened gradually — first with Framer Sites in 2022, then with the sunsetting of the legacy desktop app — but the result is a platform that competes directly with Webflow, Squarespace, and WordPress for production websites.

What makes Framer stand apart from every other builder in 2026 is the canvas. Where Webflow gives you a structured, box-model-driven editor and Squarespace gives you templates with constrained customization, Framer gives you a freeform design surface. You place elements where you want them. You control spacing, typography, and layout with the precision of a design tool, not the constraints of a page builder.

This matters because the gap between design and implementation has always been where quality dies. You design something beautiful in Figma, then spend hours trying to recreate it in a builder that fights you on every pixel. Framer closes that gap because the builder is the design tool.

Core Capabilities at a Glance

Freeform visual editor with responsive breakpoints and auto-layout
AI site generation from text prompts via Wireframer
Built-in CMS with collections, filtering, and dynamic pages
Code components in React for developers who need custom functionality
One-click publishing with integrated hosting on a global CDN
Template marketplace with community-built starters
AI translation for multi-language sites
SEO controls including metadata, sitemap generation, and Open Graph tags

If you have been following the vibe coding trend where developers describe what they want and AI builds it, Framer's AI features sit in a similar space — but for designers and non-technical founders instead of engineers.

Framer AI: How AI Website Generation Actually Works

Framer's AI features are not a gimmick bolted onto an existing builder. They are integrated into the core workflow in three distinct areas: site generation, content rewriting, and translation. Here is what each one actually does.

Generating a Full Site from a Text Prompt

Framer's Wireframer feature lets you generate a complete responsive page by describing what you want in natural language. You open a new project, select "Generate with AI," and type a prompt like "portfolio website for a freelance brand designer with a dark theme, project gallery, about section, and contact form."

Within 30 to 60 seconds, Framer generates a structured, responsive page with:

A layout framework based on your description
Starter copy that matches your stated purpose
Placeholder sections you can customize
Responsive behavior across desktop, tablet, and mobile breakpoints

The output is not a finished website. It is a strong starting point — a wireframe with enough structure and content that you can refine rather than build from scratch. Think of it as the AI doing the first 40 percent of the work: establishing page structure, section hierarchy, and basic content flow.

Where Wireframer falls short is in visual sophistication. The generated layouts tend toward safe, generic structures. You will almost always need to customize typography, colors, spacing, and imagery to get something that feels distinctive. But compared to staring at a blank canvas, the time savings are real — especially for landing pages and portfolio sites where structure follows well-established patterns.

If you are familiar with vibe coding tools like Bolt.new and Lovable, Framer's AI generation is conceptually similar but aimed at visual design rather than application code. The output is a website layout, not a codebase.

AI Translation and Content Rewriting

Framer's AI translation feature is genuinely useful for multi-language sites. You click a button, select target languages, and Framer translates your entire site — every text element, every CMS entry — without plugins or third-party integrations.

The translation quality is surprisingly good for marketing copy and straightforward content. For technical or nuanced content, you will want a human reviewer. But the workflow — translate everything in one click, then review and refine — beats managing translation plugins or external services.

Framer also offers AI-powered content rewriting within the editor, allowing you to adjust tone, length, and style of existing text blocks. This is useful for iterating on copy without leaving the canvas.

AI Image Generation

Through a partnership with Visual Electric, Framer includes AI image generation directly in the editor. You can generate images from text prompts and place them on your canvas without switching to a separate tool. For placeholder imagery and quick iterations, this saves time. For final production imagery, you will likely still want professional photography or purpose-built AI image tools.

AI Plugins for Custom Workflows

Developers can build custom AI plugins that integrate OpenAI, Anthropic, and Google Gemini models directly into the Framer editor. This enables workflows like automatic alt text generation, content rewriting with custom brand voice, and AI-powered image creation with specific style parameters. It is an advanced feature, but it signals where Framer is heading: a design platform where AI handles the repetitive work while humans focus on creative decisions.

Framer Key Features Deep Dive

Visual Editor — Designing Like Figma, Publishing Like WordPress

The visual editor is Framer's strongest feature and its primary differentiator. If you have used Figma, Sketch, or any modern design tool, the Framer canvas will feel immediately familiar. You have layers, frames, auto-layout, and direct manipulation of every element.

Key design capabilities include:

Auto-layout that handles responsive behavior without manual breakpoint adjustments
Stacks for flexible horizontal and vertical arrangements
Scroll-based animations with granular control over timing and easing
Hover, tap, and scroll interactions that you configure visually
Component system with variants and properties for reusable design elements
Smart components that maintain state and respond to user interaction

The animation system deserves special mention. Where most builders offer basic fade-in effects, Framer gives you a full animation toolkit. You can create scroll-triggered parallax effects, hover state transitions, page transition animations, and micro-interactions — all without writing code. For design-focused sites where motion and interaction quality matter, this is a significant advantage over every competitor except perhaps Webflow (which offers similar depth but with a steeper learning curve).

CMS — Built-In Content Management (and Its Limits)

Framer's CMS lets you create collections (think database tables), define fields, and build dynamic pages that pull from those collections. For blogs, portfolio galleries, product listings, and documentation sites, the CMS works well.

What works:

Visual collection design — define fields and content structure without code
Dynamic pages that automatically generate from collection items
Filtering and sorting on collection lists
Relational CMS on Pro and above — link collections together
JSON sync for importing and exporting CMS data

What has real limitations:

No nested collection lists — you cannot display a collection list inside another collection list
CMS item caps — Basic allows 1,000 items across 1 collection; Pro allows 2,500 across 10 collections; Scale allows 10,000 across 20 collections
No built-in search across CMS content
Limited API access — the CMS is primarily designed for visual management, not headless use
No schema markup per CMS item — you cannot add structured data to individual collection items through the UI

For small to medium content sites — a blog with a few hundred posts, a portfolio with 50 to 100 projects — the CMS is more than adequate. For content-heavy sites approaching thousands of items, or sites that need advanced content relationships, Webflow's CMS or a headless CMS like Sanity or Strapi will serve you better.

Code Components — React for Developers

This is where Framer gets interesting for developers. You can write custom React components and use them alongside visual elements on the Framer canvas. These code components have full access to React's ecosystem — hooks, state management, third-party libraries — and they render as native elements on the published site.

Developer features include:

Code components — custom React components with visual property controls that designers can configure in the editor
Code overrides — higher-order components that modify properties of any layer or component
Fetch API — build API endpoints that designers can use on their sites without code
Plugins — small apps that interact with the Framer editor and CMS

For teams with both designers and developers, this is a powerful model. Designers build the visual layout. Developers create custom components for complex functionality — interactive data visualizations, custom forms, third-party integrations. Both work in the same tool without stepping on each other.

If you are using AI code editors like Cursor or Windsurf for your development workflow, you can write Framer code components in your preferred editor and import them into the platform.

Templates and Marketplace

Framer's template marketplace offers hundreds of community-built templates across categories: portfolios, landing pages, agency sites, SaaS pages, and personal sites. Templates range from free to $49+, with most premium templates in the $19 to $39 range.

The marketplace is also where Framer's Creators Program shines. Template creators keep 100 percent of their revenue — Framer takes zero platform fees. This has attracted high-quality template designers, and the marketplace has grown substantially. Framer reports paying out $6.5 million to creators in 2025 (source: Framer Creators page — verify current figures).

Beyond templates, the marketplace includes components (reusable design elements) and plugins (editor extensions) that extend Framer's functionality without code.

SEO Features and Limitations

Framer includes built-in SEO controls that cover the essentials:

Page-level metadata — title tags, meta descriptions, and Open Graph tags
Automatic sitemap generation for search engine crawling
Clean URL structure with customizable slugs
Google Lighthouse integration for performance monitoring
Automatic image optimization and lazy loading
Global CDN hosting across 20+ locations for fast load times

Performance is a genuine strength. Framer sites load fast because they are statically generated and served from a global CDN. Google Lighthouse scores consistently hit 90+ for well-built Framer sites.

However, there are SEO limitations that matter for content-heavy sites:

No per-item structured data — you cannot add schema markup (FAQ, Product, Article) to individual CMS items through the Framer interface
Limited redirect management — bulk redirects require the Pro plan
No built-in analytics beyond basics — you will need Google Analytics, Plausible, or a similar tool for serious analytics
No native blog features like RSS feeds, categories with pagination, or related post recommendations

For SEO-focused content sites, tools like Surfer SEO can complement Framer's built-in capabilities, but you should know that Framer is optimized for marketing sites and portfolios more than content-heavy blogs.

Is Framer good for SEO? Yes, for the fundamentals — fast load times, clean markup, proper metadata. No, if you need advanced content SEO features that platforms like WordPress with Yoast or Webflow provide natively.

Framer Pricing 2026: Every Plan Explained

Framer's pricing is straightforward at first glance but has hidden costs that add up quickly for growing sites. Here is the complete breakdown.

Free vs Basic vs Pro vs Scale vs Enterprise

Feature	Free	Basic ($10/mo)	Pro ($30/mo)	Scale ($100+/mo)	Enterprise
Site pages	2	30	150	300+	Custom
CMS collections	0	1	10	20+	Custom
CMS items	0	1,000	2,500	10,000+	Custom
Monthly bandwidth	1 GB	10 GB	100 GB	200 GB+	Custom
Custom domain	No	Yes	Yes	Yes	Yes
Analytics history	None	30 days	30 days	30 days	Custom
Staging environment	No	No	Yes	Yes	Yes
A/B testing	No	No	Yes	Yes	Yes
Relational CMS	No	No	Yes	Yes	Yes
Site redirects	No	No	Yes	Yes	Yes
Priority support	No	No	No	Yes	Yes
Premium CDN	No	No	No	Yes	Yes

Source: framer.com/pricing — verify current pricing before purchasing. All paid prices are annual billing. Monthly billing costs more — expect roughly 20 to 30 percent higher on month-to-month plans.

The Free plan is genuinely useful for learning and prototyping. You get the full editor, AI features, and access to the template marketplace. The limitation is publishing: free sites are hosted on a framer.site subdomain with a Framer badge, and you are limited to 2 pages.

The Basic plan at $10 per month (annual) is a solid entry point for personal sites, simple portfolios, and single-page landing pages. The 30-page limit and single CMS collection are enough for most individual projects.

The Pro plan at $30 per month (annual) is where Framer becomes a serious tool. Staging environments, relational CMS, A/B testing, and site redirects unlock professional workflows. For freelancers and small agencies building client sites, this is the tier that makes sense.

The Scale plan starts at $100 per month (annual only) and adds usage-based pricing beyond included limits. It is designed for high-traffic marketing sites and larger businesses that need priority support and premium CDN performance.

Hidden Costs — Editor Seats, Languages, and CMS Limits

This is where most Framer reviews fail you. The plan prices above are per-site costs for a single editor. Here is what adds up:

Extra editor seats: $20/month on Basic, $40/month on Pro and Scale — per additional editor, per site
Translation locales: $20 per additional language per month across all plans
CMS overages on Scale: $20 per additional 100 pages, CMS items and bandwidth scale similarly
Convert add-on (advanced analytics): $50 per 500,000 events
Advanced Hosting add-on: $200 per month

For a solo founder building one site, these extras do not apply. For an agency managing multiple client sites with team access and multi-language support, the costs compound fast. A Pro site with 2 extra editors and 3 translation locales runs $30 + $80 + $60 = $170 per month — significantly more than the headline $30 price suggests.

Compare this with a platform like WordPress on a self-hosted stack under $20 per month and you can see why pricing context matters. Framer's value proposition is speed and design quality, not cost efficiency at scale.

Framer vs Webflow: Which Should You Choose?

This is the comparison most people searching for a Framer review actually want. Both platforms target designers and agencies. Both offer visual builders, CMS capabilities, and code extensibility. The differences are real and meaningful.

Aspect	Framer	Webflow
Design approach	Freeform canvas (Figma-like)	Box model / structured layout
Learning curve	Moderate (intuitive for designers)	Steep (CSS knowledge helps)
AI features	AI site generation, translation, image gen	Webflow AI (newer, more limited)
CMS depth	Good for basic/medium needs	More powerful (nested lists, 10K items on lower plans)
Code extensibility	React code components	Custom code embed, Webflow APIs
Animation	Excellent (scroll, hover, page transitions)	Excellent (Interactions 2.0)
E-commerce	No native e-commerce	Full e-commerce platform
Hosting	Included, global CDN	Included, global CDN
Pricing (entry)	$10/mo (Basic)	$14/mo (Basic)
Pricing (professional)	$30/mo (Pro)	$23/mo (CMS) to $39/mo (Business)
Template marketplace	Growing, creator-friendly (0% cut)	Larger, established ecosystem
Localization	AI translation built-in	Requires third-party tools

Choose Framer if: You are a designer who wants the canvas to feel like a design tool. You prioritize animation quality and interaction design. You want built-in AI translation for multi-language sites. You value speed of iteration over CMS depth.

Choose Webflow if: You need a robust CMS with nested collections and complex content relationships. You plan to add e-commerce. You are comfortable with CSS concepts and want granular control over the box model. You need a more mature ecosystem with more third-party integrations.

For most marketing sites, landing pages, and portfolio sites in 2026, Framer is the faster path to a polished result. For content-heavy sites, membership platforms, or e-commerce, Webflow's deeper feature set wins.

Framer vs Squarespace: Design Quality Compared

Aspect	Framer	Squarespace
Design freedom	Freeform, unlimited layout control	Template-based with constrained customization
Animation	Full animation toolkit	Basic fade/slide effects
CMS	Flexible collections	Blog and product focused
AI features	AI generation, translation, image gen	Squarespace AI (text and image generation)
E-commerce	None	Built-in, mature
Pricing	From $10/mo	From $16/mo
Learning curve	Moderate	Low
Best for	Designers wanting creative control	Non-technical users wanting polished templates

Squarespace is the safer choice for non-designers who want a professional-looking site with minimal effort. Framer is the better choice for anyone who finds Squarespace templates limiting and wants to create something distinctive. If you care about micro-interactions, scroll animations, and pixel-level control, Framer wins decisively. If you want to pick a template, add your content, and launch in an afternoon, Squarespace is more appropriate.

Framer vs Wix: Ease of Use vs Design Control

Aspect	Framer	Wix
Design approach	Freeform professional canvas	Drag-and-drop with AI positioning
AI features	AI site gen, translation, plugins	Wix ADI, AI text, AI image
App ecosystem	Growing marketplace	Massive (500+ apps)
E-commerce	None	Full e-commerce suite
CMS	Flexible collections	Built-in with dynamic pages
Pricing	From $10/mo	From $17/mo (Light)
Performance	Excellent (static generation)	Variable (historically slower)
Target user	Designers and developers	Small businesses and beginners

Wix serves a broader market — small business owners, restaurants, local services — with an app ecosystem that covers booking, payments, email marketing, and more. Framer serves a narrower audience — designers, agencies, and tech companies — with deeper design tools and better performance. If you need a business operating system with your website, Wix has more built-in functionality. If you need a website that looks and performs like it was custom-built, Framer delivers higher quality.

Framer vs WordPress: When to Use Each

Aspect	Framer	WordPress
Setup complexity	Zero (hosted platform)	Requires hosting, domain, installation
Design flexibility	Freeform visual editor	Theme-dependent, page builders vary
Plugin ecosystem	Small but growing	Massive (60,000+ plugins)
CMS power	Basic to medium	Unlimited (custom post types, ACF, etc.)
Performance	Consistently fast	Varies wildly by setup
SEO tools	Built-in basics	Best-in-class with Yoast/RankMath
Cost at scale	Expensive (per-site pricing)	Cheap (hosting + free plugins)
Maintenance	Zero (managed platform)	Ongoing (updates, security, backups)
Best for	Marketing sites, portfolios	Content sites, blogs, complex applications

WordPress powers 40+ percent of the web for a reason: it can do almost anything with the right plugins and configuration. But that flexibility comes with maintenance burden, security concerns, and performance variability. Framer eliminates all of that by being a managed platform with a consistent, fast experience.

For content-heavy sites with hundreds or thousands of pages, WordPress with proper hosting remains the better choice. For a marketing site, portfolio, or product landing page where design quality and load speed matter most, Framer gets you there faster with less ongoing work.

If you are considering self-hosting WordPress or other platforms, our guide to self-hosted deployment platforms like Coolify covers the infrastructure side.

Who Is Framer Best For? (And Who Should Avoid It)

Framer is excellent for:

Freelance designers building portfolio sites and client landing pages
Startup founders who need a polished marketing site fast
Agencies delivering high-design marketing sites at scale
Design-focused brands where animation and interaction quality define the brand
Multi-language businesses that benefit from built-in AI translation
Developers who want to combine visual design with React code components

Framer is not the right choice for:

E-commerce businesses — no native e-commerce; use Shopify or Webflow
Content-heavy publishers — CMS item limits and missing blog features are real constraints
Budget-conscious solopreneurs — costs add up quickly with editor seats and locales
Non-technical users wanting maximum simplicity — Squarespace or Wix are easier to learn
Applications with complex backend logic — Framer is a website builder, not an app platform

Framer Creators Program: Affiliate and Monetization Details

The Framer Creators Program offers two monetization paths:

1. Marketplace Revenue (Templates, Components, Plugins)

Create and sell templates, UI kits, components, or plugins on the Framer Marketplace. Creators keep 100 percent of their revenue — Framer takes zero platform fees. This is unusually generous compared to other marketplace platforms. Framer reported $6.5 million in creator payouts in 2025 (source: Framer Creators page), with individual creators earning from $1,000+ per month to six-figure annual revenues.

2. Referral Commissions

Refer new users to Framer and earn up to 50 percent commission on their subscription payments for the first 12 months. Tracking is powered by Dub. For context, a single Pro plan referral ($30/month annual) generates approximately $180 in first-year commission.

For designers and agencies who already recommend tools to clients, the Creators Program turns that recommendation into a revenue stream. If you are building with free AI tools and looking for ways to monetize your expertise, creating Framer templates is a legitimate path.

Verdict: Is Framer Worth It in 2026?

Framer has earned its place as the best AI website builder for designers who care about craft. The visual editor is best-in-class. The AI features are practical rather than gimmicky. The code component system bridges the gap between design and development in a way no other platform matches. And the performance of published sites is consistently excellent.

The trade-offs are real: CMS limitations cap what you can build for content-heavy sites, hidden pricing costs add up for teams, and the lack of e-commerce means Framer cannot be your everything platform. But for marketing sites, portfolios, landing pages, and design-forward brands, Framer delivers results that would cost significantly more with a custom development approach.

If you are a designer tired of fighting page builders that constrain your creativity, Framer is the tool that finally gets out of your way. If you are a developer who wants to contribute code components without owning the entire frontend, Framer's React integration makes that possible. And if you are a founder who needs a professional site fast, Framer's AI generation gives you a head start that no other builder matches.

Our recommendation: Start with the Free plan to learn the editor. Build your first project. If the design workflow clicks for you — and if your project fits within the CMS and feature constraints outlined above — upgrade to Pro for the full professional toolkit. The $30 per month investment pays for itself if it saves you even a few hours of design and development time per project.

For teams already invested in the broader AI tooling ecosystem — whether that is AI presentation tools like Gamma for decks or automation platforms like n8n for workflows — Framer fits naturally as the website layer. It is purpose-built for a world where AI handles the scaffolding and humans focus on the creative decisions that matter.

Have you tried Framer for a real project? We would like to hear what worked and what did not. Share your experience with us — it helps us keep this review accurate and useful for the community.

Raycast Review 2026: The Mac Launcher That Replaced 4 Apps (+ MCP Setup Guide)

Jangwook Kim — Sun, 05 Apr 2026 14:44:42 +0000

Raycast Review 2026: The Mac Launcher That Replaced 4 Apps (+ MCP Setup Guide)

Most Mac launcher reviews tell you that Raycast is "a better Spotlight." That misses the point entirely. Raycast is not just a launcher — it is a command center that replaces your clipboard manager, window manager, snippet expander, and increasingly, your AI assistant.

After using Raycast daily for over six months as part of our developer workflow at Effloow, the tool has become one of those utilities that makes you wonder how you worked without it. But the real story in 2026 is not the launcher itself — it is the AI and MCP integration that turns Raycast into an intelligent bridge between your local tools and large language models.

This review covers what actually matters: the features that justify switching, the MCP setup that no other review covers properly, the AI capabilities that work (and the ones that do not), and whether the paid plans are worth it.

Affiliate Disclosure: This article contains affiliate links to Raycast Pro via the Rewardful affiliate program. If you sign up through our links, we earn a 30% recurring commission on Pro subscriptions at no extra cost to you. We only recommend tools we use ourselves. See our affiliate disclosure for full details.

What Is Raycast? (And Why Developers Love It)

Raycast is a macOS-only productivity launcher that replaces Spotlight with a keyboard-driven command interface. You press a hotkey (default: Option + Space), type what you want, and Raycast handles it — whether that is launching an app, running a script, managing your clipboard, searching documentation, or chatting with an AI model.

What separates Raycast from basic launchers is its extension ecosystem. With over 1,500 community-built extensions, Raycast connects to GitHub, Jira, Linear, Notion, Slack, Docker, and dozens of other developer tools without leaving the keyboard. Every action is one or two keystrokes away.

Core Features Overview

Here is what Raycast does out of the box, no extensions required:

Application Launcher — Faster than Spotlight with fuzzy search and learning-based ranking
Clipboard History — Stores text, images, links, and files (3 months on free plan, unlimited on Pro)
Window Management — Snap, resize, and organize windows with keyboard shortcuts (replaces Rectangle or Magnet)
Snippets & Text Expansion — Create reusable text blocks with dynamic variables like date, time, and clipboard content
Quicklinks — Custom URL shortcuts with query parameters (e.g., type "gh {repo}" to open any GitHub repository)
Calculator & Unit Converter — Inline calculations and conversions right in the search bar
File Search — Find files faster than Finder with content-based search
Raycast Notes — Quick capture notes accessible from anywhere (5 on free plan, unlimited on Pro)

The free tier is surprisingly generous. Unlike many productivity tools that gate core features behind paywalls, Raycast gives you the full launcher, window management, snippets, quicklinks, and the extension ecosystem at no cost.

Free Tier vs Pro vs Team — What You Actually Get

Feature	Free	Pro ($8/mo annual)	Team ($12/user/mo annual)
Core launcher & search	✅	✅	✅
Clipboard history	3 months	Unlimited	Unlimited
Window management	✅	✅	✅
Snippets	✅	✅	Shared across team
Quicklinks	✅	✅	Shared across team
Extensions (1,500+)	✅	✅	✅
AI messages	50 total	50 + Advanced AI add-on	50 + Advanced AI add-on
Raycast Notes	5	Unlimited	Unlimited
Cloud Sync	❌	✅	✅
Custom themes	❌	✅	✅
Shared commands	Up to 5	Up to 5	Unlimited
Shared quicklinks & snippets	Up to 30 each	Up to 30 each	Unlimited
Advanced AI add-on	❌	+$8/mo	+$8/user/mo

Source: raycast.com/pricing

The pricing update worth noting: as of early 2026, the Pro plan is $10/month if billed monthly or $8/month on the annual plan. The Advanced AI add-on is a separate $8/month charge on top of Pro, giving you access to higher-tier models and increased rate limits.

Enterprise pricing is custom and adds SAML/SCIM SSO, domain capture, 2FA enforcement, IP allow-lists, and extension allow-lists.

Raycast AI: Built-In Intelligence for Your Mac

Raycast's AI features have matured significantly. The platform now offers four distinct ways to use AI, each suited to different workflows.

Cloud AI Models

With a Pro subscription and the Advanced AI add-on, Raycast provides access to multiple frontier models:

Claude (Anthropic) — Multiple versions available
GPT-4o and o1/o3 series (OpenAI) — Including reasoning models
Gemini (Google) — Latest versions
Llama (Meta) — Open-source models hosted in the cloud
Grok (xAI) — Latest version
Perplexity — With built-in web search capability

Rate limits on the standard tier allow 50 requests per minute and 300 per hour. Advanced models like o1 have additional caps of 150 requests per 24 hours.

Bring Your Own Key (BYOK): If you already have API keys from Anthropic, OpenAI, Google, or OpenRouter, you can use them directly in Raycast. This bypasses the AI add-on subscription entirely — you pay only for what you use through your own API accounts. This is particularly attractive for developers who already maintain API subscriptions for their coding workflows.

Local Models with Ollama — Free, Offline AI

This is where Raycast gets genuinely exciting for privacy-conscious developers. Since v1.99, Raycast integrates directly with Ollama, giving you access to over 100 open-source models that run entirely on your machine.

What this means in practice:

Zero cloud dependency — works offline, on airplanes, in restricted networks
No subscription required — local models are free for all Raycast users, including free tier
Full privacy — your prompts and data never leave your machine
Models range from lightweight (135M parameters) to massive (671B parameters)

How to set up Ollama with Raycast:

Install Ollama from ollama.ai (one command: curl -fsSL https://ollama.ai/install.sh | sh or download the Mac app)
Open Raycast Settings → AI → Local Models
Copy and paste model names from Ollama's library to download them directly within Raycast
Select your preferred local model as the default, or choose per-conversation

Recommended models for different use cases:

Use Case	Model	Size	Notes
General chat	`llama3.2`	3B	Fast, good for quick questions
Code assistance	`codellama:13b`	13B	Solid for code generation
Detailed analysis	`llama3.1:70b`	70B	Needs 48GB+ RAM, slower but accurate
Vision tasks	`llava`	7B	Image understanding support
Lightweight	`phi3:mini`	3.8B	Runs well on 8GB Mac

Vision model support means you can attach screenshots or images to your Raycast AI chat and have local models analyze them — no cloud required.

Experimental: AI Extensions with local models. Ollama-powered models can now participate in AI Extensions (tool calling). However, since Ollama does not yet support tool choice or streaming for tool calls, this feature is labeled experimental and can be unreliable. Stick to cloud models for extension-heavy workflows.

If you are interested in running more models locally, our guide on self-hosting Ollama with Open WebUI covers the full setup, including VPS deployment options. For comparing Ollama with Docker Model Runner, see our Docker Model Runner vs Ollama comparison.

Custom AI Commands & Presets for Developers

AI Commands are where Raycast becomes a real productivity multiplier. Instead of typing the same prompt patterns repeatedly, you create reusable commands with specific instructions, model selection, and output formatting.

Built-in commands include:

Fix Spelling & Grammar
Improve Writing
Make Shorter / Make Longer
Explain This
Change Tone to (Professional, Casual, Friendly, etc.)

Creating custom commands is where the value compounds. For example, you can build:

A "Review PR" command that takes clipboard content and outputs a structured code review
A "Write Commit Message" command that generates conventional commits from staged diffs
A "Explain Error" command that parses stack traces and suggests fixes
A "Translate to Japanese" command for content localization workflows

Presets combine a model selection with specific instructions, letting you switch between different AI personalities or specializations instantly. You might have a "Code Reviewer" preset using Claude and a "Creative Writer" preset using GPT-4o.

Raycast MCP Setup Guide (Model Context Protocol)

This is the section that most Raycast reviews skip entirely, and it is arguably the most future-facing feature in the entire application. MCP (Model Context Protocol) is an open standard created by Anthropic that lets AI models connect to external tools and data sources. Raycast is one of the first productivity tools to ship native MCP client support.

What Is MCP and Why It Matters

Think of MCP as a USB-C port for AI. Just as USB-C provides a standard way to connect peripherals to your computer, MCP provides a standard way to connect tools and data to AI models. Instead of each AI tool building custom integrations, MCP servers provide a universal interface.

For a deep dive into the protocol and the best servers available, see our top MCP servers guide for developers.

Installing Your First MCP Server in Raycast

Raycast makes MCP server installation straightforward:

Method 1: Using the Install Server Command

Open Raycast and search for "Install MCP Server"
Fill out the form with the server details:
- Name: A human-readable identifier (e.g., "Sequential Thinking")
- Type: stdio (the supported transport protocol)
- Command: The executable (e.g., npx)
- Args: Command arguments (e.g., ["-y", "@modelcontextprotocol/server-sequential-thinking"])
- Env: Any required environment variables (e.g., API keys)

Method 2: Clipboard Pre-fill

Copy a JSON configuration before opening the Install Server command, and Raycast auto-populates the form:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}

Method 3: Deeplink Installation

For programmatic or shareable installations, use Raycast's deeplink format:

raycast://mcp/install?<configuration-json-percent-encoded>

This is useful for team documentation or README files where you want one-click MCP server setup.

Configuring mcp-config.json

All non-development servers are stored in a single mcp-config.json configuration file. To locate it:

Open Raycast and search for "Manage MCP Servers"
Select "Show Config File in Finder"

The configuration follows a straightforward JSON format:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Important note on PATH: Raycast passes the PATH from your default shell to the MCP server process. If a command works in your terminal (like npx, node, or python3), it will work in Raycast. If your MCP server command is not found, check that your shell PATH includes the relevant directories.

Using MCP Tools in AI Chat & Commands

Once installed, MCP servers work identically to native Raycast AI Extensions. To use them:

In any AI context (Quick AI, AI Chat, AI Commands, or Presets), type @
Select the MCP server you want to invoke
The server's tools become available to the AI model

For example, with the filesystem MCP server installed, you could ask Raycast AI: "@filesystem What are the largest files in my Downloads folder?" The AI will use the MCP server's tools to actually browse your filesystem and return real results.

Best MCP Servers for Raycast

Based on our testing, here are the MCP servers that work best with Raycast:

Server	What It Does	Install Command
Sequential Thinking	Structured reasoning chains	`npx -y @modelcontextprotocol/server-sequential-thinking`
Filesystem	Read/write local files	`npx -y @modelcontextprotocol/server-filesystem /path`
GitHub	Repos, issues, PRs	`npx -y @modelcontextprotocol/server-github`
Brave Search	Web search from AI chat	`npx -y @modelcontextprotocol/server-brave-search`
Memory	Persistent knowledge graph	`npx -y @modelcontextprotocol/server-memory`
Context7	Up-to-date library docs	`npx -y @upstash/context7-mcp@latest`

Transport protocol note: Raycast currently supports stdio transport for locally-run servers. Experimental HTTP support (SSE and Streamable protocols) has been added for connecting to remote MCP servers, but stdio remains the most reliable option.

For a complete guide on building your own MCP server, see our custom MCP server tutorial.

MCP + AI Commands: The Combined Workflow

This is the workflow combination that no other Raycast review covers: using MCP servers inside custom AI Commands. Here is a practical example:

"Explain This Codebase" Command:

Install the filesystem MCP server pointing to your projects directory
Create a custom AI Command with the prompt: "Using @filesystem, read the README and key source files in {query} directory. Provide a 3-paragraph summary of what this project does, its architecture, and key dependencies."
Now, from anywhere in Raycast, run this command with a project path and get an AI-powered codebase overview

This type of workflow — combining MCP tool access with reusable AI Commands — is what makes Raycast's MCP support more than a checkbox feature.

Must-Have Raycast Extensions for Developers

The extension ecosystem is one of Raycast's strongest advantages over Alfred and Spotlight. Here are the extensions that deliver the most value in a developer workflow.

Top 10 Developer Extensions

GitHub — Browse repos, issues, PRs, and notifications without opening a browser
Linear — Create, search, and manage Linear issues from Raycast
Docker — Manage containers, images, and volumes from the command bar
Jira — Search and create Jira tickets inline
Homebrew — Search, install, and manage Homebrew packages
VS Code Recent Projects — Jump to any recent VS Code workspace instantly
Tailwind CSS — Search Tailwind classes and utilities
npm — Search npm packages with download stats and documentation links
DevDocs — Search DevDocs.io documentation offline
Dash — Query Dash documentation sets from Raycast

Productivity Extensions

Notion — Search pages, create entries, and access databases
Slack — Send messages, set status, and search conversations
Google Translate — Inline translation with auto-detect
Todoist / Things — Task management without switching apps
Color Picker — Pick colors from anywhere on screen with multiple format outputs
1Password / Bitwarden — Search and autofill passwords

Every extension installs in seconds from the Raycast Store and integrates directly into the command bar. No configuration files, no terminal commands — just search and install.

Raycast vs Alfred 2026: Which Should You Choose?

This is the comparison everyone asks about. Both are excellent Mac launchers, but they serve different philosophies.

Feature Comparison Table

Feature	Raycast	Alfred
Price	Free (Pro at $8/mo)	Free (Powerpack £34 one-time)
AI integration	Native (cloud + local + MCP)	Via workflows only
Extension ecosystem	1,500+ in store	Community workflows (fewer, varies)
Clipboard manager	Built-in (free)	Powerpack required
Window management	Built-in (free)	Not included
Snippets	Built-in (free)	Powerpack required
Customization depth	Extensions + API	Workflows + AppleScript
MCP support	Native	None
Pricing model	Subscription (Pro features)	One-time purchase (Powerpack)
Platform	macOS only	macOS only
First-party design	Modern, polished	Functional, customizable

Performance & Speed

Both launchers are fast. In daily use, the difference in launch speed is imperceptible. Where Raycast pulls ahead is in the richness of what happens after you press Enter — the depth of extension integrations, the AI features, and the MCP connectivity make it feel like a different category of tool.

Alfred's strength is its workflow system, which gives power users deep customization through AppleScript, shell scripts, and visual workflow builders. If you already have a library of Alfred workflows that you depend on, migration is a real cost.

Verdict

Choose Raycast if: You want an all-in-one tool with AI, MCP, modern extensions, and do not mind a subscription model for advanced features. The free tier alone replaces multiple paid apps.

Choose Alfred if: You prefer a one-time purchase, already have deep Alfred workflow investments, or want maximum customization through scripting without relying on a managed extension store.

For most developers starting fresh in 2026, Raycast is the stronger choice. The AI integration, MCP support, and extension ecosystem create compounding value that Alfred's traditional approach does not match.

Raycast Productivity Setup Guide

Beyond AI and developer tools, Raycast excels as a general productivity platform. Here is how to set up the features that replace standalone apps.

Window Management

Raycast's built-in window management eliminates the need for Rectangle, Magnet, or BetterSnapTool:

Half-screen snapping — Left half, right half, top half, bottom half
Quarter tiling — Snap to any corner
Third splits — Left third, center third, right third
Custom sizes — Define your own dimensions and positions
Multi-display support — Move windows between monitors with shortcuts

Set up your preferred shortcuts in Raycast Settings → Extensions → Window Management. Common setups:

Ctrl + Option + Left → Left half
Ctrl + Option + Right → Right half
Ctrl + Option + Up → Maximize
Ctrl + Option + Down → Restore previous size

Clipboard History

The clipboard manager stores everything you copy — text, images, links, files, and colors. Search through your history instantly with the Clipboard History command.

Pro tips:

Pin frequently used items for instant access
Use the "Paste as Plain Text" action to strip formatting
Filter by content type (text, images, links)

Snippets & Text Expansion

Create text snippets that expand when you type a keyword:

Static snippets — Reusable text blocks (email templates, code patterns, signatures)
Dynamic snippets — Include variables like {date}, {time}, {clipboard}, or {cursor} for intelligent expansion

Example snippets for developers:

!pr → Expands to your PR template with date and branch placeholders
!debug → Expands to your standard debugging console.log pattern
!meeting → Expands to meeting notes template with today's date

Quicklinks & Shortcuts

Quicklinks are parameterized URL shortcuts:

gh {query} → Opens https://github.com/search?q={query}
npm {package} → Opens https://www.npmjs.com/package/{package}
mdn {query} → Opens MDN Web Docs search
so {query} → Opens Stack Overflow search

These compound over time. After a few weeks of adding quicklinks for your most-visited URLs, you save minutes every day.

Pricing Deep Dive: Is Raycast Pro Worth It?

The pricing question comes down to what you value and what you already pay for.

Free Tier Value Analysis

The free tier is legitimately excellent. You get:

Full launcher with learning-based ranking
Clipboard history (3 months)
Window management (replaces $10-15 apps like Rectangle Pro)
Snippets and text expansion (replaces $5-10 apps like TextExpander basic)
Quicklinks and calculator
All 1,500+ community extensions
50 AI messages to try the feature
5 Raycast Notes

Estimated replacement value: $25-40/month in standalone app subscriptions.

Pro ROI Calculation

Pro at $8/month (annual) adds:

Unlimited clipboard history
Cloud Sync across devices
Custom themes
Unlimited Raycast Notes

The Advanced AI add-on ($8/month additional) adds:

Access to Claude, GPT-4o, o1/o3, Gemini, and other frontier models
Higher rate limits (50/min, 300/hour)
Image generation with DALL·E and Stable Diffusion

Total for Pro + AI: $16/month ($192/year).

For comparison:

ChatGPT Plus: $20/month
Claude Pro: $20/month
GitHub Copilot: $10/month

If Raycast AI replaces even one of those subscriptions for your daily quick questions and code assistance, it pays for itself. Combined with BYOK support (bring your own API keys), you can use Pro without the AI add-on and get AI features through your existing API subscriptions at usage-based rates.

The Free + Ollama Path

Here is the option that nobody talks about: Raycast Free + Ollama gives you AI-powered productivity for $0.

Install Raycast (free)
Install Ollama (free)
Download a model like llama3.2 (free)
Get AI chat, AI commands, and local model inference — all without spending anything

This works offline, respects your privacy, and requires no subscription. The trade-off is that local models are slower and less capable than frontier cloud models, but for many tasks (writing assistance, code explanation, translation), they are more than sufficient.

For setting up the most capable local models, see our guides on running Gemma 4 locally with Ollama and the free AI coding tools stack.

Who Raycast Is and Is Not For

Raycast is for you if:

You are a macOS developer who lives in the terminal and browser
You want to consolidate multiple productivity apps into one tool
You are interested in MCP and AI integration as part of your workflow
You prefer keyboard-driven interfaces over mouse navigation
You value privacy and want local AI options
You work across multiple developer tools (GitHub, Linear, Jira, Docker, etc.)

Raycast is probably not for you if:

You use Windows or Linux — Raycast is macOS only, with no announced plans for other platforms
You are happy with Spotlight + individual apps and do not want to learn a new tool
You need deep Alfred workflow compatibility — migration is possible but not seamless
You want enterprise-grade AI — Raycast AI is convenient but does not replace dedicated tools like Claude Code for advanced workflows or terminal AI coding agents
You primarily work on mobile or iPad — no iOS version exists

Frequently Asked Questions

Is Raycast free?

Yes. The core launcher, clipboard history (3 months), window management, snippets, quicklinks, calculator, and all 1,500+ community extensions are free forever. The free plan also includes 50 AI messages and 5 Raycast Notes. You can use Raycast indefinitely without paying anything.

Is Raycast safe to use?

Raycast is a reputable company backed by prominent investors. The app runs locally on your Mac and does not require root access. Extension permissions are sandboxed. For AI features, cloud models send your prompts to the respective model providers (OpenAI, Anthropic, etc.), but local models via Ollama keep everything on your machine. Raycast's privacy policy is transparent about data handling.

Is Raycast better than Alfred?

It depends on your priorities. Raycast offers more built-in features (AI, MCP, window management, clipboard) for free. Alfred offers a one-time purchase model and deeper scripting customization. For most developers starting fresh in 2026, Raycast provides more value. See the detailed comparison table above.

How do I set up MCP in Raycast?

Search for "Install MCP Server" in Raycast, fill out the server details (name, command, args, env variables), and the server becomes available via @-mention in AI Chat and Commands. See the full MCP Setup Guide section above for step-by-step instructions.

Can Raycast run local AI models?

Yes, since v1.99. Raycast integrates with Ollama to run over 100 open-source models locally. Install Ollama, download models through Raycast Settings → AI → Local Models, and use them in all AI features. Local models are free for all users, including the free tier.

How much does Raycast cost?

Free plan: $0. Pro plan: $8/month (annual) or $10/month (monthly). Team plan: $12/user/month (annual) or $15/user/month (monthly). Advanced AI add-on: +$8/month on top of Pro. Enterprise: custom pricing.

Does Raycast work on Windows?

No. Raycast is macOS-only as of April 2026. There are no officially announced plans for Windows or Linux support.

What are the best Raycast extensions?

For developers: GitHub, Linear, Docker, Jira, Homebrew, VS Code Recent Projects, and Tailwind CSS. For productivity: Notion, Slack, Google Translate, and Color Picker. See the full extensions list above.

How do I use Raycast with Ollama?

Install Ollama from ollama.ai, then go to Raycast Settings → AI → Local Models. Copy model names from Ollama's library to download them. Once downloaded, select a local model in any AI chat or command. No subscription required.

Final Verdict

Raycast in 2026 is the most complete Mac productivity tool available. The free tier alone replaces multiple paid applications, and the AI integration — especially with MCP and Ollama — puts it in a category that no other launcher touches.

The MCP support is the real differentiator. While other tools require you to switch between different AI interfaces for different tasks, Raycast lets you connect your AI assistant to your actual tools and data through a standardized protocol. This is not a gimmick — it is the direction that all AI-native tools are moving, and Raycast is there first among Mac launchers.

Our recommendation:

Start with the free plan. It is genuinely useful without paying anything.
Add Ollama for free AI. Local models give you privacy and zero cost.
Upgrade to Pro when you need Cloud Sync or unlimited clipboard history.
Add the AI add-on only if local models are not sufficient for your needs and you do not already have API keys you could use via BYOK.

For developers building with AI tools — especially those already in the MCP ecosystem with tools like Claude Code or exploring AI agent workflows — Raycast is not optional. It is the connective tissue that ties your Mac productivity to your AI-native workflow.

Whether you are building with n8n for automation, managing projects in Notion with AI agents, or comparing AI coding tools, Raycast gives you a single keyboard shortcut to access all of it. That is worth trying, and for most developers, it is worth keeping.

Last updated: April 2026. Pricing and features verified against raycast.com and manual.raycast.com. Raycast v1.99+ tested on macOS Sequoia.

Gamma AI Review 2026: I Built 50 Presentations — Here's the Honest Truth About AI Slide Generation

Jangwook Kim — Sun, 05 Apr 2026 14:44:04 +0000

Gamma AI Review 2026: I Built 50 Presentations — Here's the Honest Truth About AI Slide Generation

Every week, someone asks which AI presentation tool actually delivers on its promises. After building over 50 presentations, pitch decks, project briefs, and internal reports with Gamma AI over the past several months, I have a clear answer — but it comes with caveats that most reviews skip over.

Gamma AI turns a text prompt into a polished, card-based presentation in under 60 seconds. That part works exactly as advertised. What matters more is what happens after generation: how much editing you need, whether the output looks professional enough for real audiences, and what breaks when you try to export to PowerPoint or PDF.

This review covers everything from Agent v3.0's conversational design features to the real export limitations that Gamma's marketing does not mention prominently. If you are evaluating Gamma for client presentations, investor decks, or team communications, this is the review that will save you from surprises.

Affiliate Disclosure: This article contains affiliate links to Gamma AI via PartnerStack. If you sign up through our links, we may earn a commission at no extra cost to you. Gamma pays affiliates 30% recurring commission for one year through their PartnerStack program with a 60-day tracking cookie. See our affiliate disclosure for full details.

What Is Gamma AI?

Gamma AI is an AI-powered presentation, document, and web page builder that generates polished visual content from text prompts. Instead of building slides one by one in PowerPoint or Google Slides, you describe what you want and Gamma creates a complete, designed presentation in seconds.

Founded in 2020 and now serving over 70 million users globally, Gamma has grown into one of the most widely used AI content creation platforms. In November 2025, the company announced it had surpassed $100 million in annual recurring revenue and raised a $68 million Series B at a $2.1 billion valuation led by Andreessen Horowitz, placing it among the most successful AI-native productivity tools.

How Gamma Works

You enter a prompt or paste content — a topic, outline, document, or URL
Gamma generates a complete presentation — slides with text, images, layouts, and design elements
You refine with AI or manually — use Agent v3.0 for conversational edits or drag-and-drop for manual adjustments
You share or export — publish as a web page, present live, or export to PDF, PPTX, or PNG

The key difference from traditional tools is Gamma's card-based format. Instead of fixed-dimension slides, Gamma creates scrollable cards that adapt to content length. This means a single card can hold more information than a standard slide without forcing you to split content across multiple pages.

What Makes Gamma Different

Gamma is not just another slide generator. It creates three types of content from the same interface:

Presentations — card-based slides for live presenting or sharing
Documents — rich, designed documents that look better than a Google Doc
Web Pages — publishable one-click websites, no coding required

This versatility is genuinely useful. A single project brief can become a presentation for stakeholders, a document for the team, and a published web page for external partners — all from the same content.

If you are building content-driven workflows, Gamma fits naturally alongside tools like n8n for workflow automation or Notion AI for workspace management, creating a pipeline where AI handles the heavy lifting of content creation and formatting.

Gamma AI Features Deep-Dive

Gamma has evolved significantly beyond basic slide generation. Here is what the platform offers in 2026 and how each feature actually performs.

AI Generation Engine

Gamma leverages over 20 AI models to generate text, images, layouts, and design elements. The generation quality has improved noticeably over the past year, particularly in layout decisions and visual hierarchy.

What works well:

Topic-to-presentation generation consistently produces usable first drafts
Image selection and placement is contextually relevant most of the time
Text density is appropriate — Gamma avoids the wall-of-text problem that plagues many AI generators
Layout variety across cards keeps presentations visually interesting

Where it falls short:

Generated content tends toward generic language — you will need to inject specific data, examples, and your own voice
Image quality varies significantly depending on the topic; niche subjects get stock-photo-quality results
Occasionally generates redundant cards that repeat the same point with slightly different wording

Agent v3.0 — The Conversational Design Assistant

Agent v3.0 is Gamma's most significant recent feature and the closest thing to having a design collaborator available on demand. Instead of manually editing each card, you can describe changes in natural language and the Agent executes them across your entire presentation.

What Agent v3.0 can do:

Web research — search the web for information and pull in citations directly into your slides
Restyle entire decks — change the visual theme, color palette, or layout style with a single request
Refine content — incorporate links, screenshots, or documents you provide into existing presentations
Restructure flow — reorganize sections, merge cards, or split dense content across multiple slides
Localize content — translate and adapt presentations for different audiences

Real-world assessment: Agent v3.0 handles broad changes well — restyling a deck or adding a new section works reliably. It struggles with precise, surgical edits. Asking it to "make the third bullet point on card 7 more concise" sometimes affects other content unexpectedly. For precise editing, manual adjustment is still faster.

The web research capability is genuinely useful for creating data-backed presentations quickly. You can ask the Agent to find recent statistics on a topic and it pulls in sourced data points. However, you should verify every statistic it surfaces — AI-retrieved data is not always current or accurate.

Templates and Themes

Gamma offers a growing library of templates organized by use case: pitch decks, project updates, marketing plans, educational content, and more. Each template can be customized with your brand colors, fonts, and logo.

The template quality is above average compared to competitors. Layouts feel modern and clean rather than the cluttered, clip-art-heavy designs you still see in some tools. That said, the template library is smaller than Canva's. If you need highly specialized templates (restaurant menus, event programs, social media carousels), Canva still has broader coverage.

AI Animations

As of January 2026, Gamma generates AI-powered animations instead of static images in presentations. Cards can include subtle motion effects, animated transitions, and dynamic visual elements that make presentations feel more polished during live presenting.

The animations are tasteful and professional — Gamma has avoided the trap of adding distracting motion for its own sake. They work well in web-based presentations but do not translate to exported formats (more on this in the export section).

Analytics and Engagement Tracking

Pro plan and above users get presentation analytics: who viewed your presentation, how long they spent on each card, and where they dropped off. This is particularly valuable for sales decks and investor presentations where engagement data directly informs follow-up strategy.

The analytics dashboard is straightforward but effective. You see view counts, average time per card, and completion rates. It is not as sophisticated as dedicated analytics tools, but it gives you actionable data that PowerPoint and Google Slides simply do not provide.

Collaboration

Gamma supports real-time collaboration with multiple editors, comments, and sharing permissions. The collaboration experience is smooth — closer to Google Slides than the clunky co-authoring in PowerPoint.

Team workspaces allow you to organize presentations by project, share brand assets, and maintain consistent styling across your organization. The collaboration features work well for small to medium teams. Enterprise-level features like SSO and advanced permissions are available on higher-tier plans.

Gamma AI Pricing and Plans

Gamma uses a freemium model with credit-based AI generation. Here is the complete pricing breakdown as of April 2026. All prices reflect annual billing unless noted.

Individual Plans

Plan	Annual Price	Monthly Price	AI Credits	Key Features
Free	$0	$0	400 credits	Basic generation, Gamma watermark, limited templates
Plus	$8/mo	$10/mo	Unlimited AI	Remove watermark, custom brand colors and logo, basic brand kit
Pro	$15/mo	$20/mo	Unlimited AI	Custom branding, analytics, API access, up to 60-slide decks
Ultra	$90/mo	$100/mo	Unlimited AI	Advanced AI models, 75-card decks, early access features

Team and Enterprise Plans

Plan	Price per User (Annual)	Minimum Seats	Best For
Team	$20/mo	2 seats	Small teams needing shared workspaces
Business	$40/mo	10 seats	Larger organizations with SSO and admin controls

Source: Gamma pricing page

How AI Credits Work

The Free plan's 400 credits translate to roughly 10–15 full presentation generations, depending on length and complexity. Each generation, edit with Agent, and AI image creation consumes credits. Once you exhaust free credits, you need to upgrade — there is no pay-per-credit option.

Which Plan Should You Choose?

Free plan — good for testing Gamma and creating personal, non-client-facing content. The watermark ("Made with Gamma") makes it unsuitable for professional use. If you are presenting to investors, clients, or executives, the watermark undermines credibility.

Plus plan ($8/mo) — the sweet spot for most individual users. Unlimited AI generation and watermark removal cover 90% of use cases. If you primarily need to create presentations quickly without advanced analytics, this is the plan.

Pro plan ($15/mo) — justified if you need presentation analytics, API access, or extended deck lengths. Sales teams and consultants who need engagement tracking will find the upgrade worthwhile.

Ultra plan ($90/mo) — only makes sense if you need access to the most advanced AI models and consistently create very long presentations. For most users, Pro covers everything needed.

Getting Started with Gamma AI — Step-by-Step Tutorial

Here is how to go from zero to your first AI-generated presentation in under five minutes.

Step 1: Sign Up

Visit gamma.app and create an account with Google, email, or SSO. No credit card required for the free plan. You get 400 AI credits immediately.

Step 2: Choose Your Content Type

From the dashboard, click Create New and select your content type:

Presentation — card-based slides for presenting
Document — rich formatted documents
Webpage — publishable web pages

For this tutorial, select Presentation.

Step 3: Provide Your Input

You have several input options:

Text prompt — describe your topic and Gamma generates everything ("Create a 10-slide pitch deck for a B2B SaaS startup in the project management space")
Paste content — paste existing text, notes, or an outline and Gamma formats it into slides
Import — upload a document, PDF, or provide a URL for Gamma to convert
Template — start from a pre-designed template and customize

For the best results with a text prompt, be specific about your audience, the number of slides, and the key points you want covered. Vague prompts produce vague presentations.

Step 4: Select a Theme

After entering your prompt, Gamma presents theme options. Choose a visual style that matches your brand or purpose. You can change this later, so do not overthink it.

Step 5: Review and Generate

Gamma shows you a proposed outline before generating. This is your chance to add, remove, or reorder sections. Take a moment to adjust the outline — it is much faster to restructure at this stage than after generation.

Click Generate and Gamma creates your full presentation in 30–60 seconds.

Step 6: Refine Your Presentation

This is where the real work happens. Review each card and:

Replace generic text with specific data, examples, and your own insights
Swap AI-generated images with your own screenshots or brand visuals where appropriate
Adjust the layout of any cards that feel cluttered or sparse
Use Agent v3.0 for broad changes like restyling or adding new sections

A realistic estimate: a 10-card presentation takes 15–30 minutes to refine after AI generation. Gamma gives you 70% of the work done — you provide the final 30% that makes it yours.

Step 7: Share or Export

Choose your distribution method:

Present — full-screen presentation mode directly in Gamma
Share link — anyone with the link can view (analytics available on Pro+)
Export — PDF, PPTX, PNG, or Google Slides
Publish as webpage — one-click publish with a custom URL

Agent v3.0 Walkthrough — Your AI Design Assistant

Agent v3.0 deserves a deeper look because it fundamentally changes how you interact with Gamma. Instead of clicking through menus and dragging elements, you have a conversation with an AI that understands your entire presentation.

How to Use Agent v3.0

Open any presentation and click the Agent button (or press the keyboard shortcut)
Type your request in natural language
Agent processes the request and applies changes across your presentation
Review the changes and accept, undo, or refine further

Effective Agent Commands

Here are the types of requests that work best with Agent v3.0:

Content additions:

"Add a slide about our competitive advantages after the market overview"
"Include recent statistics about the AI presentation market"
"Create a timeline showing our product roadmap for 2026"

Visual changes:

"Change the color scheme to dark blue and white"
"Make the design more minimalist — reduce visual clutter"
"Use a consistent icon style throughout the presentation"

Structural edits:

"Combine the last three slides into a single summary slide"
"Move the pricing section before the features section"
"Split the long features card into three separate cards"

Research-backed updates:

"Research the latest market size data for AI presentation tools and add it to the market overview slide"
"Find three customer testimonial examples for SaaS pitch decks and add a testimonials section"

Agent v3.0 Limitations

Be aware of these real limitations:

Precision editing is unreliable — asking for changes to specific elements sometimes affects neighboring content
Complex multi-step requests sometimes partially fail — break complex requests into smaller steps
Research citations need verification — the Agent pulls data from the web, but you must verify accuracy
Undo is all-or-nothing — you cannot selectively accept some Agent changes while rejecting others

Despite these limitations, Agent v3.0 is a genuine productivity multiplier. It handles the tedious parts of presentation editing — restyling, restructuring, adding boilerplate sections — so you can focus on the content that matters.

Output Quality Analysis — The Honest Assessment

This is where most Gamma reviews fall short. They show the best-case outputs and skip the messy reality. Here is what you actually get across different use cases.

Design Quality: 7/10

Gamma's design output is consistently good but rarely exceptional. Presentations look modern, clean, and professional — better than what most people create manually in PowerPoint. But they have a recognizable "AI-generated" aesthetic. Experienced designers will spot Gamma output immediately.

The card-based format is both a strength and a limitation. It works beautifully for web viewing and scrollable content. It feels less natural for traditional boardroom presentations where audiences expect standard slide dimensions.

Content Quality: 5/10 (Before Editing) → 8/10 (After Editing)

Raw AI-generated content is a starting point, not a finished product. Expect generic language, safe statements, and a tendency to list features without explaining why they matter. The content is structurally sound — headings, bullet points, and flow are logical — but it lacks the specificity and insight that make presentations compelling.

After 15–30 minutes of editing per 10-card presentation, the output quality jumps significantly. Gamma handles formatting and structure so well that your editing time goes almost entirely toward improving the actual content.

Image Quality: 6/10

AI-generated images are hit or miss. Common business topics (teamwork, technology, growth) get decent results. Niche topics (specific industries, technical concepts, regional contexts) often get generic or irrelevant images. Plan to replace at least 30–50% of generated images with your own.

Overall Assessment

Gamma excels at speed and structure. It is the fastest path from "I need a presentation" to "I have a presentable draft." It does not excel at creating presentations that feel handcrafted, unique, or deeply customized. If your presentations need to stand out visually — investor decks, creative pitches, brand launches — Gamma is a starting point, not the finish line.

For internal communications, team updates, project briefs, and educational content, Gamma's output quality is more than sufficient with minimal editing.

Gamma AI vs Alternatives — Comparison Table

The AI presentation landscape has shifted significantly. Notably, Tome — once a major competitor with over 20 million users — discontinued its presentation feature in early 2025 to pivot toward sales automation. Here is how the remaining major players compare.

Feature	Gamma AI	Canva	Beautiful.ai	PowerPoint (Copilot)	Google Slides
AI Generation	Full presentation from prompt	Outline-level AI, manual refinement needed	AI layout suggestions, less generative	Copilot adds AI to existing slides	Limited AI features
Generation Speed	~30 seconds	1–2 minutes	1–2 minutes	Varies	N/A
Design Quality	Modern, card-based	Broadest template library	Best automated design	Traditional slide format	Basic
Agent/Chat AI	Agent v3.0 (conversational)	Magic Design	Limited	Copilot chat	Gemini integration
Export to PPTX	Problematic (layout shifts)	Good	Best fidelity	Native	Good
Export to PDF	Good	Good	Good	Native	Good
Analytics	Pro plan and above	Business plan	Pro plan	Via SharePoint	Limited
Collaboration	Real-time, team workspaces	Excellent, mature	Good	Excellent via 365	Excellent
Free Plan	400 credits	Generous free tier	No free plan	Requires 365 license	Free
Starting Price	$8/mo	$13/mo (Pro)	$12/mo	Included in 365 ($7/mo+)	Free
Best For	Fast AI generation, web-first content	Multi-format design, broad templates	Design-focused teams	Enterprise, Office ecosystem	Budget-conscious teams

When to Choose Gamma

You need presentations fast and want AI to handle the first draft
Your primary distribution is web links or live presenting (not PPTX files)
You create presentations, documents, and web pages from the same platform
Agent v3.0's conversational editing matches your workflow

When to Choose an Alternative

Choose Canva if you need the broadest template library and multi-format design (social, print, video, presentations)
Choose Beautiful.ai if design quality and PPTX export fidelity are your top priorities
Choose PowerPoint with Copilot if your organization is embedded in the Microsoft 365 ecosystem
Choose Google Slides if you need free, reliable collaboration and basic presentations

For teams building AI-powered content pipelines, consider how Gamma fits with other tools in your stack. Our guide to building with 14 AI agents shows how AI tools work together in practice. And if you are optimizing your content for search, Surfer SEO can help ensure your Gamma-published web pages rank well.

Export and Sharing — What Actually Works

Export is where Gamma's web-first architecture creates real friction. Understanding these limitations before you commit to Gamma for a critical project will save you from deadline-day panic.

Web Sharing (Best Experience)

Sharing via link is Gamma's strongest distribution method. Recipients get the full experience: animations, interactive elements, responsive layout, and analytics tracking. If your audience can view a web link, this is always the recommended option.

PDF Export (Reliable)

PDF export preserves visual layout faithfully. What you see in Gamma is very close to what you get in the PDF. Gradient headings may render slightly differently, and interactive elements become static, but the overall quality is consistent. This is the safest export option for offline distribution.

PowerPoint (PPTX) Export (Problematic)

This is Gamma's most significant weakness and the limitation you must understand before choosing it. PPTX export introduces:

Layout shifts — elements become misaligned or resized incorrectly
Font substitution — custom fonts may not transfer; system fonts substitute and change the visual feel
Dimension mismatches — Gamma's card format does not map cleanly to standard slide dimensions
Static conversion — all interactive elements, animations, and embedded content become static images
Gradient issues — gradient headings may default to a single color

Realistic expectation: budget 15–30 minutes of cleanup time in PowerPoint after exporting a 15-slide deck. For complex presentations with custom layouts, expect more.

If your workflow requires delivering final presentations in PPTX format — common in corporate environments — Beautiful.ai offers significantly better export fidelity. Consider using Gamma for drafting and ideation, then rebuilding critical slides in PowerPoint or Beautiful.ai for final delivery.

PNG Export

Individual cards export as PNG images. Quality is good and useful for embedding presentation visuals in documents, emails, or social media. This is a straightforward feature that works as expected.

Google Slides Export

Available as an export option, the quality falls between PDF (good) and PPTX (problematic). Some formatting adjustments are needed, but less than with PowerPoint.

Publishing as a Web Page

One of Gamma's unique strengths. You can publish any presentation as a standalone web page with a custom URL, no coding required. This is excellent for portfolio pieces, product pages, and public-facing content. The published pages are responsive and include Gamma's analytics if you are on a Pro plan or above.

Who Is Gamma AI Best For?

After extensive use, here are the audiences that get the most value from Gamma — and the ones who should look elsewhere.

Gamma Is Excellent For:

Startup founders and solo entrepreneurs who need investor decks, pitch presentations, and project briefs fast. The speed advantage is massive when you are wearing multiple hats and cannot spend hours on slide design.

Marketing teams creating campaign briefs, strategy presentations, and client reports. The combination of AI generation and web publishing means you can go from idea to shareable content in minutes.

Educators and trainers building course materials, lecture slides, and educational content. The card-based format works particularly well for learning content that students scroll through at their own pace.

Content creators who need visual content for blogs, newsletters, and social media. Gamma's web publishing turns presentations into shareable content pieces. If you are building content workflows with automation tools like n8n, Gamma's API (Pro plan) can integrate into your pipeline.

Internal communications teams producing company updates, onboarding materials, and team reports where speed matters more than pixel-perfect design.

Gamma Is Not Ideal For:

Corporate environments requiring PPTX delivery — if your client or executive team expects a PowerPoint file, Gamma's export limitations will create extra work.

Design-focused agencies where every presentation must be visually unique and brand-perfect. Gamma's output, while clean, has a recognizable aesthetic that limits differentiation.

Data-heavy presentations with complex charts, custom graphs, and detailed tables. Gamma handles basic data visualization but cannot match dedicated tools like PowerPoint or Beautiful.ai for complex data presentations.

Offline-first workflows — if your presentations are primarily delivered in environments without internet access, Gamma's web-first approach is a disadvantage.

Pros and Cons — Honest Assessment

Pros

Speed is unmatched — prompt to presentation in under 60 seconds
Agent v3.0 is genuinely useful — conversational editing saves significant time on broad changes
Three-in-one platform — presentations, documents, and web pages from one tool
Web publishing is excellent — one-click publish creates professional web pages
Generous free plan — 400 credits let you thoroughly evaluate before paying
Modern design output — clean, contemporary layouts that look professional
Analytics on Pro plan — engagement tracking that PowerPoint and Google Slides lack
Active development — regular feature updates including AI animations (January 2026)

Cons

PPTX export is unreliable — layout shifts, font issues, and dimension mismatches require manual cleanup
Card format is non-standard — does not map to traditional 16:9 slide expectations
AI content needs significant editing — generated text is generic and requires your expertise to become compelling
Image quality is inconsistent — niche topics get poor AI-generated visuals
Agent v3.0 lacks precision — broad changes work well, surgical edits are unreliable
Template library is smaller than Canva — fewer specialized templates for niche use cases
Pricing adds up for teams — team plans start at $20/seat/month, which scales quickly
Web-dependent — limited offline functionality compared to desktop applications

Frequently Asked Questions

Is Gamma AI free?

Yes, Gamma offers a free plan with 400 AI credits. This translates to roughly 10–15 full presentation generations. The free plan includes a "Made with Gamma" watermark on all content. Paid plans start at $8/month (annual billing) with the Plus plan, which removes the watermark and provides unlimited AI generation.

Can I export Gamma presentations to PowerPoint?

Yes, but with significant caveats. PPTX export introduces layout shifts, font substitution, and dimension mismatches. Budget 15–30 minutes for manual cleanup after exporting. PDF export is more reliable if you need an offline format. For the best experience, share via Gamma's web link.

Is Gamma AI better than Canva for presentations?

It depends on your priority. Gamma is faster for AI-generated presentations and better for web-first content. Canva has a broader template library, better export fidelity, and a more mature design ecosystem. If speed and AI generation are your top priorities, choose Gamma. If you need multi-format design versatility, choose Canva.

What is Gamma Agent v3.0?

Agent v3.0 is Gamma's conversational AI design assistant. It allows you to edit presentations through natural language commands — restyling entire decks, adding research-backed content, restructuring sections, and more. It works well for broad changes but struggles with precise, element-level edits.

How many presentations can I make with Gamma's free plan?

The 400 free credits support approximately 10–15 full presentation generations, depending on length and complexity. Each generation, AI edit, and image creation consumes credits. There is no way to earn additional free credits — once exhausted, you must upgrade to a paid plan.

Does Gamma AI work for investor pitch decks?

Gamma can generate a solid first draft of an investor pitch deck quickly. However, investor presentations demand polish, specific financial data, and a unique visual identity that AI generation alone cannot provide. Use Gamma for rapid drafting, then invest time refining content, replacing generic visuals, and ensuring every data point is accurate. If you must deliver in PowerPoint format, be aware of export limitations.

Can I use Gamma AI for team collaboration?

Yes, Gamma supports real-time collaboration with multiple editors, comments, and team workspaces. Free and Plus plans support basic sharing. Team plans ($20/seat/month, 2-seat minimum) add shared workspaces and brand assets. Business plans ($40/seat/month, 10-seat minimum) include SSO and advanced admin controls.

What happened to Tome as a Gamma alternative?

Tome, once a major AI presentation competitor with over 20 million users, discontinued its presentation feature in early 2025 and pivoted to sales automation. Tome Slides officially shut down on April 30, 2025. If you were a Tome user looking for an alternative, Gamma is the closest replacement for AI-powered presentation generation.

Is Gamma AI content original?

Gamma generates content using AI models, so the text and images are generated rather than copied from existing sources. However, AI-generated content can be generic and may overlap with common phrasing. For SEO purposes, you should significantly edit and personalize AI-generated content before publishing. Tools like Surfer SEO can help you optimize Gamma-published web pages for search engines.

Does Gamma have an API?

Yes, API access is available on the Pro plan ($15/month annual) and above. This enables integration with other tools and automation workflows. For teams building AI-powered content pipelines — similar to how we use Claude Code for development workflows — the API opens up programmatic presentation generation.

Final Verdict

Gamma AI is the fastest path from idea to presentable content in 2026. Agent v3.0 adds a genuinely useful conversational editing layer that no competitor matches. The combination of presentations, documents, and web pages in a single platform creates real workflow efficiency.

But Gamma is not a complete PowerPoint replacement. The PPTX export limitations are real and significant for anyone operating in corporate environments where PowerPoint files are the standard deliverable. The card-based format, while excellent for web viewing, creates friction when audiences expect traditional slides.

The right way to use Gamma: treat it as a drafting and ideation powerhouse that gets you to 70% in seconds, then invest your expertise in the final 30% that makes content compelling. For web-first distribution — shared links, published pages, live presentations — Gamma delivers an experience that traditional tools cannot match.

At $8/month for the Plus plan with unlimited AI generation, Gamma offers strong value for anyone who creates presentations regularly. Start with the free plan's 400 credits to test whether Gamma's output matches your quality expectations before committing.

Try Gamma AI Free →

Surfer SEO Review 2026: AI Content Optimization From Audit to First Page

Jangwook Kim — Sun, 05 Apr 2026 14:27:54 +0000

Originally published on Effloow

Surfer SEO Review 2026: AI Content Optimization From Audit to First Page

Most SEO tools tell you what keywords to target. Surfer SEO tells you exactly how to structure, write, and optimize your content so it actually ranks. The difference matters when you are competing against thousands of pages targeting the same keyword.

Surfer reverse-engineers the top-ranking pages for any keyword, identifies the patterns they share — word count, heading structure, NLP entities, keyword density, image usage — and gives you a real-time score as you write. Instead of guessing what Google wants, you are building content against a data-driven blueprint.

This is not a surface-level overview. We break down every major feature, walk through the setup process step by step, show you how the AI Writer and Content Audit actually work, compare Surfer against Clearscope, Frase, and MarketMuse with real pricing data, and give you an honest assessment of where Surfer excels and where it falls short.

Affiliate Disclosure: This article contains affiliate links to Surfer SEO via PartnerStack. If you sign up through our links, we may earn a commission at no extra cost to you. Surfer SEO pays affiliates via their PartnerStack program with a tiered CPA commission structure. See our affiliate disclosure for full details.

What Is Surfer SEO?

Surfer SEO is an AI-powered content optimization platform that analyzes search engine results pages (SERPs) and provides data-driven recommendations for creating content that ranks. Founded in 2017, Surfer has grown to over 150,000 users including content creators, SEO agencies, and marketing teams.

At its core, Surfer does one thing exceptionally well: it takes the guesswork out of on-page SEO. Rather than relying on generic best practices or gut instinct, Surfer analyzes the actual top-ranking pages for your target keyword and tells you exactly what your content needs to compete.

How Surfer Works

You enter a target keyword — Surfer crawls the top 10–20 results on Google for that keyword
Surfer analyzes the patterns — word count, heading structure, keyword frequency, NLP terms, images, paragraph length, and dozens of other ranking factors
You get a Content Score — a real-time 0–100 score that updates as you write, telling you how well your content matches the ranking signals
You optimize until the score is green — Surfer highlights exactly what to add, remove, or restructure

This is fundamentally different from keyword research tools like Ahrefs or SEMrush. Those tools tell you what to write about. Surfer tells you how to write it so it ranks.

Who Uses Surfer SEO

Solo bloggers who want data-backed content instead of guessing at SEO
Content agencies producing high-volume optimized articles for clients
In-house SEO teams standardizing content quality across writers
Affiliate marketers optimizing product reviews and comparison pages for search traffic
SaaS companies building organic content engines for lead generation

If your business depends on organic search traffic, Surfer is built for you. If you are doing social media marketing or paid ads exclusively, you will not get much value from it.

Surfer SEO Features Deep-Dive

Surfer has expanded well beyond its original Content Editor. Here is what the platform offers in 2026 and what each feature actually does.

Content Editor

The Content Editor is Surfer's flagship feature and the reason most people sign up. It is a writing workspace where you create content with real-time SEO feedback.

How it works:

You enter your target keyword, and Surfer generates a set of guidelines based on SERP analysis. These guidelines include:

Suggested word count — based on the average length of top-ranking content
Heading structure — recommended number of H2s and H3s with suggested topics
Keywords and NLP terms — a prioritized list of terms to include, with suggested frequency
Image recommendations — how many images top-ranking pages typically include
Paragraph structure — optimal paragraph length and density

As you write (or paste existing content), a Content Score updates in real time. Scores above 70 are typically competitive. Scores above 80 indicate strong optimization.

What changed in 2026:

Content Editor outlines now use full brand, AI, and SEO context. They are shorter, more natural, and structured like top-ranking articles instead of generic templates. AI Search guidelines are now available to all users, providing real-time suggestions for citation-optimized writing. The Auto-Optimize feature can automatically add missing entities and facts in one click.

The new Workflow tab walks you through every step from blank document to fully optimized content — helpful if you are new to Surfer or training a team of writers.

Surfer AI (AI Writer)

Surfer AI generates full articles optimized for your target keyword. You provide the keyword, select a tone, choose your target audience, and Surfer produces a complete draft with headings, internal structure, and NLP optimization already built in.

What makes it different from ChatGPT or other AI writers:

Every paragraph Surfer AI generates is guided by the same SERP analysis that powers the Content Editor. The output is not generic AI text — it is structured specifically to match what is ranking for your keyword. You get:

Heading structure matching top-ranking content patterns
NLP terms and entities integrated naturally throughout
Proper keyword density from the start
A Content Score that is already competitive before you edit

Surfer AI credits are purchased separately from your subscription. They are not included in the base plan — this is a common point of confusion for new users.

When to use Surfer AI vs. writing manually:

Use Surfer AI when you need a solid first draft quickly, especially for informational content where the structure follows predictable patterns (how-to guides, listicles, comparison pages). The overlap between vibe coding and content creation is growing as more teams use AI to generate structured output at speed. Write manually when the topic requires original research, personal experience, or a distinctive voice that AI cannot replicate.

SERP Analyzer

The SERP Analyzer is Surfer's research tool for understanding why specific pages rank. It breaks down the top results for any keyword across dozens of metrics:

Word count distribution
Heading count and structure
Keyword density and placement
Number of images
Page load speed
Domain authority indicators
Backlink profiles
Exact keyword usage in titles, meta descriptions, and headings

This is the feature that separates Surfer from simpler content optimization tools. Instead of just telling you to "include more keywords," the SERP Analyzer shows you the exact patterns that correlate with rankings for your specific keyword.

Practical use: Before writing a new article, run SERP Analyzer on your target keyword. Look for patterns — if all top-ranking pages have 2,000+ words, 8+ images, and use a specific set of NLP terms, you know what your content needs to compete.

The SERP Analyzer is available on the Scale plan and above.

Topical Map

The Topical Map helps you plan an entire content strategy around a topic cluster. Enter a broad topic, and Surfer maps out all the subtopics you should cover, their relationships, and the content gaps on your site.

What the Topical Map gives you:

A visual map of topic clusters and content relationships
Keyword suggestions for each subtopic
Identification of content gaps — topics your competitors cover but you do not
Priority scoring based on search volume and competition
Automatic refresh every 14 days to reflect SERP changes

In 2026, Surfer added bulk operations to the Topical Map — you can select multiple articles at once to archive or create Content Editor and AI articles in bulk, which speeds up content production significantly.

The Topical Map is where you plan. The Content Editor is where you execute. Using both together is where Surfer becomes most powerful.

Content Audit

The Content Audit analyzes your existing published pages and tells you exactly what to change to improve rankings. This is Surfer's answer to the question: "I have 200 articles on my blog. Which ones should I update and how?"

How Content Audit works:

Connect your Google Search Console account to Surfer
Surfer scans your site and identifies pages with ranking potential
For each page, you get specific recommendations: add these keywords, remove this section, increase word count, restructure headings
A priority score tells you which pages to update first for maximum impact

This feature alone can justify the subscription cost. Most sites have dozens of underperforming pages that are one update away from significantly better rankings. Content Audit finds them and tells you exactly what to fix.

Surfy (AI Assistant)

Surfy is Surfer's upgraded in-platform AI assistant that helps you research, write, edit, and repurpose articles. It lives inside the Content Editor and acts like a co-writer that understands your SEO targets.

You can ask Surfy to:

Research a subtopic and suggest content to add
Rewrite a section in a different tone
Expand a bullet list into detailed paragraphs
Generate FAQ sections based on "People Also Ask" data
Suggest internal linking opportunities

Surfy was significantly upgraded in early 2026, and it now functions more like a real assistant than a basic chatbot.

AI Tracker

The AI Tracker is Surfer's newest major feature, designed for the era of AI-powered search. It monitors how your brand appears in AI-generated search results (Google AI Overviews, ChatGPT, Perplexity, and now Gemini).

What AI Tracker monitors:

Whether your brand is cited in AI-generated answers
Which competitors are being mentioned instead of you
Mention Gap analysis — where competitors appear in AI search but you do not
Sentiment Analysis — how AI models describe your brand versus competitors

This is forward-looking functionality that most SEO tools do not offer yet. As AI search grows, understanding your visibility in AI-generated results becomes as important as traditional SERP rankings. If you want to control how AI crawlers access your site before tracking their behavior, try our AI Crawler Control Panel to generate and manage your robots.txt and AI-specific directives.

AI Tracker is available as an add-on or included in higher-tier plans.

Sites (Mission Control)

Surfer Sites is the 2026 hub that brings Dashboard, Content Audit, and Topical Map together in one unified view. Instead of jumping between separate tools, you get a single screen showing:

Overall site health and content scores
Pages that need attention, ranked by priority
Content gaps from your Topical Map
Performance trends over time

Sites also includes improved filtering and analysis, making it easier to manage content operations for multiple domains through the Workspaces feature.

Surfer SEO Pricing and Plans (2026)

Surfer restructured its pricing in January 2026. Here is the current plan breakdown.

Plan	Monthly Price	Annual Price (per month)	Content Editor Articles	Content Audits	Team Members	Key Features
Essential	$99/mo	$79/mo	30/month	10/month	2	Content Editor, Keyword Research (100 searches/day), Topical Map, Surfy
Scale	$219/mo	$175/mo	100/month	30/month	5	Everything in Essential + SERP Analyzer, Rank Tracker, AI Tracker basic
Enterprise	Custom	Custom	Custom	Custom	Custom	Everything in Scale + API access, dedicated support, custom integrations

Source: Surfer SEO Pricing Page

Important notes on pricing:

Surfer AI credits are sold separately. The base plans include Content Editor access but not AI-generated articles. AI credits are purchased as add-ons.
Annual billing saves up to 17% compared to monthly payments. Annual plans grant all credits in a single yearly batch.
The pricing structure changed on January 29, 2026. If you subscribed before that date, your plan may differ from current offerings.
No free plan exists. Surfer does not offer a permanently free tier, but they occasionally run trial promotions.

Is the Price Worth It?

At $99/month for the Essential plan, Surfer is a mid-range investment. Compare this to:

Clearscope: $170/month starting price — significantly more expensive
Frase: $14.99/month (Solo) to $44.99/month (Team) — considerably cheaper but fewer features
MarketMuse: Free tier available, $149/month for Standard — free option exists but paid tier is more expensive

If you publish 10+ articles per month and organic search is a primary traffic channel, the $99/month quickly pays for itself through improved rankings. If you publish less frequently, Frase might be a more cost-effective choice. For a broader look at how AI tools compare on price, see our AI tool pricing comparison.

For agencies managing multiple clients, the Scale plan at $219/month with 100 articles and 5 team members provides strong value per article.

Getting Started With Surfer SEO: Step-by-Step Tutorial

Here is how to go from signup to your first optimized article.

Step 1: Create Your Account

Visit surferseo.com and sign up for the Essential plan. You will need an email address and payment method. The onboarding flow asks about your use case — answer honestly, as this customizes your dashboard.

Step 2: Set Up Your First Site

After signing in, go to Sites and add your website domain. If you have Google Search Console connected, Surfer will import your existing pages and performance data automatically. This step is optional for writing new content but essential for Content Audit.

Step 3: Use Topical Map to Plan Content

Navigate to Topical Map and enter your main topic. For example, if your site covers AI tools, enter "AI tools" as your seed topic. Surfer generates a cluster map showing:

Primary topics to cover
Supporting subtopics and their relationships
Search volume estimates for each topic
Content gaps on your site

Select a topic from the map that aligns with your strategy and click Create Content Editor to start writing.

Step 4: Write Your First Article in Content Editor

The Content Editor opens with your target keyword pre-loaded. On the left side, you see your writing area. On the right, Surfer shows:

Content Score (your target: 70+)
Word count target (based on SERP analysis)
Keywords to include with suggested frequency
Heading suggestions
NLP terms that top-ranking content uses

Start writing. As you type, the Content Score updates in real time. The keyword panel shows which terms you have covered (green), which need more mentions (yellow), and which you have overused (red).

Pro tip: Use the new Workflow tab if this is your first time. It guides you through outlining, drafting, and optimizing in a structured sequence.

Step 5: Optimize Until Your Score Is Green

A Content Score of 70+ means your content is competitive. 80+ means it is strongly optimized. Focus on:

Hitting the word count range — do not pad with filler, but cover the topic thoroughly
Including all primary keywords at their suggested frequency
Using NLP terms naturally — these are the topical signals that differentiate thorough content from thin content
Matching the heading structure — if top-ranking pages use 8 H2s, you probably need a similar depth

Step 6: Use Facts & Coverage Booster

Before publishing, use Surfer's Facts & Coverage Booster inside the Content Editor. It scans your draft for factual gaps and missing topical depth, then suggests specific statements and data points sourced from SERPs. One click adds them to your content.

This is especially useful for data-heavy topics where you might miss key statistics or industry benchmarks that top-ranking articles include.

Step 7: Publish and Track

Export your article (Surfer supports copy-to-clipboard, HTML export, and direct integration with WordPress and Google Docs) and publish it on your site. If you are building your site with AI website builders like Framer, you can paste optimized content directly into your pages. Use Content Audit later to track how the article performs and what adjustments might improve its ranking.

AI Writer Walkthrough: Creating an Optimized Article With Surfer AI

Let us walk through using Surfer AI to generate a complete article.

Setting Up an AI Article

From your dashboard, click Create and select Surfer AI
Enter your target keyword (example: "best project management tools for startups")
Choose your settings:
- Tone of voice — professional, casual, academic, etc.
- Target audience — who is reading this content
- Competitors to analyze — Surfer suggests top-ranking pages, but you can add specific URLs
- Structure preferences — let Surfer auto-generate or provide your own outline

What Surfer AI Produces

Within a few minutes, Surfer AI generates a complete article that includes:

A title optimized for your target keyword
H2 and H3 headings matching top-ranking content structure
NLP terms and entities integrated throughout
A Content Score that is typically 60–75 out of the box
Proper keyword distribution across sections

Editing the AI Output

Surfer AI output is a strong starting point, not a finished article. Here is what you should always edit:

Add personal experience or original data. AI-generated content lacks unique insights. Add your own examples, case studies, or test results.
Verify all claims. Surfer AI can generate plausible-sounding but inaccurate statements. Fact-check every statistic and product detail.
Adjust the voice. The default tone is competent but generic. Inject your brand personality.
Optimize the Content Score to 80+. The initial score is competitive but not dominant. Use the Content Editor guidelines to push it higher.
Add images and media. Surfer AI generates text only. You need to add relevant images, screenshots, and diagrams.

Surfer AI Credit Costs

Surfer AI credits are purchased separately. Check the Surfer AI pricing page for current per-article costs. Budget for this on top of your subscription if you plan to use AI generation at scale.

Content Audit: How to Improve Existing Articles With Surfer

If you have a library of existing content, Content Audit is potentially the highest-ROI feature in Surfer.

Running Your First Audit

Connect Google Search Console to Surfer (Settings → Integrations)
Navigate to Content Audit under your site
Surfer scans your indexed pages and identifies optimization opportunities
Each page gets a current Content Score and a list of specific improvements

What Content Audit Recommends

For each page, Surfer provides actionable recommendations:

Missing keywords — terms that top-ranking competitors use but your page does not
Keyword overuse — terms you have stuffed that might trigger over-optimization penalties
Word count adjustments — whether your content is too thin or unnecessarily long
Heading restructure — how to reorganize your H2/H3 structure for better topical coverage
NLP term gaps — entity and topic coverage that your content is missing

Prioritizing Updates

Not every page is worth updating. Focus on pages that:

Rank on page 2 or top of page 3 (positions 11–30) — these are closest to page 1 with the least effort
Have declining traffic trends — they need a refresh
Cover high-value keywords for your business
Have high impressions but low click-through rates — the content is visible but not compelling enough

Content Audit assigns priority scores to help you focus. Start with the highest-priority pages and work down.

Audit Workflow Example

Here is a realistic workflow for updating existing content:

Run Content Audit across your site
Export the top 10 priority pages
Open each in Content Editor to see specific recommendations
Update the content — add missing sections, refresh outdated data, improve heading structure
Republish with an updated date
Monitor ranking changes over the next 2–4 weeks

This process is where many SEO teams see the fastest results from Surfer. New content takes months to rank. Updated existing content often improves within weeks.

If you are running content operations at scale, consider pairing Content Audit with workflow automation tools. For example, you can use n8n to build automated workflows that trigger content review tasks based on ranking drops detected through your analytics pipeline.

Surfer SEO vs Alternatives: Honest Comparison

Here is how Surfer stacks up against the major alternatives in 2026.

Feature	Surfer SEO	Clearscope	Frase	MarketMuse
Starting Price	$99/mo	$170/mo	$14.99/mo	Free (limited)
Content Editor	Yes (real-time score)	Yes (A++ grading)	Yes (topic score)	Yes (content score)
AI Writer	Yes (separate credits)	No	Yes (included)	Yes (limited in free)
SERP Analyzer	Yes (Scale plan+)	Basic	Basic	Yes
Topical Map	Yes	No	Yes (basic)	Yes (advanced)
Content Audit	Yes (GSC integration)	No	No	Yes (inventory)
AI Search Tracking	Yes (AI Tracker)	No	No	No
WordPress Plugin	Yes	Yes	Yes	No
Google Docs Integration	Yes	Yes	No	No
Team Collaboration	2–5+ members	Unlimited (Enterprise)	3+ members	1+ members
NLP Depth	Deep (multi-factor)	Moderate	Moderate	Deep (topic modeling)
Learning Curve	Moderate	Easy	Easy	Steep

Surfer SEO vs Clearscope

Choose Surfer if: You want the deepest optimization data, AI writing capabilities, and content audit functionality in one platform. Surfer offers significantly more features at a lower price point.

Choose Clearscope if: Your team needs the simplest possible tool. Clearscope's A++ grading system is intuitive enough that non-SEO writers can use it independently without training. You are willing to pay a premium for simplicity.

The accuracy gap between Surfer and Clearscope has narrowed significantly in 2026. Both provide solid optimization recommendations. The difference is in depth and price.

Surfer SEO vs Frase

Choose Surfer if: You need a complete optimization platform with SERP analysis, content audit, topical mapping, and AI search tracking. You publish content at volume and need robust team features.

Choose Frase if: Budget is your primary constraint. At $14.99/month for the Solo plan, Frase offers solid content optimization at a fraction of Surfer's cost. Frase is also strong for content briefs — useful if you manage freelance writers.

Frase is the best budget option for solo bloggers and freelancers. Surfer is the better choice for teams and agencies.

Surfer SEO vs MarketMuse

Choose Surfer if: Your focus is optimizing individual articles and getting them to rank. Surfer's Content Editor provides more granular, actionable guidance for the actual writing process.

Choose MarketMuse if: Your primary need is content strategy at scale. MarketMuse maps your entire content landscape and identifies topical authority gaps. It is less of a writing tool and more of a strategic planning engine.

Many serious content operations use both — MarketMuse for strategy and Surfer for execution.

Surfer SEO vs SEMrush Writing Assistant

Choose Surfer if: Content optimization is your primary use case and you want the deepest on-page SEO guidance available.

Choose SEMrush if: You already use SEMrush for keyword research, backlink analysis, and technical SEO, and you want a decent writing assistant integrated into your existing workflow. SEMrush's Writing Assistant is good but less specialized than Surfer.

Who Is Surfer SEO Best For?

Surfer Is an Excellent Fit For:

Content agencies producing 20+ articles per month for clients — the Content Score provides a measurable quality standard
SEO teams that need to standardize content quality across multiple writers
Affiliate marketers writing product reviews and comparison content where ranking determines revenue
SaaS marketing teams building organic content engines — Surfer's Topical Map plus Content Editor is a powerful combination
Anyone publishing content where organic search traffic is the primary distribution channel

Surfer Is Not the Best Fit For:

Occasional bloggers who publish 1–2 articles per month — the $99/month may not justify the output volume
Teams focused exclusively on social media or paid advertising — Surfer optimizes for search engines, not social algorithms
Content creators who prioritize creative writing over optimization — poets and fiction writers should look elsewhere
Very technical or niche topics with low search volume — Surfer needs sufficient SERP data to generate useful recommendations. If only 3 pages rank for your keyword, the analysis is less reliable.
Teams that already use MarketMuse or Clearscope successfully — switching costs may outweigh the marginal benefits

Pros and Cons: Honest Assessment

Pros

The Content Editor is genuinely best-in-class. The real-time scoring based on SERP analysis is more actionable than any competing product we have tested.
Content Audit finds hidden opportunities. Identifying underperforming pages that need small updates to rank significantly better is where most sites see the fastest ROI.
Topical Map eliminates guesswork in content planning. Instead of brainstorming topics, you get a data-driven map of what to write and in what order.
AI Tracker is forward-thinking. Monitoring AI search visibility is a feature most tools have not built yet. This positions Surfer well for the AI search era.
Strong integrations. WordPress plugin, Google Docs add-on, Jasper integration, and API access (Enterprise) mean Surfer fits into existing workflows.
Active development. Surfer ships meaningful feature updates regularly. The January 2026 restructuring and subsequent feature releases show a product team that is investing heavily.

Cons

Surfer AI credits cost extra. The base subscription does not include AI-generated articles. This adds up if you rely heavily on AI writing.
No free tier. Unlike MarketMuse (limited free plan) or Frase (low entry price), Surfer starts at $99/month with no free option.
SERP Analyzer is locked to Scale plan. The detailed SERP analysis tool requires the $219/month plan. This is a significant limitation for Essential plan users who want deeper competitive research.
Learning curve exists. While the new Workflow tab helps, Surfer has more features and data points than simpler tools like Clearscope. New users need time to understand what matters.
Content Score is not a ranking guarantee. A score of 90 does not mean you will rank first. Domain authority, backlinks, site speed, and hundreds of other factors still matter. Surfer optimizes content, not your entire SEO profile.
Keyword data is estimated. Surfer's built-in keyword research uses estimated search volumes, not exact data from Google Ads. For precise volume data, you still need a dedicated keyword research tool.

How Surfer Fits Into a Modern Content Workflow

Surfer is most powerful when integrated into a broader content operation rather than used in isolation. Here is how it fits with other tools in a modern content stack:

Planning → Execution → Distribution → Optimization

Planning: Use Surfer's Topical Map to identify content opportunities. Pair this with Notion AI for content planning and workspace management to organize your editorial calendar around Surfer's recommendations.
Execution: Write in Surfer's Content Editor or use Surfer AI for first drafts. If you are running an AI-powered content factory, tools like Claude Code for development workflows can help you build automation pipelines around your content process.
Distribution: Once published, promote across channels. Automation platforms can help syndicate content — see our comparison of Zapier, Make, and n8n for choosing the right automation tool. If newsletters are part of your distribution strategy, our Newsletter Revenue Calculator can help you model the revenue potential before investing in list building.
Optimization: Use Content Audit to continuously improve published content. AI Tracker monitors your visibility in AI search results.

This cyclical workflow — plan, write, distribute, optimize, repeat — is how content teams compound their organic traffic over time. Surfer fits into the writing and optimization phases.

For teams running content operations with AI agents, the combination of Surfer's data-driven optimization with AI-powered workflows creates a scalable system. We run our own content factory using 14 AI agents coordinated through Paperclip, and tools like Surfer provide the optimization data that guides our content quality standards.

If you are building AI workflows for content operations, self-hosting Dify as your AI workflow platform can integrate with Surfer's data through custom API connections at the Enterprise level.

Frequently Asked Questions

Is Surfer SEO worth it in 2026?

Yes, if organic search traffic is important to your business and you publish content regularly. The Content Editor alone provides enough value to justify the $99/month Essential plan for teams publishing 10+ articles per month. The ROI comes from higher rankings, which translate to more traffic without paying for ads. If you publish infrequently (less than 5 articles per month), consider Frase as a more budget-friendly alternative.

Does Surfer SEO actually improve rankings?

Surfer optimizes your on-page content based on what is currently ranking. This is one factor among many that determine rankings. Content Score improvements correlate with ranking improvements, but they do not guarantee them. Domain authority, backlinks, site speed, user experience, and search intent alignment all matter too. Surfer makes your content competitive — it does not replace a comprehensive SEO strategy.

Can I use Surfer SEO with WordPress?

Yes. Surfer offers a WordPress plugin that connects your Content Editor directly to your WordPress posts. You can also copy optimized content from Surfer and paste it into any CMS. Google Docs integration is also available if you prefer writing there first.

How is Surfer AI different from ChatGPT for content?

Surfer AI generates content that is pre-optimized for your target keyword based on SERP analysis. ChatGPT generates generic text without any SEO context. Surfer AI articles come with built-in keyword distribution, heading structure, and NLP term coverage that align with what is currently ranking. ChatGPT requires you to manually optimize the output afterward.

Does Surfer SEO offer a free trial?

Surfer does not maintain a permanent free tier. They occasionally run promotional trials — check surferseo.com for current offers. There is no commitment-free way to test the full platform, which is a drawback compared to tools like MarketMuse that offer limited free plans.

How many articles can I write per month with Surfer?

The Essential plan ($99/month) includes 30 Content Editor articles per month. The Scale plan ($219/month) includes 100 articles. Enterprise plans have custom limits. Surfer AI articles consume separate credits purchased on top of your subscription.

Can Surfer SEO help with existing content?

Yes — this is one of Surfer's strongest use cases. The Content Audit feature connects to Google Search Console, scans your published pages, and provides specific optimization recommendations for each one. Many users see faster results from updating existing content than from publishing new articles.

Does Surfer work for languages other than English?

Yes. Surfer supports content optimization in multiple languages. The SERP analysis adapts to the target language and location, analyzing local search results. The accuracy of NLP analysis may vary by language — English has the deepest coverage.

What is the Surfer SEO affiliate program?

Surfer runs its affiliate program through PartnerStack. The program uses a tiered CPA commission model — affiliates earn a one-time payout based on the customer's first payment. Monthly subscription referrals earn a percentage of the first month's fee. Annual subscription referrals earn a percentage of the full annual amount upfront. Commission rates increase as you refer more customers. Details at surferseo.com/affiliate-program.

Can I cancel my Surfer SEO subscription anytime?

Yes. Monthly plans can be cancelled at any time. Annual plans are billed upfront for the full year. Check Surfer's pricing FAQ for current cancellation and refund policies.

Final Verdict

Surfer SEO is the most comprehensive content optimization platform available in 2026. The Content Editor remains best-in-class, the Content Audit provides tangible ROI for existing sites, and newer features like AI Tracker position Surfer well for the evolving search landscape.

The main barriers are price ($99/month minimum with no free tier) and complexity (more features means a steeper learning curve than simpler tools). If those are deal-breakers, Frase offers solid optimization at a lower price point, and Clearscope offers a simpler experience at a higher one.

For content teams serious about organic search performance, Surfer provides the data, tools, and AI capabilities to consistently produce content that ranks. It is not magic — you still need good content strategy, domain authority, and technical SEO. But for the on-page optimization piece of the puzzle, Surfer is the tool we recommend.

Ready to try Surfer SEO? Visit surferseo.com to explore their plans and start optimizing your content with data-driven insights.

How to Self-Host n8n with Docker — AI Workflow Automation Guide 2026

Jangwook Kim — Sun, 05 Apr 2026 14:27:36 +0000

Originally published on Effloow

How to Self-Host n8n with Docker — AI Workflow Automation Guide 2026

n8n Cloud's Pro plan costs €60 per month for 30,000 executions. A self-hosted n8n instance on a $5 VPS handles unlimited executions. Same software, same features, 12x cost difference.

n8n is an open-source workflow automation platform with 1,400+ integrations and a visual node editor. It started as a Zapier alternative, but in 2026 it has evolved into something more interesting: a visual AI workflow engine where you can chain LLM calls, vector database queries, and tool-using agents — all without writing orchestration code.

This guide walks you through self-hosting n8n with Docker Compose, from initial setup to a working AI workflow with Ollama for local LLM inference. We will build a practical AI agent that can search the web, process documents, and generate structured output — running entirely on your own infrastructure.

By the end, you will have a production-ready n8n instance with PostgreSQL persistence, Ollama integration for private AI inference, and the knowledge to build AI workflows that would cost hundreds on Zapier or Make.

What Is n8n?

n8n (pronounced "nodemation") is an open-source, source-available workflow automation platform. You connect nodes on a visual canvas to build automations — triggers, data transformations, API calls, AI model invocations — and n8n executes them on schedule or in response to events.

Feature	Detail
GitHub stars	70,000+ (as of April 2026)
Current version	2.14.2
License	Sustainable Use License (source-available)
Integrations	1,400+ built-in nodes
AI capabilities	LLM chains, AI agents, vector stores, embeddings
Deployment	Docker (self-hosted), n8n Cloud, or npm

Why n8n stands out in 2026

Most automation platforms treat AI as a bolt-on feature — a single "call GPT" action buried among 7,000 other integrations. n8n treats AI as a first-class workflow primitive.

The platform ships with dedicated nodes for:

LLM chains — connect any model (OpenAI, Anthropic, Google, Ollama) to structured prompts with output parsing
AI agents — autonomous agents with tool use, memory, and multi-step reasoning
Vector stores — Qdrant, Pinecone, Supabase, and more for RAG workflows
Embeddings — generate and query embeddings from multiple providers
Document loaders — ingest PDFs, web pages, and databases into your AI pipelines

If you have used Dify for AI-specific workflows, think of n8n as the broader automation layer. Dify excels at RAG chatbots and prompt engineering. n8n excels at connecting AI to everything else — your CRM, email, databases, APIs, and file systems.

n8n's execution model

This matters for understanding the cost advantage. Zapier charges per "task" — every individual action in a workflow counts. A 5-step workflow triggered 1,000 times burns 5,000 tasks. Make.com charges per "operation" — similar granularity.

n8n counts per "execution." One execution = one complete workflow run, regardless of how many nodes it contains. A 20-node workflow that processes 1,000 webhook events uses 1,000 executions, not 20,000.

On self-hosted n8n, there is no execution limit at all. You pay for the server. That is it.

Why Self-Host n8n? The Cost Breakdown

The cost math for self-hosting n8n is straightforward and dramatic.

n8n Cloud pricing (as of April 2026)

Plan	Price	Executions/month	Active workflows
Starter	€24/mo	2,500	15
Pro	€60/mo	10,000+	50
Enterprise	Custom	Custom	Unlimited

Source: n8n.io/pricing — verify current pricing before purchasing.

Self-hosted cost

Component	Monthly cost
VPS (Hetzner CX22, 2 vCPU, 4GB RAM)	€4.35/mo
Domain name (amortized)	~$1/mo
SSL certificate (Let's Encrypt)	Free
Total	~$5.50/mo

That is unlimited executions, unlimited active workflows, and full data sovereignty for the price of a coffee.

When n8n Cloud makes more sense

Self-hosting is not always the right choice. n8n Cloud is worth the premium if:

You need multi-user access control without configuring LDAP/OIDC yourself
You want zero maintenance — no Docker updates, no backups to manage
Your team does not have anyone comfortable with basic server administration
You need enterprise SSO and audit logging out of the box

For solo developers, small teams, and anyone who already manages their own infrastructure, self-hosting is the obvious path. If that describes you, our guide to self-hosting your entire dev stack under $20/month covers the broader infrastructure context.

Comparison with other platforms

We covered this in detail in our Zapier vs Make vs n8n comparison, but here is the executive summary:

Scenario	Zapier	Make.com	n8n Cloud	n8n Self-Hosted
1,000 runs/day, 5 steps each	$300+/mo	~$19/mo	€60/mo	~$5/mo
AI workflow (LLM + tools)	$50+/mo add-on	$9+/mo add-on	Included	Included
Data stays on your server	No	No	No	Yes
Custom code nodes	Limited	Yes	Yes	Yes
Self-hostable	No	No	N/A	Yes

Prerequisites

Before starting, make sure you have:

A server or local machine with at least 2 CPU cores and 2GB RAM (4GB recommended for AI workloads)
Docker Engine 24+ and Docker Compose v2 installed
A domain name (for production with SSL — optional for local development)
Basic comfort with the terminal

Recommended servers

For a dedicated self-hosted n8n instance, we recommend:

Local development: Any machine with Docker installed (Mac, Linux, or Windows with WSL2)
Production VPS: Hetzner Cloud CX22 (2 vCPU, 4GB RAM, €4.35/mo) — see our Hetzner Cloud setup guide
AI workloads with local LLMs: Hetzner CAX21 ARM server (4 vCPU, 8GB RAM, €7.49/mo) or a machine with a GPU

If you plan to run Ollama alongside n8n for local AI inference, budget at least 8GB of RAM. Small models like Llama 3.2 (3B) run well on 8GB; larger models like Llama 3.1 (70B) need a GPU server. See our Ollama self-hosting guide for model sizing details.

Method 1: n8n Self-Hosted AI Starter Kit (Recommended)

n8n maintains an official Self-Hosted AI Starter Kit that bundles n8n with PostgreSQL, Ollama, and Qdrant (a vector database). This is the fastest path to a working AI workflow setup.

Step 1: Clone the repository

git clone https://github.com/n8n-io/self-hosted-ai-starter-kit.git
cd self-hosted-ai-starter-kit

Step 2: Configure environment variables

cp .env.example .env

Edit the .env file with secure values:

# .env — CHANGE THESE VALUES
POSTGRES_USER=n8n_user
POSTGRES_PASSWORD=your-secure-password-here
POSTGRES_DB=n8n

N8N_ENCRYPTION_KEY=generate-a-random-32-char-string
N8N_USER_MANAGEMENT_JWT_SECRET=generate-another-random-string
N8N_DEFAULT_BINARY_DATA_MODE=filesystem

# Uncomment for Mac/Apple Silicon running Ollama locally
# OLLAMA_HOST=host.docker.internal:11434

Generate secure random strings for the encryption keys:

openssl rand -hex 32  # Run twice — once for each key

Important: The N8N_ENCRYPTION_KEY encrypts stored credentials. If you lose it, all saved credentials become unreadable. Back it up somewhere safe.

Step 3: Start the stack

Choose the command that matches your hardware:

# NVIDIA GPU (recommended for AI workloads)
docker compose --profile gpu-nvidia up -d

# AMD GPU (Linux only)
docker compose --profile gpu-amd up -d

# CPU only (works everywhere, slower AI inference)
docker compose --profile cpu up -d

# Mac / Apple Silicon (uses host Ollama — install Ollama separately)
docker compose up -d

The first run pulls several Docker images and downloads the Llama 3.2 model (about 2GB). This takes a few minutes depending on your connection speed.

Step 4: Access n8n

Open your browser and navigate to:

http://localhost:5678

You will see the n8n setup screen. Create your admin account — this is the owner account for your instance. Choose a strong password.

What the starter kit includes

The Docker Compose stack runs five services:

Service	Image	Purpose	Port
n8n	`n8nio/n8n:latest`	Workflow automation engine	5678
PostgreSQL	`postgres:16-alpine`	Persistent data storage	5432 (internal)
Ollama	`ollama/ollama:latest`	Local LLM inference	11434
Qdrant	`qdrant/qdrant`	Vector database for RAG	6333
n8n-import	`n8nio/n8n:latest`	One-time demo data import	—

The starter kit also includes a demo AI workflow that you can access at http://localhost:5678/workflow/srOnR8PAY3u4RSwb after setup. It demonstrates an AI chatbot chain using Ollama — a good starting point for understanding n8n's AI capabilities.

Method 2: Minimal n8n Setup (Without AI Stack)

If you only need workflow automation without the AI components, a simpler setup with just n8n and PostgreSQL is lighter on resources.

Docker Compose for minimal n8n

Create a docker-compose.yml file:

volumes:
  n8n_storage:
  postgres_storage:

services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - postgres_storage:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -h localhost -U ${POSTGRES_USER} -d ${POSTGRES_DB}']
      interval: 5s
      timeout: 5s
      retries: 10

  n8n:
    image: n8nio/n8n:2.14.2
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_USER_MANAGEMENT_JWT_SECRET=${N8N_USER_MANAGEMENT_JWT_SECRET}
      - N8N_DIAGNOSTICS_ENABLED=false
    volumes:
      - n8n_storage:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

Create the .env file:

POSTGRES_USER=n8n_user
POSTGRES_PASSWORD=your-secure-password
POSTGRES_DB=n8n

N8N_ENCRYPTION_KEY=your-random-encryption-key
N8N_USER_MANAGEMENT_JWT_SECRET=your-random-jwt-secret

Start it:

docker compose up -d

This minimal setup uses roughly 512MB of RAM — suitable for even the smallest VPS instances.

Building Your First AI Workflow

Now that n8n is running, let us build a practical AI workflow. We will create an AI-powered content summarizer that:

Receives a URL via webhook
Fetches the web page content
Sends it to an LLM for summarization
Returns the summary as a structured JSON response

Step 1: Create a new workflow

In the n8n editor (http://localhost:5678), click "Add Workflow" in the top-right corner. Name it "AI Content Summarizer."

Step 2: Add a Webhook trigger

Click the + button to add a node
Search for "Webhook" and select it
Set the HTTP Method to POST
Set the path to summarize
Under "Respond," select "Using 'Respond to Webhook' Node" — this lets us return the AI-generated summary

Step 3: Add an HTTP Request node

Add a new node after the Webhook
Search for "HTTP Request"
Set the URL to: {{ $json.body.url }} — this reads the URL from the incoming webhook payload
Set the method to GET
Under "Options," set Response Format to "String" — we want the raw HTML

Step 4: Add an AI chain

Add a "Basic LLM Chain" node
Connect it to the HTTP Request output
Configure the model:
- If using Ollama (from the starter kit): select Ollama Chat Model and choose llama3.2
- If using an API: select OpenAI Chat Model or Anthropic Chat Model and add your API credentials
Set the prompt:

Summarize the following web page content in 3-5 bullet points. Focus on the key facts and actionable information. Return the summary as JSON with the format: {"title": "...", "bullets": ["...", "..."], "word_count": N}

Content:
{{ $json.data }}

Step 5: Add a Respond to Webhook node

Add a "Respond to Webhook" node at the end
Set "Respond With" to "All Incoming Items"

Step 6: Test it

Activate the workflow, then call it:

curl -X POST http://localhost:5678/webhook/summarize \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com"}'

You should receive a JSON response with the AI-generated summary.

This basic pattern — trigger → fetch data → AI processing → structured output — is the foundation for most AI automation workflows. From here, you can add error handling, conditional branches, database storage, and notification steps.

Advanced: AI Agent Workflows with Tool Use

n8n's AI Agent node goes beyond simple LLM chains. It creates autonomous agents that can reason, use tools, and take multi-step actions — similar to what you would build with LangGraph or CrewAI in code, but configured visually.

What an AI Agent can do in n8n

An n8n AI Agent node combines:

An LLM (any supported model) for reasoning
Tools that the agent can call: HTTP requests, code execution, database queries, web search
Memory for multi-turn conversations
Output parsers for structured responses

Building a research agent

Here is a workflow pattern for an AI research agent:

Webhook trigger — receives a research question
AI Agent node configured with:
- Model: Ollama (llama3.2) or Claude/GPT-4 via API
- Tools:
  - SerpAPI or Google Search node — for web research
  - HTTP Request tool — for fetching specific pages
  - Code tool — for data processing and calculations
- System prompt: "You are a research assistant. Search the web to answer questions thoroughly. Cite your sources with URLs."
Respond to Webhook — returns the agent's research report

The agent autonomously decides which tools to use, in what order, and how many times — based on the question and intermediate results.

Agent tool configuration

To add tools to an AI Agent node:

Click the AI Agent node
Under "Tools," click "Add Tool"
Select from available tool nodes (Calculator, Code, HTTP Request, SerpAPI, etc.)
Each tool gets a name and description that the LLM uses to decide when to invoke it

The key insight is that the tool descriptions matter as much as the system prompt. Write clear, specific descriptions so the agent knows when each tool is appropriate.

Memory for multi-turn conversations

For chatbot-style workflows, add a Window Buffer Memory or Postgres Chat Memory sub-node to the AI Agent. This gives the agent conversation context across multiple interactions.

With PostgreSQL already in your stack, Postgres Chat Memory is the natural choice — sessions persist across n8n restarts and you get full conversation history in your database.

n8n vs Zapier vs Make: When to Choose What

We wrote a detailed comparison of all four platforms. Here is the decision framework:

Choose Zapier if:

You need the largest integration library (7,000+ apps)
Your team is non-technical and needs the simplest interface
Budget is not a primary constraint
You need enterprise compliance certifications

Choose Make.com if:

You need complex multi-branch workflows at scale
You want the best price-to-operations ratio on a managed platform
Your workflows involve heavy data transformation
You do not want to manage infrastructure

Choose n8n (self-hosted) if:

You want AI workflow automation as a first-class feature
You need unlimited executions at a fixed server cost
Data sovereignty matters — GDPR, client contracts, or privacy requirements
You are comfortable with Docker and basic server management
You want to run local LLMs via Ollama without API costs

Choose n8n Cloud if:

You want n8n's features without managing infrastructure
You need managed scaling and high availability
Your execution volume fits within the tier pricing

Production Deployment Tips

Running n8n locally is one thing. Running it reliably in production requires a few more steps.

Reverse proxy with Caddy

For production deployments, put n8n behind a reverse proxy with automatic SSL. Caddy is the simplest option.

Add Caddy to your docker-compose.yml:

  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data

Create a Caddyfile:

n8n.yourdomain.com {
    reverse_proxy n8n:5678
}

Add WEBHOOK_URL=https://n8n.yourdomain.com to your n8n environment variables so webhook URLs resolve correctly.

Backups

Your n8n data lives in two places:

PostgreSQL database — workflow definitions, credentials (encrypted), execution logs
n8n_storage volume — binary data, encryption keys

Automate daily backups:

#!/bin/bash
# backup-n8n.sh
BACKUP_DIR="/backups/n8n/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"

# Database backup
docker compose exec -T postgres pg_dump -U n8n_user n8n > "$BACKUP_DIR/n8n-db.sql"

# Volume backup
docker run --rm -v n8n_storage:/data -v "$BACKUP_DIR":/backup alpine \
  tar czf /backup/n8n-storage.tar.gz -C /data .

echo "Backup completed: $BACKUP_DIR"

Run this daily via cron:

0 3 * * * /path/to/backup-n8n.sh

Updating n8n

Pin your n8n version in docker-compose.yml (e.g., n8nio/n8n:2.14.2 instead of latest) and update deliberately:

# 1. Backup first
./backup-n8n.sh

# 2. Update the image tag in docker-compose.yml

# 3. Pull and restart
docker compose pull n8n
docker compose up -d n8n

Check the n8n release notes before updating. Major version bumps may include breaking changes to workflow nodes.

Credential encryption

n8n encrypts stored credentials using the N8N_ENCRYPTION_KEY environment variable. If this key is lost or changed, all saved credentials become unreadable.

Best practices:

Generate a strong key: openssl rand -hex 32
Store it outside the server (password manager, encrypted backup)
Never commit .env files to version control
Set the key before creating any credentials — changing it later requires re-entering all credentials

Resource monitoring

For a typical self-hosted n8n instance:

Metric	Idle	Under load (50 concurrent workflows)
CPU	<5%	30-60% (2 cores)
RAM (n8n only)	~200MB	~500MB
RAM (full AI stack)	~2GB	~4GB+
Disk I/O	Minimal	Moderate (execution logs)

If running AI workloads with Ollama, the LLM inference is the bottleneck. Monitor Ollama's memory usage separately — a 3B parameter model uses about 2GB of RAM, while a 7B model needs 4-5GB.

Five Practical AI Automation Examples

Here are five n8n workflows you can build today with the self-hosted AI stack.

1. Email triage agent

Trigger: New email arrives (IMAP or Gmail node)
AI Agent: Classifies email as urgent/normal/spam, extracts action items
Actions: Labels email, creates tasks in your project management tool, sends Slack alert for urgent items
Model: Llama 3.2 (3B) via Ollama — fast enough for classification tasks

2. RSS-to-summary pipeline

Trigger: RSS Feed trigger (check every hour)
AI Chain: Summarizes each new article in 3 bullet points
Output: Posts summaries to a Slack channel or Discord server
Model: Any LLM — this is a straightforward summarization task

3. Customer support auto-responder

Trigger: Webhook from your support system
AI Agent with tools: Searches knowledge base (Qdrant vector store), drafts a response
Human review: Sends draft to Slack for approval before sending
Model: Claude or GPT-4 via API for quality-sensitive responses

4. Document processor

Trigger: File uploaded to a watched folder or S3 bucket
Processing: Extract text from PDF, split into chunks, generate embeddings
Storage: Store embeddings in Qdrant for later RAG queries
Model: Ollama for embeddings, any LLM for subsequent queries

5. Competitor monitoring dashboard

Trigger: Scheduled (daily)
Web scraping: HTTP Request nodes fetch competitor pages
AI Analysis: Compares changes, identifies new features or pricing updates
Output: Generates a daily digest email with structured comparison data
Model: Llama 3.2 via Ollama for cost-free daily runs

Each of these workflows runs on the same $5/month server. On Zapier, the email triage agent alone would cost $50+/month due to the per-task billing on multi-step workflows.

Connecting n8n to Local LLMs via Ollama

If you used the AI Starter Kit, Ollama is already running. Here is how to configure n8n to use it.

Adding Ollama as a credential

In any AI node, click the Model parameter
Select "Ollama Chat Model" or "Ollama"
Create new credentials:
- Base URL: http://ollama:11434 (inside Docker network) or http://localhost:11434 (if Ollama runs on the host)
Select your model (e.g., llama3.2)

Pulling additional models

To download more models into your Ollama instance:

docker compose exec ollama ollama pull mistral
docker compose exec ollama ollama pull codellama
docker compose exec ollama ollama pull nomic-embed-text  # For embeddings

For a complete guide on Ollama model selection, hardware requirements, and optimization, see our Ollama + Open WebUI self-hosting guide.

When to use local LLMs vs API models

Use case	Recommended model	Why
Classification, tagging	Llama 3.2 (3B) via Ollama	Fast, free, good enough for structured tasks
Summarization	Llama 3.2 (3B) or Mistral via Ollama	Adequate quality for internal summaries
Customer-facing content	Claude or GPT-4 via API	Higher quality matters when customers see the output
Code generation	CodeLlama via Ollama or Claude via API	Depends on complexity and quality requirements
Embeddings	nomic-embed-text via Ollama	Free, fast, runs locally — no reason to pay for API embeddings

The hybrid approach works well: use local Ollama models for high-volume, internal tasks and API models for customer-facing or quality-critical outputs.

Frequently Asked Questions

Is n8n really free to self-host?

The n8n Community Edition is free to self-host under the Sustainable Use License. You can use it for your own projects and business automations. The license restricts reselling n8n as a hosted service. For most self-hosting use cases, it is effectively free.

How many workflows can self-hosted n8n handle?

There is no artificial limit on workflows or executions. The practical limit is your server's CPU and RAM. A 2-core, 4GB RAM VPS comfortably handles 50+ active workflows with moderate traffic. For high-volume scenarios (thousands of executions per minute), scale vertically or run n8n in queue mode with multiple workers.

Can I use n8n with OpenAI and Anthropic APIs?

Yes. n8n has native credential types for OpenAI, Anthropic, Google AI, Hugging Face, and many more. Add your API key in the credentials settings and select the corresponding model in any AI node. You can mix and match providers within the same workflow.

How do I update n8n without losing data?

Pin your version, backup your database and volumes, update the image tag in docker-compose.yml, then run docker compose pull && docker compose up -d. Your workflows, credentials, and execution history are stored in PostgreSQL and survive container updates.

Is self-hosted n8n secure enough for production?

n8n encrypts stored credentials, supports LDAP/OIDC/SAML authentication, and provides role-based access control. For production, add a reverse proxy with SSL (Caddy or Nginx), keep the instance updated, restrict network access to port 443, and use strong encryption keys. The self-hosted version gives you more security control than any cloud platform because you own the network boundary.

Can n8n replace Zapier for a small team?

For most use cases, yes. n8n covers the same integration patterns — triggers, API calls, data transformation, scheduling — with 1,400+ built-in nodes. The main gap is Zapier's larger app library (7,000+ apps). If the specific integrations you need exist in n8n (check the n8n integrations page), you will save significant money by switching.

How does n8n compare to Dify for AI workflows?

They serve different purposes. Dify is purpose-built for AI: RAG chatbots, prompt engineering, model management. n8n is a general-purpose automation platform with strong AI capabilities added. Use Dify when your entire workflow is AI (chat interfaces, document Q&A). Use n8n when you need AI as part of a broader automation that connects to external services, databases, and APIs.

What We Learned Running n8n

At Effloow, we run 14 AI agents for content production, SEO analysis, and site management. n8n handles our workflow automation layer — connecting agents to external services, scheduling recurring tasks, and processing webhooks from various platforms.

Three things we learned the hard way:

Pin your n8n version. We initially ran :latest and an automatic update broke a webhook workflow in production. Pin to a specific version and update manually after testing.
Set up execution log pruning. By default, n8n stores all execution data. After a month of active workflows, our PostgreSQL database grew to 8GB. Set EXECUTIONS_DATA_PRUNE=true and EXECUTIONS_DATA_MAX_AGE=168 (hours) to auto-prune old execution data.
The AI Starter Kit is the right starting point. We initially set up n8n alone and added Ollama later. The starter kit's Docker Compose configuration handles the networking, volume mounts, and service dependencies correctly from the start. Save yourself the debugging.

Getting Started: Your First 30 Minutes

Here is a concrete plan for your first session with self-hosted n8n:

Minutes 0-10: Clone the AI Starter Kit, configure .env, run docker compose --profile cpu up -d
Minutes 10-15: Open http://localhost:5678, create your admin account, explore the demo workflow
Minutes 15-25: Build the AI Content Summarizer workflow from the tutorial above
Minutes 25-30: Test the webhook, iterate on the prompt, try switching between Ollama and an API model

After that, explore n8n's workflow templates library — there are hundreds of community-built workflows you can import and customize.

Self-hosting n8n is one of the highest-ROI moves for any developer or small team building with AI. Unlimited automations, local LLM inference, and full data control — all for the cost of a small VPS.

n8n is open-source software maintained by n8n GmbH. This guide covers the self-hosted Community Edition. For managed hosting with support, see n8n Cloud (affiliate link — we earn a commission at no extra cost to you).